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 General Public License as published by
00007 the Free Software Foundation; either version 2 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 General Public License for more details.
00014 
00015 You should have received a copy of the GNU General Public License
00016 along with this program; if not, write to the Free Software
00017 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, 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 "types.h"
00029 #include "transport_types.h"
00030 #include "varargs.h"
00031 #include <list>
00032 
00033 namespace Jack
00034 {
00035 
00036 class JackClientChannelInterface;
00037 class JackGraphManager;
00038 class JackServer;
00039 class JackEngine;
00040 class JackSynchro;
00041 struct JackClientControl;
00042 struct JackEngineControl;
00043 class JackSyncInterface;
00044 
00045 typedef void (*JackShutdownCallback)(void *arg);
00046 
00051 class JackClient : public JackClientInterface, public JackRunnableInterface
00052 {
00053 
00054     protected:
00055 
00056         JackProcessCallback fProcess;
00057         JackGraphOrderCallback fGraphOrder;
00058         JackXRunCallback fXrun;
00059         JackShutdownCallback fShutdown;
00060         JackThreadInitCallback fInit;
00061         JackBufferSizeCallback fBufferSize;
00062                 JackClientRegistrationCallback fClientRegistration;
00063         JackFreewheelCallback fFreewheel;
00064         JackPortRegistrationCallback fPortRegistration;
00065                 JackPortConnectCallback fPortConnect;
00066         JackTimebaseCallback fTimebase;
00067         JackSyncCallback fSync;
00068                 
00069         void* fProcessArg;
00070         void* fGraphOrderArg;
00071         void* fXrunArg;
00072         void* fShutdownArg;
00073         void* fInitArg;
00074         void* fBufferSizeArg;
00075                 void* fClientRegistrationArg;
00076         void* fFreewheelArg;
00077         void* fPortRegistrationArg;
00078                 void* fPortConnectArg;
00079         void* fTimebaseArg;
00080         void* fSyncArg;
00081         int fConditionnal;
00082                 char fServerName[64];
00083 
00084         JackThread*     fThread;    
00085         JackClientChannelInterface* fChannel;
00086         JackSynchro** fSynchroTable;
00087         std::list<jack_port_id_t> fPortList;
00088 
00089         int StartThread();
00090         void SetupDriverSync(bool freewheel);
00091         bool IsActive();
00092 
00093         void CallSyncCallback();
00094         void CallTimebaseCallback();
00095         int RequestNewPos(jack_position_t* pos);
00096 
00097         virtual int ClientNotifyImp(int refnum, const char* name, int notify, int sync, int value1, int value);
00098                 
00099                 // Fons Adriaensen thread model
00100                 inline bool WaitFirstSync();
00101                 inline void ExecuteThread();
00102                 inline bool WaitSync();
00103                 inline void SignalSync();
00104                 inline int CallProcessCallback();
00105                 inline int End();
00106                 inline int Error();
00107 
00108     public:
00109 
00110         JackClient();
00111         JackClient(JackSynchro** table);
00112         virtual ~JackClient();
00113 
00114         virtual int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status) = 0;
00115         virtual int Close();
00116 
00117         virtual JackGraphManager* GetGraphManager() const = 0;
00118         virtual JackEngineControl* GetEngineControl() const = 0;
00119 
00120         // Notifications
00121         virtual int ClientNotify(int refnum, const char* name, int notify, int sync, int value1, int value2);
00122 
00123         virtual int Activate();
00124         virtual int Deactivate();
00125 
00126         // Context
00127         virtual int SetBufferSize(jack_nframes_t buffer_size);
00128         virtual int SetFreeWheel(int onoff);
00129         virtual void ShutDown();
00130         virtual pthread_t GetThreadID();
00131 
00132         // Port management
00133         virtual int PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
00134         virtual int PortUnRegister(jack_port_id_t port);
00135 
00136         virtual int PortConnect(const char* src, const char* dst);
00137         virtual int PortDisconnect(const char* src, const char* dst);
00138         virtual int PortConnect(jack_port_id_t src, jack_port_id_t dst);
00139         virtual int PortDisconnect(jack_port_id_t src);
00140 
00141         virtual int PortIsMine(jack_port_id_t port_index);
00142 
00143         // Transport
00144         virtual int ReleaseTimebase();
00145         virtual int SetSyncCallback(JackSyncCallback sync_callback, void* arg);
00146         virtual int SetSyncTimeout(jack_time_t timeout);
00147         virtual int SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg);
00148         virtual int TransportLocate(jack_nframes_t frame);
00149         virtual jack_transport_state_t TransportQuery(jack_position_t* pos);
00150         virtual jack_nframes_t GetCurrentTransportFrame();
00151         virtual int TransportReposition(jack_position_t* pos);
00152         virtual void TransportStart();
00153         virtual void TransportStop();
00154 
00155         // Callbacks
00156         virtual void OnShutdown(JackShutdownCallback callback, void *arg);
00157         virtual int SetProcessCallback(JackProcessCallback callback, void* arg);
00158         virtual int SetXRunCallback(JackXRunCallback callback, void* arg);
00159         virtual int SetInitCallback(JackThreadInitCallback callback, void* arg);
00160         virtual int SetGraphOrderCallback(JackGraphOrderCallback callback, void* arg);
00161         virtual int SetBufferSizeCallback(JackBufferSizeCallback callback, void* arg);
00162                 virtual int SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg);
00163         virtual int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);
00164         virtual int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
00165                 virtual int SetPortConnectCallback(JackPortConnectCallback callback, void *arg);
00166         
00167                 // Internal clients
00168                 virtual char* GetInternalClientName(int ref);
00169                 virtual int InternalClientHandle(const char* client_name, jack_status_t* status);
00170                 virtual int InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va);
00171                 virtual void InternalClientUnload(int ref, jack_status_t* status);
00172                 
00173                 // Fons Adriaensen thread model
00174                 virtual jack_nframes_t Wait(int status);
00175 
00176         // JackRunnableInterface interface
00177         bool Init();
00178         bool Execute();
00179 };
00180 
00181 // Each "side" server and client will implement this to get the shared graph manager, engine control and inter-process synchro table.
00182 extern JackGraphManager* GetGraphManager();
00183 extern JackEngineControl* GetEngineControl();
00184 extern JackSynchro** GetSynchroTable();
00185 
00186 } // end of namespace
00187 
00188 #endif

Generated on Thu Feb 14 11:16:01 2008 for Jackdmp by  doxygen 1.5.1