JackDriver.h

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 #ifndef __JackDriver__
00022 #define __JackDriver__
00023 
00024 #include "types.h"
00025 #include "JackClientInterface.h"
00026 #include "JackConstants.h"
00027 #include <list>
00028 
00029 namespace Jack
00030 {
00031 
00032 class JackEngine;
00033 class JackGraphManager;
00034 class JackSynchro;
00035 struct JackEngineControl;
00036 struct JackClientControl;
00037 
00042 class EXPORT JackDriverInterface
00043 {
00044 
00045     public:
00046 
00047         JackDriverInterface()
00048         {}
00049         virtual ~JackDriverInterface()
00050         {}
00051 
00052         virtual int Open() = 0;
00053 
00054         virtual int Open(jack_nframes_t nframes,
00055                          jack_nframes_t samplerate,
00056                          bool capturing,
00057                          bool playing,
00058                          int inchannels,
00059                          int outchannels,
00060                          bool monitor,
00061                          const char* capture_driver_name,
00062                          const char* playback_driver_name,
00063                          jack_nframes_t capture_latency,
00064                          jack_nframes_t playback_latency) = 0;
00065 
00066         virtual int Attach() = 0;
00067         virtual int Detach() = 0;
00068         
00069         virtual int Read() = 0;
00070         virtual int Write() = 0;
00071                 
00072         virtual int Start() = 0;
00073         virtual int Stop() = 0;
00074         virtual int SetBufferSize(jack_nframes_t buffer_size) = 0;
00075                 virtual int SetSampleRate(jack_nframes_t sample_rate) = 0;
00076 
00077         virtual int Process() = 0;
00078 
00079         virtual void SetMaster(bool onoff) = 0;
00080         virtual bool GetMaster() = 0;
00081         virtual void AddSlave(JackDriverInterface* slave) = 0;
00082         virtual void RemoveSlave(JackDriverInterface* slave) = 0;
00083         virtual int ProcessSlaves() = 0;
00084 
00085         virtual bool IsRealTime() = 0;
00086 };
00087 
00092 class EXPORT JackDriverClientInterface : public JackDriverInterface, public JackClientInterface
00093 {};
00094 
00099 class EXPORT JackDriverClient : public JackDriverClientInterface
00100 {
00101     private:
00102 
00103         std::list<JackDriverInterface*> fSlaveList;
00104 
00105     protected:
00106 
00107         bool fIsMaster;
00108 
00109     public:
00110 
00111         virtual void SetMaster(bool onoff);
00112         virtual bool GetMaster();
00113         virtual void AddSlave(JackDriverInterface* slave);
00114         virtual void RemoveSlave(JackDriverInterface* slave);
00115         virtual int ProcessSlaves();
00116 };
00117 
00122 class EXPORT JackDriver : public JackDriverClient
00123 {
00124 
00125     protected:
00126 
00127         char fCaptureDriverName[JACK_CLIENT_NAME_SIZE];
00128         char fPlaybackDriverName[JACK_CLIENT_NAME_SIZE];
00129         jack_nframes_t fCaptureLatency;
00130         jack_nframes_t fPlaybackLatency;
00131         jack_time_t fLastWaitUst;
00132         JackEngine*     fEngine;
00133         JackGraphManager* fGraphManager;
00134         JackSynchro** fSynchroTable;
00135         JackEngineControl* fEngineControl;
00136         JackClientControl* fClientControl;
00137 
00138         JackClientControl* GetClientControl() const;
00139 
00140     public:
00141 
00142         JackDriver(const char* name, JackEngine* engine, JackSynchro** table);
00143         JackDriver();
00144         virtual ~JackDriver();
00145 
00146         virtual int Open();
00147 
00148         virtual int Open(jack_nframes_t nframes,
00149                          jack_nframes_t samplerate,
00150                          bool capturing,
00151                          bool playing,
00152                          int inchannels,
00153                          int outchannels,
00154                          bool monitor,
00155                          const char* capture_driver_name,
00156                          const char* playback_driver_name,
00157                          jack_nframes_t capture_latency,
00158                          jack_nframes_t playback_latency);
00159 
00160         virtual int Close();
00161 
00162         virtual int Process()
00163         {
00164             return 0;
00165         }
00166 
00167         virtual int Attach()
00168         {
00169             return 0;
00170         }
00171         virtual int Detach()
00172         {
00173             return 0;
00174         }
00175 
00176         virtual int Read()
00177         {
00178             return 0;
00179         }
00180         virtual int Write()
00181         {
00182             return 0;
00183         }
00184 
00185         virtual int Start()
00186         {
00187             return 0;
00188         }
00189         virtual int Stop()
00190         {
00191             return 0;
00192         }
00193 
00194         virtual int SetBufferSize(jack_nframes_t buffer_size)
00195         {
00196             return 0;
00197         }
00198                 
00199                 virtual int SetSampleRate(jack_nframes_t sample_rate)
00200                 {
00201             return 0;
00202         }
00203 
00204         void NotifyXRun(jack_time_t callback_usecs); // XRun notification sent by the driver
00205 
00206         virtual bool IsRealTime();
00207 
00208         int ClientNotify(int refnum, const char* name, int notify, int sync, int value1, int value2);
00209         
00210                 void SetupDriverSync(int ref, bool freewheel);
00211 
00212 };
00213 
00214 } // end of namespace
00215 
00216 #endif

Generated on Thu Feb 14 11:16:01 2008 for Jackdmp by  doxygen 1.5.1