common/JackClient.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 Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19 */
  20
  21 #ifndef __JackClient__
  22 #define __JackClient__
  23
  24 #include "JackClientInterface.h"
  25 #include "JackThread.h"
  26 #include "JackConstants.h"
  27 #include "JackSynchro.h"
  28 #include "JackPlatformPlug.h"
  29 #include "JackChannel.h"
  30 #include "JackRequest.h"
  31 #include "JackMetadata.h"
  32 #include "varargs.h"
  33 #include <list>
  34
  35 namespace Jack
  36 {
  37
  38 class JackGraphManager;
  39 class JackServer;
  40 class JackEngine;
  41 struct JackClientControl;
  42 struct JackEngineControl;
  43
  44 /*!
  45 \brief The base class for clients: share part of the implementation for JackInternalClient and JackLibClient.
  46 */
  47
  48 class SERVER_EXPORT JackClient : public JackClientInterface, public JackRunnableInterface
  49 {
  50         friend class JackDebugClient;
  51
  52     protected:
  53
  54         JackProcessCallback fProcess;
  55         JackGraphOrderCallback fGraphOrder;
  56         JackXRunCallback fXrun;
  57         JackShutdownCallback fShutdown;
  58         JackInfoShutdownCallback fInfoShutdown;
  59         JackThreadInitCallback fInit;
  60         JackBufferSizeCallback fBufferSize;
  61         JackSampleRateCallback fSampleRate;
  62         JackClientRegistrationCallback fClientRegistration;
  63         JackFreewheelCallback fFreewheel;
  64         JackPortRegistrationCallback fPortRegistration;
  65         JackPortConnectCallback fPortConnect;
  66         JackPortRenameCallback fPortRename;
  67         JackTimebaseCallback fTimebase;
  68         JackSyncCallback fSync;
  69         JackThreadCallback fThreadFun;
  70         JackSessionCallback fSession;
  71         JackLatencyCallback fLatency;
  72         JackPropertyChangeCallback fPropertyChange;
  73
  74         void* fProcessArg;
  75         void* fGraphOrderArg;
  76         void* fXrunArg;
  77         void* fShutdownArg;
  78         void* fInfoShutdownArg;
  79         void* fInitArg;
  80         void* fBufferSizeArg;
  81         void* fSampleRateArg;
  82         void* fClientRegistrationArg;
  83         void* fFreewheelArg;
  84         void* fPortRegistrationArg;
  85         void* fPortConnectArg;
  86         void* fPortRenameArg;
  87         void* fTimebaseArg;
  88         void* fSyncArg;
  89         void* fThreadFunArg;
  90         void* fSessionArg;
  91         void* fLatencyArg;
  92         void* fPropertyChangeArg;
  93
  94         char fServerName[JACK_SERVER_NAME_SIZE+1];
  95
  96         JackThread fThread;    /*! Thread to execute the Process function */
  97         detail::JackClientChannelInterface* fChannel;
  98         JackSynchro* fSynchroTable;
  99         std::list<jack_port_id_t> fPortList;
 100
 101         JackSessionReply fSessionReply;
 102
 103         int StartThread();
 104         void SetupDriverSync(bool freewheel);
 105         bool IsActive();
 106
 107         void CallSyncCallback();
 108         void CallTimebaseCallback();
 109
 110         virtual int ClientNotifyImp(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value);
 111
 112         inline void DummyCycle();
 113         inline void ExecuteThread();
 114         inline bool WaitSync();
 115         inline void SignalSync();
 116         inline int CallProcessCallback();
 117         inline void End();
 118         inline void Error();
 119         inline jack_nframes_t CycleWaitAux();
 120         inline void CycleSignalAux(int status);
 121         inline void CallSyncCallbackAux();
 122         inline void CallTimebaseCallbackAux();
 123         inline int ActivateAux();
 124         inline void InitAux();
 125         inline void SetupRealTime();
 126
 127         int HandleLatencyCallback(int status);
 128
 129     public:
 130
 131         JackClient(JackSynchro* table);
 132         virtual ~JackClient();
 133
 134         char* GetServerName() { return fServerName; }
 135
 136         virtual int Open(const char* server_name, const char* name, jack_uuid_t uuid, jack_options_t options, jack_status_t* status) = 0;
 137         virtual int Close();
 138
 139         virtual JackGraphManager* GetGraphManager() const = 0;
 140         virtual JackEngineControl* GetEngineControl() const = 0;
 141
 142         // Notifications
 143         virtual int ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2);
 144
 145         virtual int Activate();
 146         virtual int Deactivate();
 147
 148         // Context
 149         virtual int SetBufferSize(jack_nframes_t buffer_size);
 150         virtual int SetFreeWheel(int onoff);
 151         virtual int ComputeTotalLatencies();
 152         virtual void ShutDown(jack_status_t code, const char* message);
 153         virtual jack_native_thread_t GetThreadID();
 154
 155         // Port management
 156         virtual int PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
 157         virtual int PortUnRegister(jack_port_id_t port);
 158
 159         virtual int PortConnect(const char* src, const char* dst);
 160         virtual int PortDisconnect(const char* src, const char* dst);
 161         virtual int PortDisconnect(jack_port_id_t src);
 162
 163         virtual int PortIsMine(jack_port_id_t port_index);
 164         virtual int PortRename(jack_port_id_t port_index, const char* name);
 165
 166         // Transport
 167         virtual int ReleaseTimebase();
 168         virtual int SetSyncCallback(JackSyncCallback sync_callback, void* arg);
 169         virtual int SetSyncTimeout(jack_time_t timeout);
 170         virtual int SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg);
 171         virtual void TransportLocate(jack_nframes_t frame);
 172         virtual jack_transport_state_t TransportQuery(jack_position_t* pos);
 173         virtual jack_nframes_t GetCurrentTransportFrame();
 174         virtual int TransportReposition(const jack_position_t* pos);
 175         virtual void TransportStart();
 176         virtual void TransportStop();
 177
 178         // Callbacks
 179         virtual void OnShutdown(JackShutdownCallback callback, void *arg);
 180         virtual void OnInfoShutdown(JackInfoShutdownCallback callback, void *arg);
 181         virtual int SetProcessCallback(JackProcessCallback callback, void* arg);
 182         virtual int SetXRunCallback(JackXRunCallback callback, void* arg);
 183         virtual int SetInitCallback(JackThreadInitCallback callback, void* arg);
 184         virtual int SetGraphOrderCallback(JackGraphOrderCallback callback, void* arg);
 185         virtual int SetBufferSizeCallback(JackBufferSizeCallback callback, void* arg);
 186         virtual int SetSampleRateCallback(JackBufferSizeCallback callback, void* arg);
 187         virtual int SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg);
 188         virtual int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);
 189         virtual int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
 190         virtual int SetPortConnectCallback(JackPortConnectCallback callback, void *arg);
 191         virtual int SetPortRenameCallback(JackPortRenameCallback callback, void *arg);
 192         virtual int SetSessionCallback(JackSessionCallback callback, void *arg);
 193         virtual int SetLatencyCallback(JackLatencyCallback callback, void *arg);
 194         virtual int SetPropertyChangeCallback(JackPropertyChangeCallback callback, void* arg);
 195
 196         // Internal clients
 197         virtual char* GetInternalClientName(int ref);
 198         virtual int InternalClientHandle(const char* client_name, jack_status_t* status);
 199         virtual int InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va);
 200         virtual void InternalClientUnload(int ref, jack_status_t* status);
 201
 202         // RT Thread
 203         jack_nframes_t CycleWait();
 204         void CycleSignal(int status);
 205         virtual int SetProcessThread(JackThreadCallback fun, void *arg);
 206
 207         // Session API
 208         virtual jack_session_command_t* SessionNotify(const char* target, jack_session_event_type_t type, const char* path);
 209         virtual int SessionReply(jack_session_event_t* ev);
 210         virtual char* GetUUIDForClientName(const char* client_name);
 211         virtual char* GetClientNameByUUID(const char* uuid);
 212         virtual int ReserveClientName(const char* client_name, const char* uuid);
 213         virtual int ClientHasSessionCallback(const char* client_name);
 214
 215         // Metadata API
 216         virtual int PropertyChangeNotify(jack_uuid_t subject, const char* key, jack_property_change_t change);
 217
 218         // JackRunnableInterface interface
 219         bool Init();
 220         bool Execute();
 221 };
 222
 223 } // end of namespace
 224
 225 #endif