00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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);
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);
00115 if (!fEngineControl->fTimeOut)
00116 fEngineControl->fTimeOutUsecs = jack_time_t(2.f * fEngineControl->fPeriodUsecs);
00117
00118 fGraphManager->DirectConnect(fClientControl.fRefNum, fClientControl.fRefNum);
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);
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);
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);
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();
00228 fEngineControl->CycleIncTime(fBeginDateUst);
00229 }
00230
00231 void JackDriver::CycleTakeEndTime()
00232 {
00233 fEndDateUst = GetMicroSeconds();
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 }