common/JackThreadedDriver.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 "JackThreadedDriver.h"
  23 #include "JackError.h"
  24 #include "JackGlobals.h"
  25 #include "JackEngineControl.h"
  26
  27 namespace Jack
  28 {
  29
  30 JackThreadedDriver::JackThreadedDriver(JackDriver* driver):fThread(this)
  31 {
  32     fDriver = driver;
  33 }
  34
  35 JackThreadedDriver::~JackThreadedDriver()
  36 {
  37     delete fDriver;
  38 }
  39
  40 int JackThreadedDriver::Open()
  41 {
  42     return fDriver->Open();
  43 }
  44
  45 int JackThreadedDriver::Open(jack_nframes_t buffer_size,
  46                  jack_nframes_t samplerate,
  47                  bool capturing,
  48                  bool playing,
  49                  int inchannels,
  50                  int outchannels,
  51                  bool monitor,
  52                  const char* capture_driver_name,
  53                  const char* playback_driver_name,
  54                  jack_nframes_t capture_latency,
  55                  jack_nframes_t playback_latency)
  56 {
  57     return fDriver->Open(buffer_size, samplerate, capturing, playing, inchannels, outchannels, monitor, capture_driver_name, playback_driver_name, capture_latency, playback_latency);
  58 }
  59
  60 int JackThreadedDriver::Close()
  61 {
  62     return fDriver->Close();
  63 }
  64
  65 int JackThreadedDriver::Process()
  66 {
  67     return fDriver->Process();
  68 }
  69
  70 int JackThreadedDriver::ProcessNull()
  71 {
  72     return fDriver->ProcessNull();
  73 }
  74
  75 int JackThreadedDriver::Attach()
  76 {
  77     return fDriver->Attach();
  78 }
  79
  80 int JackThreadedDriver::Detach()
  81 {
  82     return fDriver->Detach();
  83 }
  84
  85 int JackThreadedDriver::Read()
  86 {
  87     return fDriver->Read();
  88 }
  89
  90 int JackThreadedDriver::Write()
  91 {
  92     return fDriver->Write();
  93 }
  94
  95 bool JackThreadedDriver::IsFixedBufferSize()
  96 {
  97     return fDriver->IsFixedBufferSize();
  98 }
  99
 100 int JackThreadedDriver::SetBufferSize(jack_nframes_t buffer_size)
 101 {
 102     return fDriver->SetBufferSize(buffer_size);
 103 }
 104
 105 int JackThreadedDriver::SetSampleRate(jack_nframes_t sample_rate)
 106 {
 107     return fDriver->SetSampleRate(sample_rate);
 108 }
 109
 110 void JackThreadedDriver::SetMaster(bool onoff)
 111 {
 112     fDriver->SetMaster(onoff);
 113 }
 114
 115 bool JackThreadedDriver::GetMaster()
 116 {
 117     return fDriver->GetMaster();
 118 }
 119
 120 void JackThreadedDriver::AddSlave(JackDriverInterface* slave)
 121 {
 122     fDriver->AddSlave(slave);
 123 }
 124
 125 void JackThreadedDriver::RemoveSlave(JackDriverInterface* slave)
 126 {
 127     fDriver->RemoveSlave(slave);
 128 }
 129
 130 int JackThreadedDriver::ProcessReadSlaves()
 131 {
 132     return fDriver->ProcessReadSlaves();
 133 }
 134
 135 int JackThreadedDriver::ProcessWriteSlaves()
 136 {
 137     return fDriver->ProcessWriteSlaves();
 138 }
 139
 140 int JackThreadedDriver::ProcessRead()
 141 {
 142     return fDriver->ProcessRead();
 143 }
 144
 145 int JackThreadedDriver::ProcessWrite()
 146 {
 147     return fDriver->ProcessWrite();
 148 }
 149
 150 std::list<JackDriverInterface*> JackThreadedDriver::GetSlaves()
 151 {
 152     return fDriver->GetSlaves();
 153 }
 154
 155 int JackThreadedDriver::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2)
 156 {
 157     return fDriver->ClientNotify(refnum, name, notify, sync, message, value1, value2);
 158 }
 159
 160 JackClientControl* JackThreadedDriver::GetClientControl() const
 161 {
 162     return fDriver->GetClientControl();
 163 }
 164
 165 bool JackThreadedDriver::IsRealTime() const
 166 {
 167     return fDriver->IsRealTime();
 168 }
 169
 170 bool JackThreadedDriver::IsRunning() const
 171 {
 172     return fDriver->IsRunning();
 173 }
 174
 175 int JackThreadedDriver::Start()
 176 {
 177     jack_log("JackThreadedDriver::Start");
 178
 179     if (fDriver->Start() < 0) {
 180         jack_error("Cannot start driver");
 181         return -1;
 182     }
 183     if (fThread.StartSync() < 0) {
 184         jack_error("Cannot start thread");
 185         return -1;
 186     }
 187
 188     return 0;
 189 }
 190
 191 int JackThreadedDriver::Stop()
 192 {
 193     jack_log("JackThreadedDriver::Stop");
 194
 195     switch (fThread.GetStatus()) {
 196
 197         // Kill the thread in Init phase
 198         case JackThread::kStarting:
 199         case JackThread::kIniting:
 200             if (fThread.Kill() < 0) {
 201                 jack_error("Cannot kill thread");
 202                 return -1;
 203             }
 204             break;
 205
 206         // Stop when the thread cycle is finished
 207         case JackThread::kRunning:
 208             if (fThread.Stop() < 0) {
 209                 jack_error("Cannot stop thread");
 210                 return -1;
 211             }
 212             break;
 213
 214         default:
 215             break;
 216     }
 217
 218     if (fDriver->Stop() < 0) {
 219         jack_error("Cannot stop driver");
 220         return -1;
 221     }
 222     return 0;
 223 }
 224
 225 bool JackThreadedDriver::Execute()
 226 {
 227     return (Process() == 0);
 228 }
 229
 230 bool JackThreadedDriver::Init()
 231 {
 232     if (fDriver->Initialize())  {
 233         if (fDriver->IsRealTime()) {
 234             jack_log("JackThreadedDriver::Init IsRealTime");
 235             // Will do "something" on OSX only...
 236             GetEngineControl()->fPeriod = GetEngineControl()->fConstraint = GetEngineControl()->fPeriodUsecs * 1000;
 237             fThread.SetParams(GetEngineControl()->fPeriod, GetEngineControl()->fComputation, GetEngineControl()->fConstraint);
 238             if (fThread.AcquireSelfRealTime(GetEngineControl()->fServerPriority) < 0) {
 239                 jack_error("AcquireSelfRealTime error");
 240             } else {
 241                 set_threaded_log_function();
 242             }
 243         }
 244         return true;
 245     } else {
 246         return false;
 247     }
 248 }
 249
 250 } // end of namespace