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