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.
309 Commits
8 Branches
67MB
Tree: 17f62de23f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '17f62de23f'
${ noResults }
jack2/common/JackClient.h

173 lines
6.1KB
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.         JackTimebaseCallback fTimebase;

  66.         JackSyncCallback fSync;

  67.         void* fProcessArg;

  68.         void* fGraphOrderArg;

  69.         void* fXrunArg;

  70.         void* fShutdownArg;

  71.         void* fInitArg;

  72.         void* fBufferSizeArg;

  73. 		void* fClientRegistrationArg;

  74.         void* fFreewheelArg;

  75.         void* fPortRegistrationArg;

  76.         void* fTimebaseArg;

  77.         void* fSyncArg;

  78.         int fConditionnal;

  79. 

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

  81.         JackClientChannelInterface* fChannel;

  82.         JackSynchro** fSynchroTable;

  83.         std::list<jack_port_id_t> fPortList;

  84. 

  85.         int StartThread();

  86.         void SetupDriverSync(bool freewheel);

  87.         bool IsActive();

  88. 

  89.         bool CallProcessCallback();

  90.         void CallSyncCallback();

  91.         void CallTimebaseCallback();

  92.         int RequestNewPos(jack_position_t* pos);

  93. 

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

  95. 

  96.     public:

  97. 

  98.         JackClient();

  99.         JackClient(JackSynchro** table);

  100.         virtual ~JackClient();

  101. 

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

  103.         virtual int Close();

  104. 

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

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

  107. 

  108.         // Notifications

  109.         virtual int ClientNotify(int refnum, const char* name, int notify, int sync, int value);

  110. 

  111.         virtual int Activate();

  112.         virtual int Deactivate();

  113. 

  114.         // Context

  115.         virtual int SetBufferSize(jack_nframes_t buffer_size);

  116.         virtual int SetFreeWheel(int onoff);

  117.         virtual void ShutDown();

  118.         virtual pthread_t GetThreadID();

  119. 

  120.         // Port management

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

  122.         virtual int PortUnRegister(jack_port_id_t port);

  123. 

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

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

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

  127.         virtual int PortDisconnect(jack_port_id_t src);

  128. 

  129.         virtual int PortIsMine(jack_port_id_t port_index);

  130. 

  131.         // Transport

  132.         virtual int ReleaseTimebase();

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

  134.         virtual int SetSyncTimeout(jack_time_t timeout);

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

  136.         virtual int TransportLocate(jack_nframes_t frame);

  137.         virtual jack_transport_state_t TransportQuery(jack_position_t* pos);

  138.         virtual jack_nframes_t GetCurrentTransportFrame();

  139.         virtual int TransportReposition(jack_position_t* pos);

  140.         virtual void TransportStart();

  141.         virtual void TransportStop();

  142. 

  143.         // Callbacks

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

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

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

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

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

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

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

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

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

  153. 		

  154. 		// Internal clients

  155. 		virtual char* GetInternalClientName(int ref);

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

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

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

  159. 

  160.         // JackRunnableInterface interface

  161.         bool Init();

  162.         bool Execute();

  163. };

  164. 

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

  166. extern JackGraphManager* GetGraphManager();

  167. extern JackEngineControl* GetEngineControl();

  168. extern JackSynchro** GetSynchroTable();

  169. 

  170. } // end of namespace

  171. 

  172. #endif