Jack2
1.9.10
|
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