Jack2 1.9.6

JackDriver.cpp

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