Jack2 1.9.7
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 "session.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[64];
00091 
00092         JackThread fThread;    
00093         detail::JackClientChannelInterface* fChannel;
00094         JackSynchro* fSynchroTable;
00095         std::list<jack_port_id_t> fPortList;
00096 
00097         bool fImmediateSessionReply;
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 
00122         int HandleLatencyCallback(int status);
00123 
00124     public:
00125 
00126         JackClient();
00127         JackClient(JackSynchro* table);
00128         virtual ~JackClient();
00129 
00130         virtual int Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status) = 0;
00131         virtual int Close();
00132 
00133         virtual JackGraphManager* GetGraphManager() const = 0;
00134         virtual JackEngineControl* GetEngineControl() const = 0;
00135 
00136         // Notifications
00137         virtual int ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2);
00138 
00139         virtual int Activate();
00140         virtual int Deactivate();
00141 
00142         // Context
00143         virtual int SetBufferSize(jack_nframes_t buffer_size);
00144         virtual int SetFreeWheel(int onoff);
00145         virtual int ComputeTotalLatencies();
00146         virtual void ShutDown();
00147         virtual jack_native_thread_t GetThreadID();
00148 
00149         // Port management
00150         virtual int PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
00151         virtual int PortUnRegister(jack_port_id_t port);
00152 
00153         virtual int PortConnect(const char* src, const char* dst);
00154         virtual int PortDisconnect(const char* src, const char* dst);
00155         virtual int PortDisconnect(jack_port_id_t src);
00156 
00157         virtual int PortIsMine(jack_port_id_t port_index);
00158         virtual int PortRename(jack_port_id_t port_index, const char* name);
00159 
00160         // Transport
00161         virtual int ReleaseTimebase();
00162         virtual int SetSyncCallback(JackSyncCallback sync_callback, void* arg);
00163         virtual int SetSyncTimeout(jack_time_t timeout);
00164         virtual int SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg);
00165         virtual void TransportLocate(jack_nframes_t frame);
00166         virtual jack_transport_state_t TransportQuery(jack_position_t* pos);
00167         virtual jack_nframes_t GetCurrentTransportFrame();
00168         virtual int TransportReposition(jack_position_t* pos);
00169         virtual void TransportStart();
00170         virtual void TransportStop();
00171 
00172         // Callbacks
00173         virtual void OnShutdown(JackShutdownCallback callback, void *arg);
00174         virtual void OnInfoShutdown(JackInfoShutdownCallback callback, void *arg);
00175         virtual int SetProcessCallback(JackProcessCallback callback, void* arg);
00176         virtual int SetXRunCallback(JackXRunCallback callback, void* arg);
00177         virtual int SetInitCallback(JackThreadInitCallback callback, void* arg);
00178         virtual int SetGraphOrderCallback(JackGraphOrderCallback callback, void* arg);
00179         virtual int SetBufferSizeCallback(JackBufferSizeCallback callback, void* arg);
00180         virtual int SetSampleRateCallback(JackBufferSizeCallback callback, void* arg);
00181         virtual int SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg);
00182         virtual int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);
00183         virtual int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
00184         virtual int SetPortConnectCallback(JackPortConnectCallback callback, void *arg);
00185         virtual int SetPortRenameCallback(JackPortRenameCallback callback, void *arg);
00186         virtual int SetSessionCallback(JackSessionCallback callback, void *arg);
00187         virtual int SetLatencyCallback(JackLatencyCallback callback, void *arg);
00188 
00189         // Internal clients
00190         virtual char* GetInternalClientName(int ref);
00191         virtual int InternalClientHandle(const char* client_name, jack_status_t* status);
00192         virtual int InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va);
00193         virtual void InternalClientUnload(int ref, jack_status_t* status);
00194 
00195         // RT Thread
00196         jack_nframes_t CycleWait();
00197         void CycleSignal(int status);
00198         virtual int SetProcessThread(JackThreadCallback fun, void *arg);
00199 
00200         // Session API
00201         virtual jack_session_command_t* SessionNotify(const char* target, jack_session_event_type_t type, const char* path);
00202         virtual int SessionReply(jack_session_event_t* ev);
00203         virtual char* GetUUIDForClientName(const char* client_name);
00204         virtual char* GetClientNameByUUID(const char* uuid);
00205         virtual int ReserveClientName(const char* client_name, const char* uuid);
00206         virtual int ClientHasSessionCallback(const char* client_name);
00207 
00208         // JackRunnableInterface interface
00209         bool Init();
00210         bool Execute();
00211 };
00212 
00213 } // end of namespace
00214 
00215 #endif

Generated for Jack2 by doxygen 1.7.4