common/JackDriver.h

   1 /*
   2  Copyright (C) 2001 Paul Davis
   3  Copyright (C) 2004-2008 Grame
   4
   5  This program is free software; you can redistribute it and/or modify
   6  it under the terms of the GNU General Public License as published by
   7  the Free Software Foundation; either version 2 of the License, or
   8  (at your option) any later version.
   9
  10  This program is distributed in the hope that it will be useful,
  11  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  GNU General Public License for more details.
  14
  15  You should have received a copy of the GNU General Public License
  16  along with this program; if not, write to the Free Software
  17  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19  */
  20
  21 #ifndef __JackDriver__
  22 #define __JackDriver__
  23
  24 #include "types.h"
  25 #include "JackClientInterface.h"
  26 #include "JackConstants.h"
  27 #include "JackPlatformPlug.h"
  28 #include "JackClientControl.h"
  29 #include <list>
  30
  31 namespace Jack
  32 {
  33
  34 class JackLockedEngine;
  35 class JackGraphManager;
  36 struct JackEngineControl;
  37
  38 /*!
  39 \brief The base interface for drivers.
  40 */
  41
  42 class SERVER_EXPORT JackDriverInterface
  43 {
  44
  45     public:
  46
  47         JackDriverInterface()
  48         {}
  49         virtual ~JackDriverInterface()
  50         {}
  51
  52         virtual int Open() = 0;
  53
  54         virtual int Open (bool capturing,
  55                      bool playing,
  56                      int inchannels,
  57                      int outchannels,
  58                      bool monitor,
  59                      const char* capture_driver_name,
  60                      const char* playback_driver_name,
  61                      jack_nframes_t capture_latency,
  62                      jack_nframes_t playback_latency) = 0;
  63
  64         virtual int Open(jack_nframes_t buffer_size,
  65                          jack_nframes_t samplerate,
  66                          bool capturing,
  67                          bool playing,
  68                          int inchannels,
  69                          int outchannels,
  70                          bool monitor,
  71                          const char* capture_driver_name,
  72                          const char* playback_driver_name,
  73                          jack_nframes_t capture_latency,
  74                          jack_nframes_t playback_latency) = 0;
  75
  76         virtual int Attach() = 0;
  77         virtual int Detach() = 0;
  78
  79         virtual int Read() = 0;
  80         virtual int Write() = 0;
  81
  82         virtual int Start() = 0;
  83         virtual int Stop() = 0;
  84
  85         virtual bool IsFixedBufferSize() = 0;
  86         virtual int SetBufferSize(jack_nframes_t buffer_size) = 0;
  87         virtual int SetSampleRate(jack_nframes_t sample_rate) = 0;
  88
  89         virtual int Process() = 0;
  90         virtual int ProcessNull() = 0;
  91
  92         virtual void SetMaster(bool onoff) = 0;
  93         virtual bool GetMaster() = 0;
  94         virtual void AddSlave(JackDriverInterface* slave) = 0;
  95         virtual void RemoveSlave(JackDriverInterface* slave) = 0;
  96         virtual std::list<JackDriverInterface*> GetSlaves() = 0;
  97         virtual int ProcessSlaves() = 0;
  98
  99         virtual bool IsRealTime() const = 0;
 100 };
 101
 102 /*!
 103  \brief The base interface for drivers clients.
 104  */
 105
 106 class SERVER_EXPORT JackDriverClientInterface : public JackDriverInterface, public JackClientInterface
 107 {};
 108
 109 /*!
 110  \brief The base class for drivers.
 111  */
 112
 113 class SERVER_EXPORT JackDriver : public JackDriverClientInterface
 114 {
 115
 116     protected:
 117
 118         char fCaptureDriverName[JACK_CLIENT_NAME_SIZE + 1];
 119         char fPlaybackDriverName[JACK_CLIENT_NAME_SIZE + 1];
 120         char fAliasName[JACK_CLIENT_NAME_SIZE + 1];
 121         jack_nframes_t fCaptureLatency;
 122         jack_nframes_t fPlaybackLatency;
 123         jack_time_t fBeginDateUst;
 124         jack_time_t fEndDateUst;
 125         float fDelayedUsecs;
 126         JackLockedEngine* fEngine;
 127         JackGraphManager* fGraphManager;
 128         JackSynchro* fSynchroTable;
 129         JackEngineControl* fEngineControl;
 130         JackClientControl fClientControl;
 131         std::list<JackDriverInterface*> fSlaveList;
 132         bool fIsMaster;
 133
 134         void CycleIncTime();
 135         void CycleTakeBeginTime();
 136         void CycleTakeEndTime();
 137
 138         void SetupDriverSync(int ref, bool freewheel);
 139
 140         void NotifyXRun(jack_time_t callback_usecs, float delayed_usecs);   // XRun notification sent by the driver
 141         void NotifyBufferSize(jack_nframes_t buffer_size);                  // BufferSize notification sent by the driver
 142         void NotifySampleRate(jack_nframes_t sample_rate);                  // SampleRate notification sent by the driver
 143
 144     public:
 145
 146         JackDriver(const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table);
 147         JackDriver();
 148         virtual ~JackDriver();
 149
 150         void SetMaster(bool onoff);
 151         bool GetMaster();
 152
 153         void AddSlave(JackDriverInterface* slave);
 154         void RemoveSlave(JackDriverInterface* slave);
 155         std::list<JackDriverInterface*> GetSlaves()
 156         {
 157             return fSlaveList;
 158         }
 159         int ProcessSlaves();
 160
 161         virtual int Open();
 162
 163         virtual int Open (bool capturing,
 164                      bool playing,
 165                      int inchannels,
 166                      int outchannels,
 167                      bool monitor,
 168                      const char* capture_driver_name,
 169                      const char* playback_driver_name,
 170                      jack_nframes_t capture_latency,
 171                      jack_nframes_t playback_latency);
 172
 173         virtual int Open(jack_nframes_t buffer_size,
 174                          jack_nframes_t samplerate,
 175                          bool capturing,
 176                          bool playing,
 177                          int inchannels,
 178                          int outchannels,
 179                          bool monitor,
 180                          const char* capture_driver_name,
 181                          const char* playback_driver_name,
 182                          jack_nframes_t capture_latency,
 183                          jack_nframes_t playback_latency);
 184         virtual int Close();
 185
 186         virtual int Process();
 187         virtual int ProcessNull();
 188
 189         virtual int Attach();
 190         virtual int Detach();
 191
 192         virtual int Read();
 193         virtual int Write();
 194
 195         virtual int Start();
 196         virtual int Stop();
 197
 198         virtual bool IsFixedBufferSize();
 199         virtual int SetBufferSize(jack_nframes_t buffer_size);
 200         virtual int SetSampleRate(jack_nframes_t sample_rate);
 201
 202         virtual int ClientNotify(int refnum, const char* name, int notify, int sync, int value1, int value2);
 203         virtual JackClientControl* GetClientControl() const;
 204
 205         virtual bool IsRealTime() const;
 206         virtual bool Initialize();  // To be called by the wrapping thread Init method when the driver is a "blocking" one
 207
 208 };
 209
 210 } // end of namespace
 211
 212 #endif