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