jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
500 Commits
8 Branches
398MB
Tree: fd41ff9feb
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fd41ff9feb'
${ noResults }
jack2/common/JackClient.h

189 lines
6.6KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2001 Paul Davis 

  3. Copyright (C) 2004-2006 Grame

  4. 

  5. This program is free software; you can redistribute it and/or modify

  6. it under the terms of the GNU General Public License as published by

  7. the Free Software Foundation; either version 2 of the License, or

  8. (at your option) any later version.

  9. 

  10. This program is distributed in the hope that it will be useful,

  11. but WITHOUT ANY WARRANTY; without even the implied warranty of

  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13. GNU General Public License for more details.

  14. 

  15. You should have received a copy of the GNU General Public License

  16. along with this program; if not, write to the Free Software

  17. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18. 

  19. */

  20. 

  21. #ifndef __JackClient__

  22. #define __JackClient__

  23. 

  24. #include "JackClientInterface.h"

  25. #include "JackThread.h"

  26. #include "JackConstants.h"

  27. #include "JackSynchro.h"

  28. #include "types.h"

  29. #include "transport_types.h"

  30. #include "varargs.h"

  31. #include <list>

  32. 

  33. namespace Jack

  34. {

  35. 

  36. class JackClientChannelInterface;

  37. class JackGraphManager;

  38. class JackServer;

  39. class JackEngine;

  40. class JackSynchro;

  41. struct JackClientControl;

  42. struct JackEngineControl;

  43. class JackSyncInterface;

  44. 

  45. typedef void (*JackShutdownCallback)(void *arg);

  46. 

  47. /*!

  48. \brief The base class for clients: share part of the implementation for JackInternalClient and JackLibClient.

  49. */

  50. 

  51. class JackClient : public JackClientInterface, public JackRunnableInterface

  52. {

  53. 

  54.     protected:

  55. 

  56.         JackProcessCallback fProcess;

  57.         JackGraphOrderCallback fGraphOrder;

  58.         JackXRunCallback fXrun;

  59.         JackShutdownCallback fShutdown;

  60.         JackThreadInitCallback fInit;

  61.         JackBufferSizeCallback fBufferSize;

  62. 		JackClientRegistrationCallback fClientRegistration;

  63.         JackFreewheelCallback fFreewheel;

  64.         JackPortRegistrationCallback fPortRegistration;

  65. 		JackPortConnectCallback fPortConnect;

  66.         JackTimebaseCallback fTimebase;

  67.         JackSyncCallback fSync;

  68. 		

  69.         void* fProcessArg;

  70.         void* fGraphOrderArg;

  71.         void* fXrunArg;

  72.         void* fShutdownArg;

  73.         void* fInitArg;

  74.         void* fBufferSizeArg;

  75. 		void* fClientRegistrationArg;

  76.         void* fFreewheelArg;

  77.         void* fPortRegistrationArg;

  78. 		void* fPortConnectArg;

  79.         void* fTimebaseArg;

  80.         void* fSyncArg;

  81.         int fConditionnal;

  82. 		char fServerName[64];

  83. 

  84.         JackThread*	fThread;    /*! Thread to execute the Process function */

  85.         JackClientChannelInterface* fChannel;

  86.         JackSynchro** fSynchroTable;

  87.         std::list<jack_port_id_t> fPortList;

  88. 

  89.         int StartThread();

  90.         void SetupDriverSync(bool freewheel);

  91.         bool IsActive();

  92. 

  93.         void CallSyncCallback();

  94.         void CallTimebaseCallback();

  95.         int RequestNewPos(jack_position_t* pos);

  96. 

  97.         virtual int ClientNotifyImp(int refnum, const char* name, int notify, int sync, int value1, int value);

  98. 		

  99. 		// Fons Adriaensen thread model

  100. 		inline bool WaitFirstSync();

  101. 		inline void ExecuteThread();

  102. 		inline bool WaitSync();

  103. 		inline void SignalSync();

  104. 		inline int CallProcessCallback();

  105. 		inline int End();

  106. 		inline int Error();

  107. 

  108.     public:

  109. 

  110.         JackClient();

  111.         JackClient(JackSynchro** table);

  112.         virtual ~JackClient();

  113. 

  114.         virtual int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status) = 0;

  115.         virtual int Close();

  116. 

  117.         virtual JackGraphManager* GetGraphManager() const = 0;

  118.         virtual JackEngineControl* GetEngineControl() const = 0;

  119. 

  120.         // Notifications

  121.         virtual int ClientNotify(int refnum, const char* name, int notify, int sync, int value1, int value2);

  122. 

  123.         virtual int Activate();

  124.         virtual int Deactivate();

  125. 

  126.         // Context

  127.         virtual int SetBufferSize(jack_nframes_t buffer_size);

  128.         virtual int SetFreeWheel(int onoff);

  129.         virtual void ShutDown();

  130.         virtual pthread_t GetThreadID();

  131. 

  132.         // Port management

  133.         virtual int PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);

  134.         virtual int PortUnRegister(jack_port_id_t port);

  135. 

  136.         virtual int PortConnect(const char* src, const char* dst);

  137.         virtual int PortDisconnect(const char* src, const char* dst);

  138.         virtual int PortConnect(jack_port_id_t src, jack_port_id_t dst);

  139.         virtual int PortDisconnect(jack_port_id_t src);

  140. 

  141.         virtual int PortIsMine(jack_port_id_t port_index);

  142. 

  143.         // Transport

  144.         virtual int ReleaseTimebase();

  145.         virtual int SetSyncCallback(JackSyncCallback sync_callback, void* arg);

  146.         virtual int SetSyncTimeout(jack_time_t timeout);

  147.         virtual int SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg);

  148.         virtual int TransportLocate(jack_nframes_t frame);

  149.         virtual jack_transport_state_t TransportQuery(jack_position_t* pos);

  150.         virtual jack_nframes_t GetCurrentTransportFrame();

  151.         virtual int TransportReposition(jack_position_t* pos);

  152.         virtual void TransportStart();

  153.         virtual void TransportStop();

  154. 

  155.         // Callbacks

  156.         virtual void OnShutdown(JackShutdownCallback callback, void *arg);

  157.         virtual int SetProcessCallback(JackProcessCallback callback, void* arg);

  158.         virtual int SetXRunCallback(JackXRunCallback callback, void* arg);

  159.         virtual int SetInitCallback(JackThreadInitCallback callback, void* arg);

  160.         virtual int SetGraphOrderCallback(JackGraphOrderCallback callback, void* arg);

  161.         virtual int SetBufferSizeCallback(JackBufferSizeCallback callback, void* arg);

  162. 		virtual int SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg);

  163.         virtual int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);

  164.         virtual int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);

  165. 		virtual int SetPortConnectCallback(JackPortConnectCallback callback, void *arg);

  166. 	

  167. 		// Internal clients

  168. 		virtual char* GetInternalClientName(int ref);

  169. 		virtual int InternalClientHandle(const char* client_name, jack_status_t* status);

  170. 		virtual int InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va);

  171. 		virtual void InternalClientUnload(int ref, jack_status_t* status);

  172. 		

  173. 		// Fons Adriaensen thread model

  174. 		virtual jack_nframes_t Wait(int status);

  175. 

  176.         // JackRunnableInterface interface

  177.         bool Init();

  178.         bool Execute();

  179. };

  180. 

  181. // Each "side" server and client will implement this to get the shared graph manager, engine control and inter-process synchro table.

  182. extern JackGraphManager* GetGraphManager();

  183. extern JackEngineControl* GetEngineControl();

  184. extern JackSynchro** GetSynchroTable();

  185. 

  186. } // end of namespace

  187. 

  188. #endif