common/JackEngine.h

   1 /*
   2 Copyright (C) 2004-2008 Grame
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef __JackEngine__
  21 #define __JackEngine__
  22
  23 #include "JackConstants.h"
  24 #include "JackGraphManager.h"
  25 #include "JackSynchro.h"
  26 #include "JackMutex.h"
  27 #include "JackTransportEngine.h"
  28 #include "JackPlatformPlug.h"
  29
  30 namespace Jack
  31 {
  32
  33 class JackClientInterface;
  34 struct JackEngineControl;
  35 class JackExternalClient;
  36
  37 /*!
  38 \brief Engine description.
  39 */
  40
  41 class SERVER_EXPORT JackEngine : public JackLockAble
  42 {
  43     friend class JackLockedEngine;
  44
  45     private:
  46
  47         JackGraphManager* fGraphManager;
  48         JackEngineControl* fEngineControl;
  49         JackClientInterface* fClientTable[CLIENT_NUM];
  50         JackSynchro* fSynchroTable;
  51         JackServerNotifyChannel fChannel;              /*! To communicate between the RT thread and server */
  52         JackProcessSync fSignal;
  53         jack_time_t fLastSwitchUsecs;
  54
  55         int fSessionPendingReplies;
  56         JackChannelTransaction *fSessionTransaction;
  57         JackSessionNotifyResult *fSessionResult;
  58         std::map<int,std::string> fReservationMap;
  59         int fMaxUUID;
  60
  61         int ClientCloseAux(int refnum, JackClientInterface* client, bool wait);
  62         void CheckXRun(jack_time_t callback_usecs);
  63
  64         int NotifyAddClient(JackClientInterface* new_client, const char* name, int refnum);
  65         void NotifyRemoveClient(const char* name, int refnum);
  66
  67         void ProcessNext(jack_time_t callback_usecs);
  68         void ProcessCurrent(jack_time_t callback_usecs);
  69
  70         bool ClientCheckName(const char* name);
  71         bool GenerateUniqueName(char* name);
  72
  73         int AllocateRefnum();
  74         void ReleaseRefnum(int ref);
  75
  76         void NotifyClient(int refnum, int event, int sync, const char*  message, int value1, int value2);
  77         void NotifyClients(int event, int sync, const char*  message,  int value1, int value2);
  78
  79         void NotifyPortRegistation(jack_port_id_t port_index, bool onoff);
  80         void NotifyPortConnect(jack_port_id_t src, jack_port_id_t dst, bool onoff);
  81         void NotifyPortRename(jack_port_id_t src, const char* old_name);
  82         void NotifyActivate(int refnum);
  83
  84         int GetNewUUID();
  85         void EnsureUUID(int uuid);
  86
  87         bool CheckClient(int refnum)
  88         {
  89             return (refnum >= 0 && refnum < CLIENT_NUM && fClientTable[refnum] != NULL);
  90         }
  91
  92     public:
  93
  94         JackEngine(JackGraphManager* manager, JackSynchro* table, JackEngineControl* controler);
  95         ~JackEngine();
  96
  97         int Open();
  98         int Close();
  99
 100         // Client management
 101         int ClientCheck(const char* name, char* name_res, int protocol, int options, int* status);
 102         int ClientExternalOpen(const char* name, int pid, int uuid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager);
 103         int ClientInternalOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, bool wait);
 104
 105         int ClientExternalClose(int refnum);
 106         int ClientInternalClose(int refnum, bool wait);
 107
 108         int ClientActivate(int refnum, bool is_real_time);
 109         int ClientDeactivate(int refnum);
 110
 111         int GetClientPID(const char* name);
 112         int GetClientRefNum(const char* name);
 113
 114         // Internal client management
 115         int GetInternalClientName(int int_ref, char* name_res);
 116         int InternalClientHandle(const char* client_name, int* status, int* int_ref);
 117         int InternalClientUnload(int refnum, int* status);
 118
 119         // Port management
 120         int PortRegister(int refnum, const char* name, const char *type, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port);
 121         int PortUnRegister(int refnum, jack_port_id_t port);
 122
 123         int PortConnect(int refnum, const char* src, const char* dst);
 124         int PortDisconnect(int refnum, const char* src, const char* dst);
 125
 126         int PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst);
 127         int PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst);
 128
 129         int PortRename(int refnum, jack_port_id_t port, const char* name);
 130
 131         // Graph
 132         bool Process(jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end);
 133
 134         // Notifications
 135         void NotifyXRun(jack_time_t callback_usecs, float delayed_usecs);
 136         void NotifyFailure(int code, const char* reason);
 137         void NotifyXRun(int refnum);
 138         void NotifyGraphReorder();
 139         void NotifyBufferSize(jack_nframes_t buffer_size);
 140         void NotifySampleRate(jack_nframes_t sample_rate);
 141         void NotifyFreewheel(bool onoff);
 142         void NotifyQuit();
 143
 144         void SessionNotify( int refnum, const char *target, jack_session_event_type_t type, const char *path, JackChannelTransaction *socket );
 145         void SessionReply( int refnum );
 146
 147         void GetUUIDForClientName(const char *client_name, char *uuid_res, int *result);
 148         void GetClientNameForUUID(const char *uuid, char *name_res, int *result);
 149         void ReserveClientName(const char *name, const char *uuid, int *result);
 150 };
 151
 152
 153 } // end of namespace
 154
 155 #endif
 156