JackClient.h

00001 /*
00002 Copyright (C) 2001 Paul Davis 
00003 Copyright (C) 2004-2006 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         JackTimebaseCallback fTimebase;
00066         JackSyncCallback fSync;
00067         void* fProcessArg;
00068         void* fGraphOrderArg;
00069         void* fXrunArg;
00070         void* fShutdownArg;
00071         void* fInitArg;
00072         void* fBufferSizeArg;
00073                 void* fClientRegistrationArg;
00074         void* fFreewheelArg;
00075         void* fPortRegistrationArg;
00076         void* fTimebaseArg;
00077         void* fSyncArg;
00078         int fConditionnal;
00079 
00080         JackThread*     fThread;    
00081         JackClientChannelInterface* fChannel;
00082         JackSynchro** fSynchroTable;
00083         std::list<jack_port_id_t> fPortList;
00084 
00085         int StartThread();
00086         void SetupDriverSync(bool freewheel);
00087         bool IsActive();
00088 
00089         bool CallProcessCallback();
00090         void CallSyncCallback();
00091         void CallTimebaseCallback();
00092         int RequestNewPos(jack_position_t* pos);
00093 
00094         virtual int ClientNotifyImp(int refnum, const char* name, int notify, int sync, int value);
00095 
00096     public:
00097 
00098         JackClient();
00099         JackClient(JackSynchro** table);
00100         virtual ~JackClient();
00101 
00102         virtual int Open(const char* name, jack_options_t options, jack_status_t* status) = 0;
00103         virtual int Close();
00104 
00105         virtual JackGraphManager* GetGraphManager() const = 0;
00106         virtual JackEngineControl* GetEngineControl() const = 0;
00107 
00108         // Notifications
00109         virtual int ClientNotify(int refnum, const char* name, int notify, int sync, int value);
00110 
00111         virtual int Activate();
00112         virtual int Deactivate();
00113 
00114         // Context
00115         virtual int SetBufferSize(jack_nframes_t buffer_size);
00116         virtual int SetFreeWheel(int onoff);
00117         virtual void ShutDown();
00118         virtual pthread_t GetThreadID();
00119 
00120         // Port management
00121         virtual int PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
00122         virtual int PortUnRegister(jack_port_id_t port);
00123 
00124         virtual int PortConnect(const char* src, const char* dst);
00125         virtual int PortDisconnect(const char* src, const char* dst);
00126         virtual int PortConnect(jack_port_id_t src, jack_port_id_t dst);
00127         virtual int PortDisconnect(jack_port_id_t src);
00128 
00129         virtual int PortIsMine(jack_port_id_t port_index);
00130 
00131         // Transport
00132         virtual int ReleaseTimebase();
00133         virtual int SetSyncCallback(JackSyncCallback sync_callback, void* arg);
00134         virtual int SetSyncTimeout(jack_time_t timeout);
00135         virtual int SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg);
00136         virtual int TransportLocate(jack_nframes_t frame);
00137         virtual jack_transport_state_t TransportQuery(jack_position_t* pos);
00138         virtual jack_nframes_t GetCurrentTransportFrame();
00139         virtual int TransportReposition(jack_position_t* pos);
00140         virtual void TransportStart();
00141         virtual void TransportStop();
00142 
00143         // Callbacks
00144         virtual void OnShutdown(JackShutdownCallback callback, void *arg);
00145         virtual int SetProcessCallback(JackProcessCallback callback, void* arg);
00146         virtual int SetXRunCallback(JackXRunCallback callback, void* arg);
00147         virtual int SetInitCallback(JackThreadInitCallback callback, void* arg);
00148         virtual int SetGraphOrderCallback(JackGraphOrderCallback callback, void* arg);
00149         virtual int SetBufferSizeCallback(JackBufferSizeCallback callback, void* arg);
00150                 virtual int SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg);
00151         virtual int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);
00152         virtual int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
00153                 
00154                 // Internal clients
00155                 virtual char* GetInternalClientName(int ref);
00156                 virtual int InternalClientHandle(const char* client_name, jack_status_t* status);
00157                 virtual int InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va);
00158                 virtual void InternalClientUnload(int ref, jack_status_t* status);
00159 
00160         // JackRunnableInterface interface
00161         bool Init();
00162         bool Execute();
00163 };
00164 
00165 // Each "side" server and client will implement this to get the shared graph manager, engine control and inter-process synchro table.
00166 extern JackGraphManager* GetGraphManager();
00167 extern JackEngineControl* GetEngineControl();
00168 extern JackSynchro** GetSynchroTable();
00169 
00170 } // end of namespace
00171 
00172 #endif

Generated on Mon Oct 15 17:11:13 2007 for Jackdmp by  doxygen 1.5.1