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

174 lines
6.2KB
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. 		char fServerName[64];

  80. 

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

  82.         JackClientChannelInterface* fChannel;

  83.         JackSynchro** fSynchroTable;

  84.         std::list<jack_port_id_t> fPortList;

  85. 

  86.         int StartThread();

  87.         void SetupDriverSync(bool freewheel);

  88.         bool IsActive();

  89. 

  90.         bool CallProcessCallback();

  91.         void CallSyncCallback();

  92.         void CallTimebaseCallback();

  93.         int RequestNewPos(jack_position_t* pos);

  94. 

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

  96. 

  97.     public:

  98. 

  99.         JackClient();

  100.         JackClient(JackSynchro** table);

  101.         virtual ~JackClient();

  102. 

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

  104.         virtual int Close();

  105. 

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

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

  108. 

  109.         // Notifications

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

  111. 

  112.         virtual int Activate();

  113.         virtual int Deactivate();

  114. 

  115.         // Context

  116.         virtual int SetBufferSize(jack_nframes_t buffer_size);

  117.         virtual int SetFreeWheel(int onoff);

  118.         virtual void ShutDown();

  119.         virtual pthread_t GetThreadID();

  120. 

  121.         // Port management

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

  123.         virtual int PortUnRegister(jack_port_id_t port);

  124. 

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

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

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

  128.         virtual int PortDisconnect(jack_port_id_t src);

  129. 

  130.         virtual int PortIsMine(jack_port_id_t port_index);

  131. 

  132.         // Transport

  133.         virtual int ReleaseTimebase();

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

  135.         virtual int SetSyncTimeout(jack_time_t timeout);

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

  137.         virtual int TransportLocate(jack_nframes_t frame);

  138.         virtual jack_transport_state_t TransportQuery(jack_position_t* pos);

  139.         virtual jack_nframes_t GetCurrentTransportFrame();

  140.         virtual int TransportReposition(jack_position_t* pos);

  141.         virtual void TransportStart();

  142.         virtual void TransportStop();

  143. 

  144.         // Callbacks

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

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

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

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

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

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

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

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

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

  154. 		

  155. 		// Internal clients

  156. 		virtual char* GetInternalClientName(int ref);

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

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

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

  160. 

  161.         // JackRunnableInterface interface

  162.         bool Init();

  163.         bool Execute();

  164. };

  165. 

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

  167. extern JackGraphManager* GetGraphManager();

  168. extern JackEngineControl* GetEngineControl();

  169. extern JackSynchro** GetSynchroTable();

  170. 

  171. } // end of namespace

  172. 

  173. #endif