JackDriver.h

00001 /*
00002 Copyright (C) 2001 Paul Davis 
00003 Copyright (C) 2004-2006 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                          int capturing,
00057                          int 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 
00076         virtual int Process() = 0;
00077 
00078         virtual void SetMaster(bool onoff) = 0;
00079         virtual bool GetMaster() = 0;
00080         virtual void AddSlave(JackDriverInterface* slave) = 0;
00081         virtual void RemoveSlave(JackDriverInterface* slave) = 0;
00082         virtual int ProcessSlaves() = 0;
00083 
00084         virtual bool IsRealTime() = 0;
00085 };
00086 
00091 class EXPORT JackDriverClientInterface : public JackDriverInterface, public JackClientInterface
00092 {};
00093 
00098 class EXPORT JackDriverClient : public JackDriverClientInterface
00099 {
00100     private:
00101 
00102         std::list<JackDriverInterface*> fSlaveList;
00103 
00104     protected:
00105 
00106         bool fIsMaster;
00107 
00108     public:
00109 
00110         virtual void SetMaster(bool onoff);
00111         virtual bool GetMaster();
00112         virtual void AddSlave(JackDriverInterface* slave);
00113         virtual void RemoveSlave(JackDriverInterface* slave);
00114         virtual int ProcessSlaves();
00115 };
00116 
00121 class EXPORT JackDriver : public JackDriverClient
00122 {
00123 
00124     protected:
00125 
00126         char fCaptureDriverName[JACK_CLIENT_NAME_SIZE];
00127         char fPlaybackDriverName[JACK_CLIENT_NAME_SIZE];
00128         jack_nframes_t fCaptureLatency;
00129         jack_nframes_t fPlaybackLatency;
00130         jack_time_t fLastWaitUst;
00131         JackEngine*     fEngine;
00132         JackGraphManager* fGraphManager;
00133         JackSynchro** fSynchroTable;
00134         JackEngineControl* fEngineControl;
00135         JackClientControl* fClientControl;
00136 
00137         JackClientControl* GetClientControl() const;
00138 
00139     public:
00140 
00141         JackDriver(const char* name, JackEngine* engine, JackSynchro** table);
00142         JackDriver();
00143         virtual ~JackDriver();
00144 
00145         virtual int Open();
00146 
00147         virtual int Open(jack_nframes_t nframes,
00148                          jack_nframes_t samplerate,
00149                          int capturing,
00150                          int playing,
00151                          int inchannels,
00152                          int outchannels,
00153                          bool monitor,
00154                          const char* capture_driver_name,
00155                          const char* playback_driver_name,
00156                          jack_nframes_t capture_latency,
00157                          jack_nframes_t playback_latency);
00158 
00159         virtual int Close();
00160 
00161         virtual int Process()
00162         {
00163             return 0;
00164         }
00165 
00166         virtual int Attach()
00167         {
00168             return 0;
00169         }
00170         virtual int Detach()
00171         {
00172             return 0;
00173         }
00174 
00175         virtual int Read()
00176         {
00177             return 0;
00178         }
00179         virtual int Write()
00180         {
00181             return 0;
00182         }
00183 
00184         virtual int Start()
00185         {
00186             return 0;
00187         }
00188         virtual int Stop()
00189         {
00190             return 0;
00191         }
00192 
00193         virtual int SetBufferSize(jack_nframes_t buffer_size)
00194         {
00195             return 0;
00196         }
00197 
00198         void NotifyXRun(jack_time_t callback_usecs); // XRun notification sent by the driver
00199 
00200         virtual bool IsRealTime();
00201 
00202         int ClientNotify(int refnum, const char* name, int notify, int sync, int value)
00203         {
00204             return 0;
00205         }
00206 
00207 };
00208 
00209 } // end of namespace
00210 
00211 #endif

Generated on Mon Oct 15 17:11:14 2007 for Jackdmp by  doxygen 1.5.1