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 "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
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
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
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 }