Jack2 1.9.6

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