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 <list>
00031 
00032 namespace Jack
00033 {
00034 
00035 class JackClientChannelInterface;
00036 class JackGraphManager;
00037 class JackServer;
00038 class JackEngine;
00039 class JackSynchro;
00040 struct JackClientControl;
00041 struct JackEngineControl;
00042 class JackSyncInterface;
00043 
00044 typedef void (*JackShutdownCallback)(void *arg);
00045 
00050 class JackClient : public JackClientInterface, public JackRunnableInterface
00051 {
00052 
00053     protected:
00054 
00055         JackProcessCallback fProcess;
00056         JackGraphOrderCallback fGraphOrder;
00057         JackXRunCallback fXrun;
00058         JackShutdownCallback fShutdown;
00059         JackThreadInitCallback fInit;
00060         JackBufferSizeCallback fBufferSize;
00061         JackFreewheelCallback fFreewheel;
00062         JackPortRegistrationCallback fPortRegistration;
00063         JackTimebaseCallback fTimebase;
00064         JackSyncCallback fSync;
00065         void* fProcessArg;
00066         void* fGraphOrderArg;
00067         void* fXrunArg;
00068         void* fShutdownArg;
00069         void* fInitArg;
00070         void* fBufferSizeArg;
00071         void* fFreewheelArg;
00072         void* fPortRegistrationArg;
00073         void* fTimebaseArg;
00074         void* fSyncArg;
00075         int fConditionnal;
00076 
00077         JackThread*     fThread;    
00078         JackClientChannelInterface* fChannel;
00079         JackSynchro** fSynchroTable;
00080         std::list<jack_port_id_t> fPortList;
00081 
00082         int StartThread();
00083         void SetupDriverSync(bool freewheel);
00084         bool IsActive();
00085 
00086         bool CallProcessCallback();
00087         void CallSyncCallback();
00088         void CallTimebaseCallback();
00089         int RequestNewPos(jack_position_t* pos);
00090 
00091         virtual int ClientNotifyImp(int refnum, const char* name, int notify, int sync, int value);
00092 
00093     public:
00094 
00095         JackClient();
00096         JackClient(JackSynchro** table);
00097         virtual ~JackClient();
00098 
00099         virtual int Open(const char* name) = 0;
00100         virtual int Close();
00101 
00102         virtual JackGraphManager* GetGraphManager() const = 0;
00103         virtual JackEngineControl* GetEngineControl() const = 0;
00104 
00105         // Notifications
00106         virtual int ClientNotify(int refnum, const char* name, int notify, int sync, int value);
00107 
00108         virtual int Activate();
00109         virtual int Deactivate();
00110 
00111         // Context
00112         virtual int SetBufferSize(jack_nframes_t buffer_size);
00113         virtual int SetFreeWheel(int onoff);
00114         virtual void ShutDown();
00115         virtual pthread_t GetThreadID();
00116 
00117         // Port management
00118         virtual int PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
00119         virtual int PortUnRegister(jack_port_id_t port);
00120 
00121         virtual int PortConnect(const char* src, const char* dst);
00122         virtual int PortDisconnect(const char* src, const char* dst);
00123         virtual int PortConnect(jack_port_id_t src, jack_port_id_t dst);
00124         virtual int PortDisconnect(jack_port_id_t src);
00125 
00126         int PortIsMine(jack_port_id_t port_index);
00127 
00128         // Transport
00129         virtual int ReleaseTimebase();
00130         virtual int SetSyncCallback(JackSyncCallback sync_callback, void* arg);
00131         virtual int SetSyncTimeout(jack_time_t timeout);
00132         virtual int SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg);
00133         virtual int TransportLocate(jack_nframes_t frame);
00134         virtual jack_transport_state_t TransportQuery(jack_position_t* pos);
00135         virtual jack_nframes_t GetCurrentTransportFrame();
00136         virtual int TransportReposition(jack_position_t* pos);
00137         virtual void TransportStart();
00138         virtual void TransportStop();
00139 
00140         // Callbacks
00141         virtual void OnShutdown(JackShutdownCallback callback, void *arg);
00142         virtual int SetProcessCallback(JackProcessCallback callback, void* arg);
00143         virtual int SetXRunCallback(JackXRunCallback callback, void* arg);
00144         virtual int SetInitCallback(JackThreadInitCallback callback, void* arg);
00145         virtual int SetGraphOrderCallback(JackGraphOrderCallback callback, void* arg);
00146         virtual int SetBufferSizeCallback(JackBufferSizeCallback callback, void* arg);
00147         virtual int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);
00148         virtual int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
00149 
00150         // JackRunnableInterface interface
00151         bool Init();
00152         bool Execute();
00153 };
00154 
00155 // Each "side" server and client will implement this to get the shared graph manager, engine control and inter-process synchro table.
00156 extern JackGraphManager* GetGraphManager();
00157 extern JackEngineControl* GetEngineControl();
00158 extern JackSynchro** GetSynchroTable();
00159 
00160 } // end of namespace
00161 
00162 #endif

Generated on Wed Jan 10 11:42:44 2007 for Jackdmp by  doxygen 1.4.5