Jack2
1.9.10
|
00001 /* 00002 Copyright (C) 2001 Paul Davis 00003 Copyright (C) 2004-2008 Grame. 00004 00005 This program is free software; you can redistribute it and/or modify 00006 it under the terms of the GNU General Public License as published by 00007 the Free Software Foundation; either version 2 of the License, or 00008 This program is distributed in the hope that it will be useful, 00009 but WITHOUT ANY WARRANTY; without even the implied warranty of 00010 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00011 (at your option) any later version. 00012 00013 GNU General Public License for more details. 00014 00015 You should have received a copy of the GNU General Public License 00016 along with this program; if not, write to the Free Software 00017 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 00018 00019 */ 00020 00021 #include "JackSystemDeps.h" 00022 #include "JackAudioDriver.h" 00023 #include "JackTime.h" 00024 #include "JackError.h" 00025 #include "JackEngineControl.h" 00026 #include "JackPort.h" 00027 #include "JackGraphManager.h" 00028 #include "JackLockedEngine.h" 00029 #include "JackException.h" 00030 #include <assert.h> 00031 00032 using namespace std; 00033 00034 namespace Jack 00035 { 00036 00037 JackAudioDriver::JackAudioDriver(const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table) 00038 : JackDriver(name, alias, engine, table) 00039 {} 00040 00041 JackAudioDriver::~JackAudioDriver() 00042 {} 00043 00044 int JackAudioDriver::SetBufferSize(jack_nframes_t buffer_size) 00045 { 00046 // Update engine and graph manager state 00047 fEngineControl->fBufferSize = buffer_size; 00048 fGraphManager->SetBufferSize(buffer_size); 00049 00050 fEngineControl->UpdateTimeOut(); 00051 UpdateLatencies(); 00052 00053 // Redirected on slaves drivers... 00054 return JackDriver::SetBufferSize(buffer_size); 00055 } 00056 00057 int JackAudioDriver::SetSampleRate(jack_nframes_t sample_rate) 00058 { 00059 fEngineControl->fSampleRate = sample_rate; 00060 fEngineControl->UpdateTimeOut(); 00061 00062 // Redirected on slaves drivers... 00063 return JackDriver::SetSampleRate(sample_rate); 00064 } 00065 00066 int JackAudioDriver::Open(jack_nframes_t buffer_size, 00067 jack_nframes_t samplerate, 00068 bool capturing, 00069 bool playing, 00070 int inchannels, 00071 int outchannels, 00072 bool monitor, 00073 const char* capture_driver_name, 00074 const char* playback_driver_name, 00075 jack_nframes_t capture_latency, 00076 jack_nframes_t playback_latency) 00077 { 00078 fCaptureChannels = inchannels; 00079 fPlaybackChannels = outchannels; 00080 fWithMonitorPorts = monitor; 00081 memset(fCapturePortList, 0, sizeof(jack_port_id_t) * DRIVER_PORT_NUM); 00082 memset(fPlaybackPortList, 0, sizeof(jack_port_id_t) * DRIVER_PORT_NUM); 00083 memset(fMonitorPortList, 0, sizeof(jack_port_id_t) * DRIVER_PORT_NUM); 00084 return JackDriver::Open(buffer_size, samplerate, capturing, playing, inchannels, outchannels, 00085 monitor, capture_driver_name, playback_driver_name, capture_latency, playback_latency); 00086 } 00087 00088 void JackAudioDriver::UpdateLatencies() 00089 { 00090 jack_latency_range_t input_range; 00091 jack_latency_range_t output_range; 00092 jack_latency_range_t monitor_range; 00093 00094 for (int i = 0; i < fCaptureChannels; i++) { 00095 input_range.max = input_range.min = fEngineControl->fBufferSize + fCaptureLatency; 00096 fGraphManager->GetPort(fCapturePortList[i])->SetLatencyRange(JackCaptureLatency, &input_range); 00097 } 00098 00099 for (int i = 0; i < fPlaybackChannels; i++) { 00100 output_range.max = output_range.min = fPlaybackLatency; 00101 if (fEngineControl->fSyncMode) { 00102 output_range.max = output_range.min += fEngineControl->fBufferSize; 00103 } else { 00104 output_range.max = output_range.min += fEngineControl->fBufferSize * 2; 00105 } 00106 fGraphManager->GetPort(fPlaybackPortList[i])->SetLatencyRange(JackPlaybackLatency, &output_range); 00107 if (fWithMonitorPorts) { 00108 monitor_range.min = monitor_range.max = fEngineControl->fBufferSize; 00109 fGraphManager->GetPort(fMonitorPortList[i])->SetLatencyRange(JackCaptureLatency, &monitor_range); 00110 } 00111 } 00112 } 00113 00114 int JackAudioDriver::Attach() 00115 { 00116 JackPort* port; 00117 jack_port_id_t port_index; 00118 char name[REAL_JACK_PORT_NAME_SIZE]; 00119 char alias[REAL_JACK_PORT_NAME_SIZE]; 00120 int i; 00121 00122 jack_log("JackAudioDriver::Attach fBufferSize = %ld fSampleRate = %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate); 00123 00124 for (i = 0; i < fCaptureChannels; i++) { 00125 snprintf(alias, sizeof(alias), "%s:%s:out%d", fAliasName, fCaptureDriverName, i + 1); 00126 snprintf(name, sizeof(name), "%s:capture_%d", fClientControl.fName, i + 1); 00127 if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, CaptureDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) { 00128 jack_error("driver: cannot register port for %s", name); 00129 return -1; 00130 } 00131 port = fGraphManager->GetPort(port_index); 00132 port->SetAlias(alias); 00133 fCapturePortList[i] = port_index; 00134 jack_log("JackAudioDriver::Attach fCapturePortList[i] port_index = %ld", port_index); 00135 } 00136 00137 for (i = 0; i < fPlaybackChannels; i++) { 00138 snprintf(alias, sizeof(alias), "%s:%s:in%d", fAliasName, fPlaybackDriverName, i + 1); 00139 snprintf(name, sizeof(name), "%s:playback_%d", fClientControl.fName, i + 1); 00140 if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, PlaybackDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) { 00141 jack_error("driver: cannot register port for %s", name); 00142 return -1; 00143 } 00144 port = fGraphManager->GetPort(port_index); 00145 port->SetAlias(alias); 00146 fPlaybackPortList[i] = port_index; 00147 jack_log("JackAudioDriver::Attach fPlaybackPortList[i] port_index = %ld", port_index); 00148 00149 // Monitor ports 00150 if (fWithMonitorPorts) { 00151 jack_log("Create monitor port"); 00152 snprintf(name, sizeof(name), "%s:monitor_%u", fClientControl.fName, i + 1); 00153 if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, fEngineControl->fBufferSize, &port_index) < 0) { 00154 jack_error("Cannot register monitor port for %s", name); 00155 return -1; 00156 } else { 00157 fMonitorPortList[i] = port_index; 00158 } 00159 } 00160 } 00161 00162 UpdateLatencies(); 00163 return 0; 00164 } 00165 00166 int JackAudioDriver::Detach() 00167 { 00168 int i; 00169 jack_log("JackAudioDriver::Detach"); 00170 00171 for (i = 0; i < fCaptureChannels; i++) { 00172 fEngine->PortUnRegister(fClientControl.fRefNum, fCapturePortList[i]); 00173 } 00174 00175 for (i = 0; i < fPlaybackChannels; i++) { 00176 fEngine->PortUnRegister(fClientControl.fRefNum, fPlaybackPortList[i]); 00177 if (fWithMonitorPorts) { 00178 fEngine->PortUnRegister(fClientControl.fRefNum, fMonitorPortList[i]); 00179 } 00180 } 00181 00182 return 0; 00183 } 00184 00185 int JackAudioDriver::Write() 00186 { 00187 for (int i = 0; i < fPlaybackChannels; i++) { 00188 if (fGraphManager->GetConnectionsNum(fPlaybackPortList[i]) > 0) { 00189 jack_default_audio_sample_t* buffer = GetOutputBuffer(i); 00190 int size = sizeof(jack_default_audio_sample_t) * fEngineControl->fBufferSize; 00191 // Monitor ports 00192 if (fWithMonitorPorts && fGraphManager->GetConnectionsNum(fMonitorPortList[i]) > 0) { 00193 memcpy(GetMonitorBuffer(i), buffer, size); 00194 } 00195 } 00196 } 00197 return 0; 00198 } 00199 00200 int JackAudioDriver::Process() 00201 { 00202 return (fEngineControl->fSyncMode) ? ProcessSync() : ProcessAsync(); 00203 } 00204 00205 /* 00206 The driver "asynchronous" mode: output buffers computed at the *previous cycle* are used, the server does not 00207 synchronize to the end of client graph execution. 00208 */ 00209 00210 int JackAudioDriver::ProcessAsync() 00211 { 00212 // Read input buffers for the current cycle 00213 if (Read() < 0) { 00214 jack_error("JackAudioDriver::ProcessAsync: read error, stopping..."); 00215 return -1; 00216 } 00217 00218 // Write output buffers from the previous cycle 00219 if (Write() < 0) { 00220 jack_error("JackAudioDriver::ProcessAsync: write error, stopping..."); 00221 return -1; 00222 } 00223 00224 // Process graph 00225 ProcessGraphAsync(); 00226 00227 // Keep end cycle time 00228 JackDriver::CycleTakeEndTime(); 00229 return 0; 00230 } 00231 00232 void JackAudioDriver::ProcessGraphAsync() 00233 { 00234 // Process graph 00235 if (fIsMaster) { 00236 ProcessGraphAsyncMaster(); 00237 } else { 00238 ProcessGraphAsyncSlave(); 00239 } 00240 } 00241 00242 /* 00243 Used when the driver works in master mode. 00244 */ 00245 00246 void JackAudioDriver::ProcessGraphAsyncMaster() 00247 { 00248 // fBeginDateUst is set in the "low level" layer, fEndDateUst is from previous cycle 00249 if (!fEngine->Process(fBeginDateUst, fEndDateUst)) { 00250 jack_error("JackAudioDriver::ProcessGraphAsyncMaster: Process error"); 00251 } 00252 00253 if (ResumeRefNum() < 0) { 00254 jack_error("JackAudioDriver::ProcessGraphAsyncMaster: ResumeRefNum error"); 00255 } 00256 00257 if (ProcessReadSlaves() < 0) { 00258 jack_error("JackAudioDriver::ProcessGraphAsyncMaster: ProcessReadSlaves error"); 00259 } 00260 00261 if (ProcessWriteSlaves() < 0) { 00262 jack_error("JackAudioDriver::ProcessGraphAsyncMaster: ProcessWriteSlaves error"); 00263 } 00264 00265 // Does not wait on graph execution end 00266 } 00267 00268 /* 00269 Used when the driver works in slave mode. 00270 */ 00271 00272 void JackAudioDriver::ProcessGraphAsyncSlave() 00273 { 00274 if (ResumeRefNum() < 0) { 00275 jack_error("JackAudioDriver::ProcessGraphAsyncSlave: ResumeRefNum error"); 00276 } 00277 } 00278 00279 /* 00280 The driver "synchronous" mode: the server does synchronize to the end of client graph execution, 00281 if graph process succeed, output buffers computed at the *current cycle* are used. 00282 */ 00283 00284 int JackAudioDriver::ProcessSync() 00285 { 00286 // Read input buffers for the current cycle 00287 if (Read() < 0) { 00288 jack_error("JackAudioDriver::ProcessSync: read error, stopping..."); 00289 return -1; 00290 } 00291 00292 // Process graph 00293 ProcessGraphSync(); 00294 00295 // Write output buffers from the current cycle 00296 if (Write() < 0) { 00297 jack_error("JackAudioDriver::ProcessSync: write error, stopping..."); 00298 return -1; 00299 } 00300 00301 // Keep end cycle time 00302 JackDriver::CycleTakeEndTime(); 00303 return 0; 00304 } 00305 00306 void JackAudioDriver::ProcessGraphSync() 00307 { 00308 // Process graph 00309 if (fIsMaster) { 00310 ProcessGraphSyncMaster(); 00311 } else { 00312 ProcessGraphSyncSlave(); 00313 } 00314 } 00315 00316 /* 00317 Used when the driver works in master mode. 00318 */ 00319 00320 void JackAudioDriver::ProcessGraphSyncMaster() 00321 { 00322 // fBeginDateUst is set in the "low level" layer, fEndDateUst is from previous cycle 00323 if (fEngine->Process(fBeginDateUst, fEndDateUst)) { 00324 00325 if (ResumeRefNum() < 0) { 00326 jack_error("JackAudioDriver::ProcessGraphSyncMaster: ResumeRefNum error"); 00327 } 00328 00329 if (ProcessReadSlaves() < 0) { 00330 jack_error("JackAudioDriver::ProcessGraphSync: ProcessReadSlaves error, engine may now behave abnormally!!"); 00331 } 00332 00333 if (ProcessWriteSlaves() < 0) { 00334 jack_error("JackAudioDriver::ProcessGraphSync: ProcessWriteSlaves error, engine may now behave abnormally!!"); 00335 } 00336 00337 // Waits for graph execution end 00338 if (SuspendRefNum() < 0) { 00339 jack_error("JackAudioDriver::ProcessGraphSync: SuspendRefNum error, engine may now behave abnormally!!"); 00340 } 00341 00342 } else { // Graph not finished: do not activate it 00343 jack_error("JackAudioDriver::ProcessGraphSync: Process error"); 00344 } 00345 } 00346 00347 /* 00348 Used when the driver works in slave mode. 00349 */ 00350 00351 void JackAudioDriver::ProcessGraphSyncSlave() 00352 { 00353 if (ResumeRefNum() < 0) { 00354 jack_error("JackAudioDriver::ProcessGraphSyncSlave: ResumeRefNum error"); 00355 } 00356 } 00357 00358 jack_default_audio_sample_t* JackAudioDriver::GetInputBuffer(int port_index) 00359 { 00360 return fCapturePortList[port_index] 00361 ? (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fCapturePortList[port_index], fEngineControl->fBufferSize) 00362 : NULL; 00363 } 00364 00365 jack_default_audio_sample_t* JackAudioDriver::GetOutputBuffer(int port_index) 00366 { 00367 return fPlaybackPortList[port_index] 00368 ? (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fPlaybackPortList[port_index], fEngineControl->fBufferSize) 00369 : NULL; 00370 } 00371 00372 jack_default_audio_sample_t* JackAudioDriver::GetMonitorBuffer(int port_index) 00373 { 00374 return fPlaybackPortList[port_index] 00375 ? (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fMonitorPortList[port_index], fEngineControl->fBufferSize) 00376 : NULL; 00377 } 00378 00379 int JackAudioDriver::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2) 00380 { 00381 switch (notify) { 00382 00383 case kLatencyCallback: 00384 HandleLatencyCallback(value1); 00385 break; 00386 00387 default: 00388 JackDriver::ClientNotify(refnum, name, notify, sync, message, value1, value2); 00389 break; 00390 } 00391 00392 return 0; 00393 } 00394 00395 void JackAudioDriver::HandleLatencyCallback(int status) 00396 { 00397 jack_latency_callback_mode_t mode = (status == 0) ? JackCaptureLatency : JackPlaybackLatency; 00398 00399 for (int i = 0; i < fCaptureChannels; i++) { 00400 if (mode == JackPlaybackLatency) { 00401 fGraphManager->RecalculateLatency(fCapturePortList[i], mode); 00402 } 00403 } 00404 00405 for (int i = 0; i < fPlaybackChannels; i++) { 00406 if (mode == JackCaptureLatency) { 00407 fGraphManager->RecalculateLatency(fPlaybackPortList[i], mode); 00408 } 00409 } 00410 } 00411 00412 } // end of namespace