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