Jack2  1.9.10
JackClient.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 Lesser General Public License as published by
00007 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
00014 
00015 You should have received a copy of the GNU Lesser General Public License
00016 along with this program; if not, write to the Free Software
00017 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00018 
00019 */
00020 
00021 #ifndef __JackClient__
00022 #define __JackClient__
00023 
00024 #include "JackClientInterface.h"
00025 #include "JackThread.h"
00026 #include "JackConstants.h"
00027 #include "JackSynchro.h"
00028 #include "JackPlatformPlug.h"
00029 #include "JackChannel.h"
00030 #include "JackRequest.h"
00031 #include "varargs.h"
00032 #include <list>
00033 
00034 namespace Jack
00035 {
00036 
00037 class JackGraphManager;
00038 class JackServer;
00039 class JackEngine;
00040 struct JackClientControl;
00041 struct JackEngineControl;
00042 
00047 class SERVER_EXPORT JackClient : public JackClientInterface, public JackRunnableInterface
00048 {
00049         friend class JackDebugClient;
00050 
00051     protected:
00052 
00053         JackProcessCallback fProcess;
00054         JackGraphOrderCallback fGraphOrder;
00055         JackXRunCallback fXrun;
00056         JackShutdownCallback fShutdown;
00057         JackInfoShutdownCallback fInfoShutdown;
00058         JackThreadInitCallback fInit;
00059         JackBufferSizeCallback fBufferSize;
00060         JackSampleRateCallback fSampleRate;
00061         JackClientRegistrationCallback fClientRegistration;
00062         JackFreewheelCallback fFreewheel;
00063         JackPortRegistrationCallback fPortRegistration;
00064         JackPortConnectCallback fPortConnect;
00065         JackPortRenameCallback fPortRename;
00066         JackTimebaseCallback fTimebase;
00067         JackSyncCallback fSync;
00068         JackThreadCallback fThreadFun;
00069         JackSessionCallback fSession;
00070         JackLatencyCallback fLatency;
00071 
00072         void* fProcessArg;
00073         void* fGraphOrderArg;
00074         void* fXrunArg;
00075         void* fShutdownArg;
00076         void* fInfoShutdownArg;
00077         void* fInitArg;
00078         void* fBufferSizeArg;
00079         void* fSampleRateArg;
00080         void* fClientRegistrationArg;
00081         void* fFreewheelArg;
00082         void* fPortRegistrationArg;
00083         void* fPortConnectArg;
00084         void* fPortRenameArg;
00085         void* fTimebaseArg;
00086         void* fSyncArg;
00087         void* fThreadFunArg;
00088         void* fSessionArg;
00089         void* fLatencyArg;
00090         char fServerName[JACK_SERVER_NAME_SIZE];
00091 
00092         JackThread fThread;    
00093         detail::JackClientChannelInterface* fChannel;
00094         JackSynchro* fSynchroTable;
00095         std::list<jack_port_id_t> fPortList;
00096 
00097         JackSessionReply fSessionReply;
00098 
00099         int StartThread();
00100         void SetupDriverSync(bool freewheel);
00101         bool IsActive();
00102 
00103         void CallSyncCallback();
00104         void CallTimebaseCallback();
00105 
00106         virtual int ClientNotifyImp(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value);
00107 
00108         inline void DummyCycle();
00109         inline void ExecuteThread();
00110         inline bool WaitSync();
00111         inline void SignalSync();
00112         inline int CallProcessCallback();
00113         inline void End();
00114         inline void Error();
00115         inline jack_nframes_t CycleWaitAux();
00116         inline void CycleSignalAux(int status);
00117         inline void CallSyncCallbackAux();
00118         inline void CallTimebaseCallbackAux();
00119         inline int ActivateAux();
00120         inline void InitAux();
00121         inline void SetupRealTime();
00122 
00123         int HandleLatencyCallback(int status);
00124 
00125     public:
00126 
00127         JackClient();
00128         JackClient(JackSynchro* table);
00129         virtual ~JackClient();
00130 
00131         virtual int Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status) = 0;
00132         virtual int Close();
00133 
00134         virtual JackGraphManager* GetGraphManager() const = 0;
00135         virtual JackEngineControl* GetEngineControl() const = 0;
00136 
00137         // Notifications
00138         virtual int ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2);
00139 
00140         virtual int Activate();
00141         virtual int Deactivate();
00142 
00143         // Context
00144         virtual int SetBufferSize(jack_nframes_t buffer_size);
00145         virtual int SetFreeWheel(int onoff);
00146         virtual int ComputeTotalLatencies();
00147         virtual void ShutDown(jack_status_t code, const char* message);
00148         virtual jack_native_thread_t GetThreadID();
00149 
00150         // Port management
00151         virtual int PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
00152         virtual int PortUnRegister(jack_port_id_t port);
00153 
00154         virtual int PortConnect(const char* src, const char* dst);
00155         virtual int PortDisconnect(const char* src, const char* dst);
00156         virtual int PortDisconnect(jack_port_id_t src);
00157 
00158         virtual int PortIsMine(jack_port_id_t port_index);
00159         virtual int PortRename(jack_port_id_t port_index, const char* name);
00160 
00161         // Transport
00162         virtual int ReleaseTimebase();
00163         virtual int SetSyncCallback(JackSyncCallback sync_callback, void* arg);
00164         virtual int SetSyncTimeout(jack_time_t timeout);
00165         virtual int SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg);
00166         virtual void TransportLocate(jack_nframes_t frame);
00167         virtual jack_transport_state_t TransportQuery(jack_position_t* pos);
00168         virtual jack_nframes_t GetCurrentTransportFrame();
00169         virtual int TransportReposition(const jack_position_t* pos);
00170         virtual void TransportStart();
00171         virtual void TransportStop();
00172 
00173         // Callbacks
00174         virtual void OnShutdown(JackShutdownCallback callback, void *arg);
00175         virtual void OnInfoShutdown(JackInfoShutdownCallback callback, void *arg);
00176         virtual int SetProcessCallback(JackProcessCallback callback, void* arg);
00177         virtual int SetXRunCallback(JackXRunCallback callback, void* arg);
00178         virtual int SetInitCallback(JackThreadInitCallback callback, void* arg);
00179         virtual int SetGraphOrderCallback(JackGraphOrderCallback callback, void* arg);
00180         virtual int SetBufferSizeCallback(JackBufferSizeCallback callback, void* arg);
00181         virtual int SetSampleRateCallback(JackBufferSizeCallback callback, void* arg);
00182         virtual int SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg);
00183         virtual int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);
00184         virtual int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
00185         virtual int SetPortConnectCallback(JackPortConnectCallback callback, void *arg);
00186         virtual int SetPortRenameCallback(JackPortRenameCallback callback, void *arg);
00187         virtual int SetSessionCallback(JackSessionCallback callback, void *arg);
00188         virtual int SetLatencyCallback(JackLatencyCallback callback, void *arg);
00189 
00190         // Internal clients
00191         virtual char* GetInternalClientName(int ref);
00192         virtual int InternalClientHandle(const char* client_name, jack_status_t* status);
00193         virtual int InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va);
00194         virtual void InternalClientUnload(int ref, jack_status_t* status);
00195 
00196         // RT Thread
00197         jack_nframes_t CycleWait();
00198         void CycleSignal(int status);
00199         virtual int SetProcessThread(JackThreadCallback fun, void *arg);
00200 
00201         // Session API
00202         virtual jack_session_command_t* SessionNotify(const char* target, jack_session_event_type_t type, const char* path);
00203         virtual int SessionReply(jack_session_event_t* ev);
00204         virtual char* GetUUIDForClientName(const char* client_name);
00205         virtual char* GetClientNameByUUID(const char* uuid);
00206         virtual int ReserveClientName(const char* client_name, const char* uuid);
00207         virtual int ClientHasSessionCallback(const char* client_name);
00208 
00209         // JackRunnableInterface interface
00210         bool Init();
00211         bool Execute();
00212 };
00213 
00214 } // end of namespace
00215 
00216 #endif