Jack2  1.9.10
JackThreadedDriver.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 "JackThreadedDriver.h"
00023 #include "JackError.h"
00024 #include "JackTools.h"
00025 #include "JackGlobals.h"
00026 #include "JackEngineControl.h"
00027 
00028 namespace Jack
00029 {
00030 
00031 JackThreadedDriver::JackThreadedDriver(JackDriver* driver):fThread(this),fDriver(driver)
00032 {}
00033 
00034 JackThreadedDriver::~JackThreadedDriver()
00035 {
00036     delete fDriver;
00037 }
00038 
00039 int JackThreadedDriver::Open()
00040 {
00041     return fDriver->Open();
00042 }
00043 
00044 int JackThreadedDriver::Open(jack_nframes_t buffer_size,
00045                              jack_nframes_t samplerate,
00046                              bool capturing,
00047                              bool playing,
00048                              int inchannels,
00049                              int outchannels,
00050                              bool monitor,
00051                              const char* capture_driver_name,
00052                              const char* playback_driver_name,
00053                              jack_nframes_t capture_latency,
00054                              jack_nframes_t playback_latency)
00055 {
00056     return fDriver->Open(buffer_size,
00057                         samplerate, capturing,
00058                         playing, inchannels,
00059                         outchannels, monitor,
00060                         capture_driver_name, playback_driver_name,
00061                         capture_latency, playback_latency);
00062 }
00063 
00064 int JackThreadedDriver::Close()
00065 {
00066     return fDriver->Close();
00067 }
00068 
00069 int JackThreadedDriver::Process()
00070 {
00071     return fDriver->Process();
00072 }
00073 
00074 int JackThreadedDriver::Attach()
00075 {
00076     return fDriver->Attach();
00077 }
00078 
00079 int JackThreadedDriver::Detach()
00080 {
00081     return fDriver->Detach();
00082 }
00083 
00084 int JackThreadedDriver::Read()
00085 {
00086     return fDriver->Read();
00087 }
00088 
00089 int JackThreadedDriver::Write()
00090 {
00091     return fDriver->Write();
00092 }
00093 
00094 bool JackThreadedDriver::IsFixedBufferSize()
00095 {
00096     return fDriver->IsFixedBufferSize();
00097 }
00098 
00099 int JackThreadedDriver::SetBufferSize(jack_nframes_t buffer_size)
00100 {
00101     return fDriver->SetBufferSize(buffer_size);
00102 }
00103 
00104 int JackThreadedDriver::SetSampleRate(jack_nframes_t sample_rate)
00105 {
00106     return fDriver->SetSampleRate(sample_rate);
00107 }
00108 
00109 void JackThreadedDriver::SetMaster(bool onoff)
00110 {
00111     fDriver->SetMaster(onoff);
00112 }
00113 
00114 bool JackThreadedDriver::GetMaster()
00115 {
00116     return fDriver->GetMaster();
00117 }
00118 
00119 void JackThreadedDriver::AddSlave(JackDriverInterface* slave)
00120 {
00121     fDriver->AddSlave(slave);
00122 }
00123 
00124 void JackThreadedDriver::RemoveSlave(JackDriverInterface* slave)
00125 {
00126     fDriver->RemoveSlave(slave);
00127 }
00128 
00129 int JackThreadedDriver::ProcessReadSlaves()
00130 {
00131     return fDriver->ProcessReadSlaves();
00132 }
00133 
00134 int JackThreadedDriver::ProcessWriteSlaves()
00135 {
00136     return fDriver->ProcessWriteSlaves();
00137 }
00138 
00139 int JackThreadedDriver::ProcessRead()
00140 {
00141     return fDriver->ProcessRead();
00142 }
00143 
00144 int JackThreadedDriver::ProcessWrite()
00145 {
00146     return fDriver->ProcessWrite();
00147 }
00148 
00149 int JackThreadedDriver::ProcessReadSync()
00150 {
00151     return fDriver->ProcessReadSync();
00152 }
00153 
00154 int JackThreadedDriver::ProcessWriteSync()
00155 {
00156     return fDriver->ProcessWriteSync();
00157 }
00158 
00159 int JackThreadedDriver::ProcessReadAsync()
00160 {
00161     return fDriver->ProcessReadAsync();
00162 }
00163 
00164 int JackThreadedDriver::ProcessWriteAsync()
00165 {
00166     return fDriver->ProcessWriteAsync();
00167 }
00168 
00169 std::list<JackDriverInterface*> JackThreadedDriver::GetSlaves()
00170 {
00171     return fDriver->GetSlaves();
00172 }
00173 
00174 int JackThreadedDriver::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2)
00175 {
00176     return fDriver->ClientNotify(refnum, name, notify, sync, message, value1, value2);
00177 }
00178 
00179 JackClientControl* JackThreadedDriver::GetClientControl() const
00180 {
00181     return fDriver->GetClientControl();
00182 }
00183 
00184 bool JackThreadedDriver::IsRealTime() const
00185 {
00186     return fDriver->IsRealTime();
00187 }
00188 
00189 bool JackThreadedDriver::IsRunning() const
00190 {
00191     return fDriver->IsRunning();
00192 }
00193 
00194 int JackThreadedDriver::Start()
00195 {
00196     jack_log("JackThreadedDriver::Start");
00197 
00198     if (fDriver->Start() < 0) {
00199         jack_error("Cannot start driver");
00200         return -1;
00201     }
00202     if (fThread.StartSync() < 0) {
00203         jack_error("Cannot start thread");
00204         return -1;
00205     }
00206 
00207     return 0;
00208 }
00209 
00210 int JackThreadedDriver::Stop()
00211 {
00212     jack_log("JackThreadedDriver::Stop");
00213 
00214     switch (fThread.GetStatus()) {
00215 
00216         // Kill the thread in Init phase
00217         case JackThread::kStarting:
00218         case JackThread::kIniting:
00219             if (fThread.Kill() < 0) {
00220                 jack_error("Cannot kill thread");
00221             }
00222             break;
00223 
00224         // Stop when the thread cycle is finished
00225         case JackThread::kRunning:
00226             if (fThread.Stop() < 0) {
00227                 jack_error("Cannot stop thread");
00228             }
00229             break;
00230 
00231         default:
00232             break;
00233     }
00234 
00235     if (fDriver->Stop() < 0) {
00236         jack_error("Cannot stop driver");
00237         return -1;
00238     }
00239     return 0;
00240 }
00241 
00242 bool JackThreadedDriver::Execute()
00243 {
00244     return (Process() == 0);
00245 }
00246 
00247 bool JackThreadedDriver::Init()
00248 {
00249     if (fDriver->Initialize())  {
00250         SetRealTime();
00251         return true;
00252     } else {
00253         return false;
00254     }
00255 }
00256 
00257 void JackThreadedDriver::SetRealTime()
00258 {
00259     if (fDriver->IsRealTime()) {
00260         jack_log("JackThreadedDriver::Init real-time");
00261         // Will do "something" on OSX only...
00262         GetEngineControl()->fPeriod = GetEngineControl()->fConstraint = GetEngineControl()->fPeriodUsecs * 1000;
00263         GetEngineControl()->fComputation = JackTools::ComputationMicroSec(GetEngineControl()->fBufferSize) * 1000;
00264         fThread.SetParams(GetEngineControl()->fPeriod, GetEngineControl()->fComputation, GetEngineControl()->fConstraint);
00265         if (fThread.AcquireSelfRealTime(GetEngineControl()->fServerPriority) < 0) {
00266             jack_error("AcquireSelfRealTime error");
00267         } else {
00268             set_threaded_log_function();
00269         }
00270     } else {
00271         jack_log("JackThreadedDriver::Init non-realtime");
00272     }
00273 }
00274 
00275 
00276 } // end of namespace