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