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

196 lines
7.0KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2001 Paul Davis

  3. Copyright (C) 2004-2008 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.         friend class JackDebugClient;

  54. 

  55.     protected:

  56. 

  57.         JackProcessCallback fProcess;

  58.         JackGraphOrderCallback fGraphOrder;

  59.         JackXRunCallback fXrun;

  60.         JackShutdownCallback fShutdown;

  61.         JackThreadInitCallback fInit;

  62.         JackBufferSizeCallback fBufferSize;

  63.         JackClientRegistrationCallback fClientRegistration;

  64.         JackFreewheelCallback fFreewheel;

  65.         JackPortRegistrationCallback fPortRegistration;

  66.         JackPortConnectCallback fPortConnect;

  67.         JackTimebaseCallback fTimebase;

  68.         JackSyncCallback fSync;

  69.         JackThreadCallback fThreadFun;

  70. 

  71.         void* fProcessArg;

  72.         void* fGraphOrderArg;

  73.         void* fXrunArg;

  74.         void* fShutdownArg;

  75.         void* fInitArg;

  76.         void* fBufferSizeArg;

  77.         void* fClientRegistrationArg;

  78.         void* fFreewheelArg;

  79.         void* fPortRegistrationArg;

  80.         void* fPortConnectArg;

  81.         void* fTimebaseArg;

  82.         void* fSyncArg;

  83.         void* fThreadFunArg;

  84.         int fConditionnal;

  85.         char fServerName[64];

  86. 

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

  88.         JackClientChannelInterface* fChannel;

  89.         JackSynchro** fSynchroTable;

  90.         std::list<jack_port_id_t> fPortList;

  91. 

  92.         int StartThread();

  93.         void SetupDriverSync(bool freewheel);

  94.         bool IsActive();

  95. 

  96.         void CallSyncCallback();

  97.         void CallTimebaseCallback();

  98.         int RequestNewPos(jack_position_t* pos);

  99. 

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

  101. 

  102.         // Fons Adriaensen thread model

  103.         inline bool WaitFirstSync();

  104.         inline void ExecuteThread();

  105.         inline bool WaitSync();

  106.         inline void SignalSync();

  107.         inline int CallProcessCallback();

  108.         inline int End();

  109.         inline int Error();

  110. 

  111.     public:

  112. 

  113.         JackClient();

  114.         JackClient(JackSynchro** table);

  115.         virtual ~JackClient();

  116. 

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

  118.         virtual int Close();

  119. 

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

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

  122. 

  123.         // Notifications

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

  125. 

  126.         virtual int Activate();

  127.         virtual int Deactivate();

  128. 

  129.         // Context

  130.         virtual int SetBufferSize(jack_nframes_t buffer_size);

  131.         virtual int SetFreeWheel(int onoff);

  132.         virtual void ShutDown();

  133.         virtual pthread_t GetThreadID();

  134. 

  135.         // Port management

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

  137.         virtual int PortUnRegister(jack_port_id_t port);

  138. 

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

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

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

  142.         virtual int PortDisconnect(jack_port_id_t src);

  143. 

  144.         virtual int PortIsMine(jack_port_id_t port_index);

  145. 

  146.         // Transport

  147.         virtual int ReleaseTimebase();

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

  149.         virtual int SetSyncTimeout(jack_time_t timeout);

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

  151.         virtual int TransportLocate(jack_nframes_t frame);

  152.         virtual jack_transport_state_t TransportQuery(jack_position_t* pos);

  153.         virtual jack_nframes_t GetCurrentTransportFrame();

  154.         virtual int TransportReposition(jack_position_t* pos);

  155.         virtual void TransportStart();

  156.         virtual void TransportStop();

  157. 

  158.         // Callbacks

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

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

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

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

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

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

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

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

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

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

  169. 

  170.         // Internal clients

  171.         virtual char* GetInternalClientName(int ref);

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

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

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

  175. 

  176.         // Fons Adriaensen thread model

  177.         virtual jack_nframes_t Wait(int status);

  178. 

  179.         virtual jack_nframes_t CycleWait();

  180.         void CycleSignal(int status);

  181.         int SetProcessThread(JackThreadCallback fun, void *arg);

  182. 

  183.         // JackRunnableInterface interface

  184.         bool Init();

  185.         bool Execute();

  186. };

  187. 

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

  189. extern JackGraphManager* GetGraphManager();

  190. extern JackEngineControl* GetEngineControl();

  191. extern JackSynchro** GetSynchroTable();

  192. 

  193. } // end of namespace

  194. 

  195. #endif