common/JackDriver.cpp

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004-2008 Grame
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include "JackSystemDeps.h"
  22 #include "JackDriver.h"
  23 #include "JackTime.h"
  24 #include "JackError.h"
  25 #include "JackPort.h"
  26 #include "JackGraphManager.h"
  27 #include "JackGlobals.h"
  28 #include "JackEngineControl.h"
  29 #include "JackClientControl.h"
  30 #include "JackLockedEngine.h"
  31 #include <math.h>
  32 #include <assert.h>
  33
  34 using namespace std;
  35
  36 namespace Jack
  37 {
  38
  39 JackDriver::JackDriver(const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table)
  40     :fClientControl(name)
  41 {
  42     assert(strlen(name) < JACK_CLIENT_NAME_SIZE);
  43     fSynchroTable = table;
  44     strcpy(fAliasName, alias);
  45     fEngine = engine;
  46     fGraphManager = NULL;
  47     fBeginDateUst = 0;
  48     fDelayedUsecs = 0.f;
  49     fIsMaster = true;
  50  }
  51
  52 JackDriver::JackDriver()
  53 {
  54     fSynchroTable = NULL;
  55     fEngine = NULL;
  56     fGraphManager = NULL;
  57     fBeginDateUst = 0;
  58     fIsMaster = true;
  59 }
  60
  61 JackDriver::~JackDriver()
  62 {
  63     jack_log("~JackDriver");
  64 }
  65
  66 int JackDriver::Open()
  67 {
  68     int refnum = -1;
  69
  70     if (fEngine->ClientInternalOpen(fClientControl.fName, &refnum, &fEngineControl, &fGraphManager, this, false) != 0) {
  71         jack_error("Cannot allocate internal client for driver");
  72         return -1;
  73     }
  74
  75     fClientControl.fRefNum = refnum;
  76     fClientControl.fActive = true;
  77     fEngineControl->fDriverNum++;
  78     fGraphManager->DirectConnect(fClientControl.fRefNum, fClientControl.fRefNum); // Connect driver to itself for "sync" mode
  79     SetupDriverSync(fClientControl.fRefNum, false);
  80     return 0;
  81 }
  82
  83 int JackDriver::Open (bool capturing,
  84                      bool playing,
  85                      int inchannels,
  86                      int outchannels,
  87                      bool monitor,
  88                      const char* capture_driver_name,
  89                      const char* playback_driver_name,
  90                      jack_nframes_t capture_latency,
  91                      jack_nframes_t playback_latency)
  92 {
  93     jack_log("JackDriver::Open capture_driver_name = %s", capture_driver_name);
  94     jack_log("JackDriver::Open playback_driver_name = %s", playback_driver_name);
  95     int refnum = -1;
  96
  97     if (fEngine->ClientInternalOpen(fClientControl.fName, &refnum, &fEngineControl, &fGraphManager, this, false) != 0) {
  98         jack_error("Cannot allocate internal client for driver");
  99         return -1;
 100     }
 101
 102     fClientControl.fRefNum = refnum;
 103     fClientControl.fActive = true;
 104     fEngineControl->fDriverNum++;
 105     fCaptureLatency = capture_latency;
 106     fPlaybackLatency = playback_latency;
 107
 108     assert(strlen(capture_driver_name) < JACK_CLIENT_NAME_SIZE);
 109     assert(strlen(playback_driver_name) < JACK_CLIENT_NAME_SIZE);
 110
 111     strcpy(fCaptureDriverName, capture_driver_name);
 112     strcpy(fPlaybackDriverName, playback_driver_name);
 113
 114     fEngineControl->fPeriodUsecs = jack_time_t(1000000.f / fEngineControl->fSampleRate * fEngineControl->fBufferSize); // in microsec
 115     if (!fEngineControl->fTimeOut)
 116         fEngineControl->fTimeOutUsecs = jack_time_t(2.f * fEngineControl->fPeriodUsecs);
 117
 118     fGraphManager->DirectConnect(fClientControl.fRefNum, fClientControl.fRefNum); // Connect driver to itself for "sync" mode
 119     SetupDriverSync(fClientControl.fRefNum, false);
 120     return 0;
 121 }
 122
 123 int JackDriver::Open(jack_nframes_t buffer_size,
 124                      jack_nframes_t samplerate,
 125                      bool capturing,
 126                      bool playing,
 127                      int inchannels,
 128                      int outchannels,
 129                      bool monitor,
 130                      const char* capture_driver_name,
 131                      const char* playback_driver_name,
 132                      jack_nframes_t capture_latency,
 133                      jack_nframes_t playback_latency)
 134 {
 135     jack_log("JackDriver::Open capture_driver_name = %s", capture_driver_name);
 136     jack_log("JackDriver::Open playback_driver_name = %s", playback_driver_name);
 137     int refnum = -1;
 138
 139     if (fEngine->ClientInternalOpen(fClientControl.fName, &refnum, &fEngineControl, &fGraphManager, this, false) != 0) {
 140         jack_error("Cannot allocate internal client for driver");
 141         return -1;
 142     }
 143
 144     fClientControl.fRefNum = refnum;
 145     fClientControl.fActive = true;
 146     fEngineControl->fDriverNum++;
 147     fEngineControl->fBufferSize = buffer_size;
 148     fEngineControl->fSampleRate = samplerate;
 149     fCaptureLatency = capture_latency;
 150     fPlaybackLatency = playback_latency;
 151
 152     assert(strlen(capture_driver_name) < JACK_CLIENT_NAME_SIZE);
 153     assert(strlen(playback_driver_name) < JACK_CLIENT_NAME_SIZE);
 154
 155     strcpy(fCaptureDriverName, capture_driver_name);
 156     strcpy(fPlaybackDriverName, playback_driver_name);
 157
 158     fEngineControl->fPeriodUsecs = jack_time_t(1000000.f / fEngineControl->fSampleRate * fEngineControl->fBufferSize); // in microsec
 159     if (!fEngineControl->fTimeOut)
 160         fEngineControl->fTimeOutUsecs = jack_time_t(2.f * fEngineControl->fPeriodUsecs);
 161
 162     fGraphManager->SetBufferSize(buffer_size);
 163     fGraphManager->DirectConnect(fClientControl.fRefNum, fClientControl.fRefNum); // Connect driver to itself for "sync" mode
 164     SetupDriverSync(fClientControl.fRefNum, false);
 165     return 0;
 166 }
 167
 168 int JackDriver::Close()
 169 {
 170     if (fClientControl.fRefNum > 0) {
 171         jack_log("JackDriver::Close");
 172         fGraphManager->DirectDisconnect(fClientControl.fRefNum, fClientControl.fRefNum); // Disconnect driver from itself for sync
 173         fClientControl.fActive = false;
 174         fEngineControl->fDriverNum--;
 175         return fEngine->ClientInternalClose(fClientControl.fRefNum, false);
 176     } else {
 177         return -1;
 178     }
 179 }
 180
 181 /*!
 182         In "async" mode, the server does not synchronize itself on the output drivers, thus it would never "consume" the activations.
 183         The synchronization primitives for drivers are setup in "flush" mode that to not keep unneeded activations.
 184         Drivers synchro are setup in "flush" mode if server is "async" and NOT freewheel.
 185 */
 186 void JackDriver::SetupDriverSync(int ref, bool freewheel)
 187 {
 188     if (!freewheel && !fEngineControl->fSyncMode) {
 189         jack_log("JackDriver::SetupDriverSync driver sem in flush mode");
 190         fSynchroTable[ref].SetFlush(true);
 191     } else {
 192         jack_log("JackDriver::SetupDriverSync driver sem in normal mode");
 193         fSynchroTable[ref].SetFlush(false);
 194     }
 195 }
 196
 197 int JackDriver::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2)
 198 {
 199     switch (notify) {
 200
 201         case kStartFreewheelCallback:
 202             jack_log("JackDriver::kStartFreewheel");
 203             SetupDriverSync(fClientControl.fRefNum, true);
 204             break;
 205
 206         case kStopFreewheelCallback:
 207             jack_log("JackDriver::kStopFreewheel");
 208             SetupDriverSync(fClientControl.fRefNum, false);
 209             break;
 210     }
 211
 212     return 0;
 213 }
 214
 215 bool JackDriver::IsRealTime() const
 216 {
 217     return fEngineControl->fRealTime;
 218 }
 219
 220 void JackDriver::CycleIncTime()
 221 {
 222     fEngineControl->CycleIncTime(fBeginDateUst);
 223 }
 224
 225 void JackDriver::CycleTakeBeginTime()
 226 {
 227     fBeginDateUst = GetMicroSeconds();  // Take callback date here
 228     fEngineControl->CycleIncTime(fBeginDateUst);
 229 }
 230
 231 void JackDriver::CycleTakeEndTime()
 232 {
 233     fEndDateUst = GetMicroSeconds();    // Take end date here
 234 }
 235
 236 JackClientControl* JackDriver::GetClientControl() const
 237 {
 238     return (JackClientControl*)&fClientControl;
 239 }
 240
 241 void JackDriver::NotifyXRun(jack_time_t cur_cycle_begin, float delayed_usecs)
 242 {
 243     fEngine->NotifyXRun(cur_cycle_begin, delayed_usecs);
 244 }
 245
 246 void JackDriver::NotifyBufferSize(jack_nframes_t buffer_size)
 247 {
 248     fEngine->NotifyBufferSize(buffer_size);
 249     fEngineControl->InitFrameTime();
 250 }
 251
 252 void JackDriver::NotifySampleRate(jack_nframes_t sample_rate)
 253 {
 254     fEngine->NotifySampleRate(sample_rate);
 255     fEngineControl->InitFrameTime();
 256 }
 257
 258 void JackDriver::NotifyFailure(int code, const char* reason)
 259 {
 260     fEngine->NotifyFailure(code, reason);
 261 }
 262
 263 void JackDriver::SetMaster(bool onoff)
 264 {
 265     fIsMaster = onoff;
 266 }
 267
 268 bool JackDriver::GetMaster()
 269 {
 270     return fIsMaster;
 271 }
 272
 273 void JackDriver::AddSlave(JackDriverInterface* slave)
 274 {
 275     fSlaveList.push_back(slave);
 276 }
 277
 278 void JackDriver::RemoveSlave(JackDriverInterface* slave)
 279 {
 280     fSlaveList.remove(slave);
 281 }
 282
 283 int JackDriver::ProcessSlaves()
 284 {
 285     int res = 0;
 286     list<JackDriverInterface*>::const_iterator it;
 287     for (it = fSlaveList.begin(); it != fSlaveList.end(); it++) {
 288         JackDriverInterface* slave = *it;
 289         if (slave->Process() < 0)
 290             res = -1;
 291     }
 292     return res;
 293 }
 294
 295 int JackDriver::Process()
 296 {
 297     return 0;
 298 }
 299
 300 int JackDriver::ProcessNull()
 301 {
 302     return 0;
 303 }
 304
 305 int JackDriver::Attach()
 306 {
 307     return 0;
 308 }
 309
 310 int JackDriver::Detach()
 311 {
 312     return 0;
 313 }
 314
 315 int JackDriver::Read()
 316 {
 317     return 0;
 318 }
 319
 320 int JackDriver::Write()
 321 {
 322     return 0;
 323 }
 324
 325 int JackDriver::Start()
 326 {
 327     fEngineControl->InitFrameTime();
 328     return 0;
 329 }
 330
 331 int JackDriver::Stop()
 332 {
 333     return 0;
 334 }
 335
 336 bool JackDriver::IsFixedBufferSize()
 337 {
 338     return true;
 339 }
 340
 341 int JackDriver::SetBufferSize(jack_nframes_t buffer_size)
 342 {
 343     return 0;
 344 }
 345
 346 int JackDriver::SetSampleRate(jack_nframes_t sample_rate)
 347 {
 348     return 0;
 349 }
 350
 351 bool JackDriver::Initialize()
 352 {
 353     return true;
 354 }
 355
 356
 357 } // end of namespace