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 jack_log("JackDriver::Close");
00171 fGraphManager->DirectDisconnect(fClientControl.fRefNum, fClientControl.fRefNum);
00172 fClientControl.fActive = false;
00173 fEngineControl->fDriverNum--;
00174 return fEngine->ClientInternalClose(fClientControl.fRefNum, false);
00175 }
00176
00182 void JackDriver::SetupDriverSync(int ref, bool freewheel)
00183 {
00184 if (!freewheel && !fEngineControl->fSyncMode) {
00185 jack_log("JackDriver::SetupDriverSync driver sem in flush mode");
00186 fSynchroTable[ref].SetFlush(true);
00187 } else {
00188 jack_log("JackDriver::SetupDriverSync driver sem in normal mode");
00189 fSynchroTable[ref].SetFlush(false);
00190 }
00191 }
00192
00193 int JackDriver::ClientNotify(int refnum, const char* name, int notify, int sync, int value1, int value2)
00194 {
00195 switch (notify) {
00196
00197 case kStartFreewheelCallback:
00198 jack_log("JackDriver::kStartFreewheel");
00199 SetupDriverSync(fClientControl.fRefNum, true);
00200 break;
00201
00202 case kStopFreewheelCallback:
00203 jack_log("JackDriver::kStopFreewheel");
00204 SetupDriverSync(fClientControl.fRefNum, false);
00205 break;
00206 }
00207
00208 return 0;
00209 }
00210
00211 bool JackDriver::IsRealTime() const
00212 {
00213 return fEngineControl->fRealTime;
00214 }
00215
00216 void JackDriver::CycleIncTime()
00217 {
00218 fEngineControl->CycleIncTime(fBeginDateUst);
00219 }
00220
00221 void JackDriver::CycleTakeBeginTime()
00222 {
00223 fBeginDateUst = GetMicroSeconds();
00224 fEngineControl->CycleIncTime(fBeginDateUst);
00225 }
00226
00227 void JackDriver::CycleTakeEndTime()
00228 {
00229 fEndDateUst = GetMicroSeconds();
00230 }
00231
00232 JackClientControl* JackDriver::GetClientControl() const
00233 {
00234 return (JackClientControl*)&fClientControl;
00235 }
00236
00237 void JackDriver::NotifyXRun(jack_time_t cur_cycle_begin, float delayed_usecs)
00238 {
00239 fEngine->NotifyXRun(cur_cycle_begin, delayed_usecs);
00240 }
00241
00242 void JackDriver::NotifyBufferSize(jack_nframes_t buffer_size)
00243 {
00244 fEngine->NotifyBufferSize(buffer_size);
00245 fEngineControl->InitFrameTime();
00246 }
00247
00248 void JackDriver::NotifySampleRate(jack_nframes_t sample_rate)
00249 {
00250 fEngine->NotifySampleRate(sample_rate);
00251 fEngineControl->InitFrameTime();
00252 }
00253
00254 void JackDriver::SetMaster(bool onoff)
00255 {
00256 fIsMaster = onoff;
00257 }
00258
00259 bool JackDriver::GetMaster()
00260 {
00261 return fIsMaster;
00262 }
00263
00264 void JackDriver::AddSlave(JackDriverInterface* slave)
00265 {
00266 fSlaveList.push_back(slave);
00267 }
00268
00269 void JackDriver::RemoveSlave(JackDriverInterface* slave)
00270 {
00271 fSlaveList.remove(slave);
00272 }
00273
00274 int JackDriver::ProcessSlaves()
00275 {
00276 int res = 0;
00277 list<JackDriverInterface*>::const_iterator it;
00278 for (it = fSlaveList.begin(); it != fSlaveList.end(); it++) {
00279 JackDriverInterface* slave = *it;
00280 if (slave->Process() < 0)
00281 res = -1;
00282 }
00283 return res;
00284 }
00285
00286 int JackDriver::Process()
00287 {
00288 return 0;
00289 }
00290
00291 int JackDriver::ProcessNull()
00292 {
00293 return 0;
00294 }
00295
00296 int JackDriver::Attach()
00297 {
00298 return 0;
00299 }
00300
00301 int JackDriver::Detach()
00302 {
00303 return 0;
00304 }
00305
00306 int JackDriver::Read()
00307 {
00308 return 0;
00309 }
00310
00311 int JackDriver::Write()
00312 {
00313 return 0;
00314 }
00315
00316 int JackDriver::Start()
00317 {
00318 fEngineControl->InitFrameTime();
00319 return 0;
00320 }
00321
00322 int JackDriver::Stop()
00323 {
00324 return 0;
00325 }
00326
00327 bool JackDriver::IsFixedBufferSize()
00328 {
00329 return true;
00330 }
00331
00332 int JackDriver::SetBufferSize(jack_nframes_t buffer_size)
00333 {
00334 return 0;
00335 }
00336
00337 int JackDriver::SetSampleRate(jack_nframes_t sample_rate)
00338 {
00339 return 0;
00340 }
00341
00342 bool JackDriver::Initialize()
00343 {
00344 return true;
00345 }
00346
00347
00348 }