Jack2 1.9.7

JackThreadedDriver.cpp

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 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         // Kill the thread in Init phase
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         // Stop when the thread cycle is finished
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             // Will do "something" on OSX only...
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 } // end of namespace

Generated for Jack2 by doxygen 1.7.3