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 audio driver");
00072 return -1;
00073 }
00074
00075 fClientControl.fRefNum = refnum;
00076 fClientControl.fActive = true;
00077 fGraphManager->DirectConnect(fClientControl.fRefNum, fClientControl.fRefNum);
00078 SetupDriverSync(fClientControl.fRefNum, false);
00079 return 0;
00080 }
00081
00082 int JackDriver::Open(jack_nframes_t buffer_size,
00083 jack_nframes_t samplerate,
00084 bool capturing,
00085 bool playing,
00086 int inchannels,
00087 int outchannels,
00088 bool monitor,
00089 const char* capture_driver_name,
00090 const char* playback_driver_name,
00091 jack_nframes_t capture_latency,
00092 jack_nframes_t playback_latency)
00093 {
00094 jack_log("JackDriver::Open capture_driver_name = %s", capture_driver_name);
00095 jack_log("JackDriver::Open playback_driver_name = %s", playback_driver_name);
00096 int refnum = -1;
00097
00098 if (fEngine->ClientInternalOpen(fClientControl.fName, &refnum, &fEngineControl, &fGraphManager, this, false) != 0) {
00099 jack_error("Cannot allocate internal client for audio driver");
00100 return -1;
00101 }
00102
00103 fClientControl.fRefNum = refnum;
00104 fClientControl.fActive = true;
00105 fEngineControl->fBufferSize = buffer_size;
00106 fEngineControl->fSampleRate = samplerate;
00107 fCaptureLatency = capture_latency;
00108 fPlaybackLatency = playback_latency;
00109
00110 assert(strlen(capture_driver_name) < JACK_CLIENT_NAME_SIZE);
00111 assert(strlen(playback_driver_name) < JACK_CLIENT_NAME_SIZE);
00112
00113 strcpy(fCaptureDriverName, capture_driver_name);
00114 strcpy(fPlaybackDriverName, playback_driver_name);
00115
00116 fEngineControl->fPeriodUsecs = jack_time_t(1000000.f / fEngineControl->fSampleRate * fEngineControl->fBufferSize);
00117 if (!fEngineControl->fTimeOut)
00118 fEngineControl->fTimeOutUsecs = jack_time_t(2.f * fEngineControl->fPeriodUsecs);
00119
00120 fGraphManager->SetBufferSize(buffer_size);
00121 fGraphManager->DirectConnect(fClientControl.fRefNum, fClientControl.fRefNum);
00122 SetupDriverSync(fClientControl.fRefNum, false);
00123 return 0;
00124 }
00125
00126 int JackDriver::Close()
00127 {
00128 jack_log("JackDriver::Close");
00129 fGraphManager->DirectDisconnect(fClientControl.fRefNum, fClientControl.fRefNum);
00130 fClientControl.fActive = false;
00131 return fEngine->ClientInternalClose(fClientControl.fRefNum, false);
00132 }
00133
00139 void JackDriver::SetupDriverSync(int ref, bool freewheel)
00140 {
00141 if (!freewheel && !fEngineControl->fSyncMode) {
00142 jack_log("JackDriver::SetupDriverSync driver sem in flush mode");
00143 fSynchroTable[ref].SetFlush(true);
00144 } else {
00145 jack_log("JackDriver::SetupDriverSync driver sem in normal mode");
00146 fSynchroTable[ref].SetFlush(false);
00147 }
00148 }
00149
00150 int JackDriver::ClientNotify(int refnum, const char* name, int notify, int sync, int value1, int value2)
00151 {
00152 switch (notify) {
00153
00154 case kStartFreewheelCallback:
00155 jack_log("JackDriver::kStartFreewheel");
00156 SetupDriverSync(fClientControl.fRefNum, true);
00157 break;
00158
00159 case kStopFreewheelCallback:
00160 jack_log("JackDriver::kStopFreewheel");
00161 SetupDriverSync(fClientControl.fRefNum, false);
00162 break;
00163 }
00164
00165 return 0;
00166 }
00167
00168 bool JackDriver::IsRealTime() const
00169 {
00170 return fEngineControl->fRealTime;
00171 }
00172
00173 void JackDriver::CycleIncTime()
00174 {
00175 fEngineControl->CycleIncTime(fBeginDateUst);
00176 }
00177
00178 void JackDriver::CycleTakeBeginTime()
00179 {
00180 fBeginDateUst = GetMicroSeconds();
00181 fEngineControl->CycleIncTime(fBeginDateUst);
00182 }
00183
00184 void JackDriver::CycleTakeEndTime()
00185 {
00186 fEndDateUst = GetMicroSeconds();
00187 }
00188
00189 JackClientControl* JackDriver::GetClientControl() const
00190 {
00191 return (JackClientControl*)&fClientControl;
00192 }
00193
00194 void JackDriver::NotifyXRun(jack_time_t cur_cycle_begin, float delayed_usecs)
00195 {
00196 fEngine->NotifyXRun(cur_cycle_begin, delayed_usecs);
00197 }
00198
00199 void JackDriver::NotifyBufferSize(jack_nframes_t buffer_size)
00200 {
00201 fEngine->NotifyBufferSize(buffer_size);
00202 fEngineControl->InitFrameTime();
00203 }
00204
00205 void JackDriver::NotifySampleRate(jack_nframes_t sample_rate)
00206 {
00207 fEngine->NotifySampleRate(sample_rate);
00208 fEngineControl->InitFrameTime();
00209 }
00210
00211 void JackDriver::SetMaster(bool onoff)
00212 {
00213 fIsMaster = onoff;
00214 }
00215
00216 bool JackDriver::GetMaster()
00217 {
00218 return fIsMaster;
00219 }
00220
00221 void JackDriver::AddSlave(JackDriverInterface* slave)
00222 {
00223 fSlaveList.push_back(slave);
00224 }
00225
00226 void JackDriver::RemoveSlave(JackDriverInterface* slave)
00227 {
00228 fSlaveList.remove(slave);
00229 }
00230
00231 int JackDriver::ProcessSlaves()
00232 {
00233 int res = 0;
00234 list<JackDriverInterface*>::const_iterator it;
00235 for (it = fSlaveList.begin(); it != fSlaveList.end(); it++) {
00236 JackDriverInterface* slave = *it;
00237 if (slave->Process() < 0)
00238 res = -1;
00239 }
00240 return res;
00241 }
00242
00243 int JackDriver::Process()
00244 {
00245 return 0;
00246 }
00247
00248 int JackDriver::ProcessNull()
00249 {
00250 return 0;
00251 }
00252
00253 int JackDriver::Attach()
00254 {
00255 return 0;
00256 }
00257
00258 int JackDriver::Detach()
00259 {
00260 return 0;
00261 }
00262
00263 int JackDriver::Read()
00264 {
00265 return 0;
00266 }
00267
00268 int JackDriver::Write()
00269 {
00270 return 0;
00271 }
00272
00273 int JackDriver::Start()
00274 {
00275 return 0;
00276 }
00277
00278 int JackDriver::Stop()
00279 {
00280 return 0;
00281 }
00282
00283 bool JackDriver::IsFixedBufferSize()
00284 {
00285 return true;
00286 }
00287
00288 int JackDriver::SetBufferSize(jack_nframes_t buffer_size)
00289 {
00290 return 0;
00291 }
00292
00293 int JackDriver::SetSampleRate(jack_nframes_t sample_rate)
00294 {
00295 return 0;
00296 }
00297
00298 bool JackDriver::Init()
00299 {
00300 return true;
00301 }
00302
00303
00304 }