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 bool JackThreadedDriver::IsRunning() const
00156 {
00157 return fDriver->IsRunning();
00158 }
00159
00160 int JackThreadedDriver::Start()
00161 {
00162 jack_log("JackThreadedDriver::Start");
00163
00164 if (fDriver->Start() < 0) {
00165 jack_error("Cannot start driver");
00166 return -1;
00167 }
00168 if (fThread.StartSync() < 0) {
00169 jack_error("Cannot start thread");
00170 return -1;
00171 }
00172
00173 return 0;
00174 }
00175
00176 int JackThreadedDriver::Stop()
00177 {
00178 jack_log("JackThreadedDriver::Stop");
00179
00180 switch (fThread.GetStatus()) {
00181
00182
00183 case JackThread::kStarting:
00184 case JackThread::kIniting:
00185 if (fThread.Kill() < 0) {
00186 jack_error("Cannot kill thread");
00187 return -1;
00188 }
00189 break;
00190
00191
00192 case JackThread::kRunning:
00193 if (fThread.Stop() < 0) {
00194 jack_error("Cannot stop thread");
00195 return -1;
00196 }
00197 break;
00198
00199 default:
00200 break;
00201 }
00202
00203 if (fDriver->Stop() < 0) {
00204 jack_error("Cannot stop driver");
00205 return -1;
00206 }
00207 return 0;
00208 }
00209
00210 bool JackThreadedDriver::Execute()
00211 {
00212 return (Process() == 0);
00213 }
00214
00215 bool JackThreadedDriver::Init()
00216 {
00217 if (fDriver->Initialize()) {
00218 if (fDriver->IsRealTime()) {
00219 jack_log("JackThreadedDriver::Init IsRealTime");
00220
00221 GetEngineControl()->fPeriod = GetEngineControl()->fConstraint = GetEngineControl()->fPeriodUsecs * 1000;
00222 fThread.SetParams(GetEngineControl()->fPeriod, GetEngineControl()->fComputation, GetEngineControl()->fConstraint);
00223 if (fThread.AcquireSelfRealTime(GetEngineControl()->fServerPriority) < 0) {
00224 jack_error("AcquireSelfRealTime error");
00225 } else {
00226 set_threaded_log_function();
00227 }
00228 }
00229 return true;
00230 } else {
00231 return false;
00232 }
00233 }
00234
00235 }