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 "JackGlobals.h"
00025 #include "JackClient.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, samplerate, capturing, playing, inchannels, outchannels, monitor, capture_driver_name, playback_driver_name, capture_latency, playback_latency);
00059 }
00060
00061 int JackThreadedDriver::Close()
00062 {
00063 return fDriver->Close();
00064 }
00065
00066 int JackThreadedDriver::Process()
00067 {
00068 return fDriver->Process();
00069 }
00070
00071 int JackThreadedDriver::ProcessNull()
00072 {
00073 return fDriver->ProcessNull();
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::ProcessSlaves()
00132 {
00133 return fDriver->ProcessSlaves();
00134 }
00135
00136 int JackThreadedDriver::ClientNotify(int refnum, const char* name, int notify, int sync, int value1, int value2)
00137 {
00138 return fDriver->ClientNotify(refnum, name, notify, sync, value1, value2);
00139 }
00140
00141 JackClientControl* JackThreadedDriver::GetClientControl() const
00142 {
00143 return fDriver->GetClientControl();
00144 }
00145
00146 bool JackThreadedDriver::IsRealTime() const
00147 {
00148 return fDriver->IsRealTime();
00149 }
00150
00151 int JackThreadedDriver::Start()
00152 {
00153 jack_log("JackThreadedDriver::Start");
00154
00155 if (fDriver->Start() < 0) {
00156 jack_error("Cannot start driver");
00157 return -1;
00158 }
00159 if (fThread.StartSync() < 0) {
00160 jack_error("Cannot start thread");
00161 return -1;
00162 }
00163
00164 return 0;
00165 }
00166
00167 int JackThreadedDriver::Stop()
00168 {
00169 jack_log("JackThreadedDriver::Stop");
00170
00171 switch (fThread.GetStatus()) {
00172
00173
00174 case JackThread::kStarting:
00175 case JackThread::kIniting:
00176 if (fThread.Kill() < 0) {
00177 jack_error("Cannot kill thread");
00178 return -1;
00179 }
00180 break;
00181
00182
00183 case JackThread::kRunning:
00184 if (fThread.Stop() < 0) {
00185 jack_error("Cannot stop thread");
00186 return -1;
00187 }
00188 break;
00189
00190 default:
00191 break;
00192 }
00193
00194 if (fDriver->Stop() < 0) {
00195 jack_error("Cannot stop driver");
00196 return -1;
00197 }
00198 return 0;
00199 }
00200
00201 bool JackThreadedDriver::Execute()
00202 {
00203 return (Process() == 0);
00204 }
00205
00206 bool JackThreadedDriver::Init()
00207 {
00208 if (fDriver->Init()) {
00209 if (fDriver->IsRealTime()) {
00210 jack_log("JackThreadedDriver::Init IsRealTime");
00211
00212 fThread.SetParams(GetEngineControl()->fPeriod, GetEngineControl()->fComputation, GetEngineControl()->fConstraint);
00213 if (fThread.AcquireRealTime(GetEngineControl()->fPriority) < 0) {
00214 jack_error("AcquireRealTime error");
00215 } else {
00216 set_threaded_log_function();
00217 }
00218 }
00219 return true;
00220 } else {
00221 return false;
00222 }
00223 }
00224
00225 }