Jack2 1.9.6
|
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 (at your option) any later version. 00009 00010 This program is distributed in the hope that it will be useful, 00011 but WITHOUT ANY WARRANTY; without even the implied warranty of 00012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 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 "JackDriver.h" 00023 #include "JackTime.h" 00024 #include "JackError.h" 00025 #include "JackPort.h" 00026 #include "JackGraphManager.h" 00027 #include "JackGlobals.h" 00028 #include "JackEngineControl.h" 00029 #include "JackClientControl.h" 00030 #include "JackLockedEngine.h" 00031 #include <math.h> 00032 #include <assert.h> 00033 00034 using namespace std; 00035 00036 namespace Jack 00037 { 00038 00039 JackDriver::JackDriver(const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table) 00040 :fClientControl(name) 00041 { 00042 assert(strlen(name) < JACK_CLIENT_NAME_SIZE); 00043 fSynchroTable = table; 00044 strcpy(fAliasName, alias); 00045 fEngine = engine; 00046 fGraphManager = NULL; 00047 fBeginDateUst = 0; 00048 fDelayedUsecs = 0.f; 00049 fIsMaster = true; 00050 } 00051 00052 JackDriver::JackDriver() 00053 { 00054 fSynchroTable = NULL; 00055 fEngine = NULL; 00056 fGraphManager = NULL; 00057 fBeginDateUst = 0; 00058 fIsMaster = true; 00059 } 00060 00061 JackDriver::~JackDriver() 00062 { 00063 jack_log("~JackDriver"); 00064 } 00065 00066 int JackDriver::Open() 00067 { 00068 int refnum = -1; 00069 00070 if (fEngine->ClientInternalOpen(fClientControl.fName, &refnum, &fEngineControl, &fGraphManager, this, false) != 0) { 00071 jack_error("Cannot allocate internal client for driver"); 00072 return -1; 00073 } 00074 00075 fClientControl.fRefNum = refnum; 00076 fClientControl.fActive = true; 00077 fEngineControl->fDriverNum++; 00078 fGraphManager->DirectConnect(fClientControl.fRefNum, fClientControl.fRefNum); // Connect driver to itself for "sync" mode 00079 SetupDriverSync(fClientControl.fRefNum, false); 00080 return 0; 00081 } 00082 00083 int JackDriver::Open (bool capturing, 00084 bool playing, 00085 int inchannels, 00086 int outchannels, 00087 bool monitor, 00088 const char* capture_driver_name, 00089 const char* playback_driver_name, 00090 jack_nframes_t capture_latency, 00091 jack_nframes_t playback_latency) 00092 { 00093 jack_log("JackDriver::Open capture_driver_name = %s", capture_driver_name); 00094 jack_log("JackDriver::Open playback_driver_name = %s", playback_driver_name); 00095 int refnum = -1; 00096 00097 if (fEngine->ClientInternalOpen(fClientControl.fName, &refnum, &fEngineControl, &fGraphManager, this, false) != 0) { 00098 jack_error("Cannot allocate internal client for driver"); 00099 return -1; 00100 } 00101 00102 fClientControl.fRefNum = refnum; 00103 fClientControl.fActive = true; 00104 fEngineControl->fDriverNum++; 00105 fCaptureLatency = capture_latency; 00106 fPlaybackLatency = playback_latency; 00107 00108 assert(strlen(capture_driver_name) < JACK_CLIENT_NAME_SIZE); 00109 assert(strlen(playback_driver_name) < JACK_CLIENT_NAME_SIZE); 00110 00111 strcpy(fCaptureDriverName, capture_driver_name); 00112 strcpy(fPlaybackDriverName, playback_driver_name); 00113 00114 fEngineControl->fPeriodUsecs = jack_time_t(1000000.f / fEngineControl->fSampleRate * fEngineControl->fBufferSize); // in microsec 00115 if (!fEngineControl->fTimeOut) 00116 fEngineControl->fTimeOutUsecs = jack_time_t(2.f * fEngineControl->fPeriodUsecs); 00117 00118 fGraphManager->DirectConnect(fClientControl.fRefNum, fClientControl.fRefNum); // Connect driver to itself for "sync" mode 00119 SetupDriverSync(fClientControl.fRefNum, false); 00120 return 0; 00121 } 00122 00123 int JackDriver::Open(jack_nframes_t buffer_size, 00124 jack_nframes_t samplerate, 00125 bool capturing, 00126 bool playing, 00127 int inchannels, 00128 int outchannels, 00129 bool monitor, 00130 const char* capture_driver_name, 00131 const char* playback_driver_name, 00132 jack_nframes_t capture_latency, 00133 jack_nframes_t playback_latency) 00134 { 00135 jack_log("JackDriver::Open capture_driver_name = %s", capture_driver_name); 00136 jack_log("JackDriver::Open playback_driver_name = %s", playback_driver_name); 00137 int refnum = -1; 00138 00139 if (fEngine->ClientInternalOpen(fClientControl.fName, &refnum, &fEngineControl, &fGraphManager, this, false) != 0) { 00140 jack_error("Cannot allocate internal client for driver"); 00141 return -1; 00142 } 00143 00144 fClientControl.fRefNum = refnum; 00145 fClientControl.fActive = true; 00146 fEngineControl->fDriverNum++; 00147 fEngineControl->fBufferSize = buffer_size; 00148 fEngineControl->fSampleRate = samplerate; 00149 fCaptureLatency = capture_latency; 00150 fPlaybackLatency = playback_latency; 00151 00152 assert(strlen(capture_driver_name) < JACK_CLIENT_NAME_SIZE); 00153 assert(strlen(playback_driver_name) < JACK_CLIENT_NAME_SIZE); 00154 00155 strcpy(fCaptureDriverName, capture_driver_name); 00156 strcpy(fPlaybackDriverName, playback_driver_name); 00157 00158 fEngineControl->fPeriodUsecs = jack_time_t(1000000.f / fEngineControl->fSampleRate * fEngineControl->fBufferSize); // in microsec 00159 if (!fEngineControl->fTimeOut) 00160 fEngineControl->fTimeOutUsecs = jack_time_t(2.f * fEngineControl->fPeriodUsecs); 00161 00162 fGraphManager->SetBufferSize(buffer_size); 00163 fGraphManager->DirectConnect(fClientControl.fRefNum, fClientControl.fRefNum); // Connect driver to itself for "sync" mode 00164 SetupDriverSync(fClientControl.fRefNum, false); 00165 return 0; 00166 } 00167 00168 int JackDriver::Close() 00169 { 00170 if (fClientControl.fRefNum >= 0) { 00171 jack_log("JackDriver::Close"); 00172 fGraphManager->DirectDisconnect(fClientControl.fRefNum, fClientControl.fRefNum); // Disconnect driver from itself for sync 00173 fClientControl.fActive = false; 00174 fEngineControl->fDriverNum--; 00175 return fEngine->ClientInternalClose(fClientControl.fRefNum, false); 00176 } else { 00177 return -1; 00178 } 00179 } 00180 00186 void JackDriver::SetupDriverSync(int ref, bool freewheel) 00187 { 00188 if (!freewheel && !fEngineControl->fSyncMode) { 00189 jack_log("JackDriver::SetupDriverSync driver sem in flush mode"); 00190 fSynchroTable[ref].SetFlush(true); 00191 } else { 00192 jack_log("JackDriver::SetupDriverSync driver sem in normal mode"); 00193 fSynchroTable[ref].SetFlush(false); 00194 } 00195 } 00196 00197 int JackDriver::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2) 00198 { 00199 switch (notify) { 00200 00201 case kStartFreewheelCallback: 00202 jack_log("JackDriver::kStartFreewheel"); 00203 SetupDriverSync(fClientControl.fRefNum, true); 00204 break; 00205 00206 case kStopFreewheelCallback: 00207 jack_log("JackDriver::kStopFreewheel"); 00208 SetupDriverSync(fClientControl.fRefNum, false); 00209 break; 00210 } 00211 00212 return 0; 00213 } 00214 00215 bool JackDriver::IsRealTime() const 00216 { 00217 return fEngineControl->fRealTime; 00218 } 00219 00220 void JackDriver::CycleIncTime() 00221 { 00222 fEngineControl->CycleIncTime(fBeginDateUst); 00223 } 00224 00225 void JackDriver::CycleTakeBeginTime() 00226 { 00227 fBeginDateUst = GetMicroSeconds(); // Take callback date here 00228 fEngineControl->CycleIncTime(fBeginDateUst); 00229 } 00230 00231 void JackDriver::CycleTakeEndTime() 00232 { 00233 fEndDateUst = GetMicroSeconds(); // Take end date here 00234 } 00235 00236 JackClientControl* JackDriver::GetClientControl() const 00237 { 00238 return (JackClientControl*)&fClientControl; 00239 } 00240 00241 void JackDriver::NotifyXRun(jack_time_t cur_cycle_begin, float delayed_usecs) 00242 { 00243 fEngine->NotifyXRun(cur_cycle_begin, delayed_usecs); 00244 } 00245 00246 void JackDriver::NotifyBufferSize(jack_nframes_t buffer_size) 00247 { 00248 fEngine->NotifyBufferSize(buffer_size); 00249 fEngineControl->InitFrameTime(); 00250 } 00251 00252 void JackDriver::NotifySampleRate(jack_nframes_t sample_rate) 00253 { 00254 fEngine->NotifySampleRate(sample_rate); 00255 fEngineControl->InitFrameTime(); 00256 } 00257 00258 void JackDriver::NotifyFailure(int code, const char* reason) 00259 { 00260 fEngine->NotifyFailure(code, reason); 00261 } 00262 00263 void JackDriver::SetMaster(bool onoff) 00264 { 00265 fIsMaster = onoff; 00266 } 00267 00268 bool JackDriver::GetMaster() 00269 { 00270 return fIsMaster; 00271 } 00272 00273 void JackDriver::AddSlave(JackDriverInterface* slave) 00274 { 00275 fSlaveList.push_back(slave); 00276 } 00277 00278 void JackDriver::RemoveSlave(JackDriverInterface* slave) 00279 { 00280 fSlaveList.remove(slave); 00281 } 00282 00283 int JackDriver::ProcessSlaves() 00284 { 00285 int res = 0; 00286 list<JackDriverInterface*>::const_iterator it; 00287 for (it = fSlaveList.begin(); it != fSlaveList.end(); it++) { 00288 JackDriverInterface* slave = *it; 00289 if (slave->Process() < 0) 00290 res = -1; 00291 } 00292 return res; 00293 } 00294 00295 int JackDriver::Process() 00296 { 00297 return 0; 00298 } 00299 00300 int JackDriver::ProcessNull() 00301 { 00302 return 0; 00303 } 00304 00305 int JackDriver::Attach() 00306 { 00307 return 0; 00308 } 00309 00310 int JackDriver::Detach() 00311 { 00312 return 0; 00313 } 00314 00315 int JackDriver::Read() 00316 { 00317 return 0; 00318 } 00319 00320 int JackDriver::Write() 00321 { 00322 return 0; 00323 } 00324 00325 int JackDriver::Start() 00326 { 00327 fEngineControl->InitFrameTime(); 00328 return 0; 00329 } 00330 00331 int JackDriver::Stop() 00332 { 00333 return 0; 00334 } 00335 00336 bool JackDriver::IsFixedBufferSize() 00337 { 00338 return true; 00339 } 00340 00341 int JackDriver::SetBufferSize(jack_nframes_t buffer_size) 00342 { 00343 return 0; 00344 } 00345 00346 int JackDriver::SetSampleRate(jack_nframes_t sample_rate) 00347 { 00348 return 0; 00349 } 00350 00351 bool JackDriver::Initialize() 00352 { 00353 return true; 00354 } 00355 00356 00357 } // end of namespace