common/JackLibClient.cpp

   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 Lesser General Public License as published by
   6 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  13
  14 You should have received a copy of the GNU Lesser General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17
  18 */
  19
  20 #include "JackLibClient.h"
  21 #include "JackTime.h"
  22 #include "JackLibGlobals.h"
  23 #include "JackGlobals.h"
  24 #include "JackPlatformPlug.h"
  25 #include "JackTools.h"
  26
  27 namespace Jack
  28 {
  29
  30 // Used for external C API (JackAPI.cpp)
  31 JackGraphManager* GetGraphManager()
  32 {
  33     if (JackLibGlobals::fGlobals) {
  34         return JackLibGlobals::fGlobals->fGraphManager;
  35     } else {
  36         return NULL;
  37     }
  38 }
  39
  40 JackEngineControl* GetEngineControl()
  41 {
  42     if (JackLibGlobals::fGlobals) {
  43         return JackLibGlobals::fGlobals->fEngineControl;
  44     } else {
  45         return NULL;
  46     }
  47 }
  48
  49 JackSynchro* GetSynchroTable()
  50 {
  51     return (JackLibGlobals::fGlobals ? JackLibGlobals::fGlobals->fSynchroTable : 0);
  52 }
  53
  54 // Used for client-side Metadata API (JackLibAPI.cpp)
  55 JackMetadata* GetMetadata()
  56 {
  57     if (JackLibGlobals::fGlobals) {
  58         return JackLibGlobals::fGlobals->fMetadata;
  59     } else {
  60         return NULL;
  61     }
  62 }
  63
  64 //-------------------
  65 // Client management
  66 //-------------------
  67
  68 /*
  69 ShutDown is called:
  70 - from the RT thread when Execute method fails
  71 - possibly from a "closed" notification channel
  72 (Not needed since the synch object used (Sema of Fifo will fails when server quits... see ShutDown))
  73 */
  74
  75 void JackLibClient::ShutDown(jack_status_t code, const char* message)
  76 {
  77     jack_log("JackLibClient::ShutDown");
  78     JackGlobals::fServerRunning = false;
  79     JackClient::ShutDown(code, message);
  80 }
  81
  82 JackLibClient::JackLibClient(JackSynchro* table): JackClient(table)
  83 {
  84     jack_log("JackLibClient::JackLibClient table = %x", table);
  85     fChannel = new JackClientChannel();
  86 }
  87
  88 JackLibClient::~JackLibClient()
  89 {
  90     jack_log("JackLibClient::~JackLibClient");
  91     delete fChannel;
  92 }
  93
  94 int JackLibClient::Open(const char* server_name, const char* name, jack_uuid_t uuid, jack_options_t options, jack_status_t* status)
  95 {
  96     int shared_engine, shared_client, shared_graph, result;
  97     bool res;
  98     jack_log("JackLibClient::Open name = %s", name);
  99
 100     if (strlen(name) >= JACK_CLIENT_NAME_SIZE) {
 101         jack_error("\"%s\" is too long to be used as a JACK client name.\n"
 102                    "Please use %lu characters or less",
 103                    name,
 104                    JACK_CLIENT_NAME_SIZE - 1);
 105         return -1;
 106     }
 107
 108     strncpy(fServerName, server_name, sizeof(fServerName));
 109     fServerName[sizeof(fServerName) - 1] = 0;
 110
 111     // Open server/client channel
 112     char name_res[JACK_CLIENT_NAME_SIZE+1];
 113     if (fChannel->Open(server_name, name, uuid, name_res, this, options, status) < 0) {
 114         jack_error("Cannot connect to the server");
 115         goto error;
 116     }
 117
 118     // Start receiving notifications
 119     if (fChannel->Start() < 0) {
 120         jack_error("Cannot start channel");
 121         goto error;
 122     }
 123
 124     // Require new client
 125     fChannel->ClientOpen(name_res, JackTools::GetPID(), uuid, &shared_engine, &shared_client, &shared_graph, &result);
 126     if (result < 0) {
 127         jack_error("Cannot open %s client", name_res);
 128         goto error;
 129     }
 130
 131     try {
 132         // Map shared memory segments
 133         JackLibGlobals::fGlobals->fEngineControl.SetShmIndex(shared_engine, fServerName);
 134         JackLibGlobals::fGlobals->fGraphManager.SetShmIndex(shared_graph, fServerName);
 135         fClientControl.SetShmIndex(shared_client, fServerName);
 136         JackGlobals::fVerbose = GetEngineControl()->fVerbose;
 137     } catch (...) {
 138         jack_error("Map shared memory segments exception");
 139         goto error;
 140     }
 141
 142     SetupDriverSync(false);
 143
 144     // Connect shared synchro : the synchro must be usable in I/O mode when several clients live in the same process
 145     assert(JackGlobals::fSynchroMutex);
 146     JackGlobals::fSynchroMutex->Lock();
 147     res = fSynchroTable[GetClientControl()->fRefNum].Connect(name_res, fServerName);
 148     JackGlobals::fSynchroMutex->Unlock();
 149     if (!res) {
 150         jack_error("Cannot ConnectSemaphore %s client", name_res);
 151         goto error;
 152     }
 153
 154     JackGlobals::fClientTable[GetClientControl()->fRefNum] = this;
 155     SetClockSource(GetEngineControl()->fClockSource);
 156     jack_log("JackLibClient::Open name = %s refnum = %ld", name_res, GetClientControl()->fRefNum);
 157     return 0;
 158
 159 error:
 160     fChannel->Stop();
 161     fChannel->Close();
 162     return -1;
 163 }
 164
 165 // Notifications received from the server
 166 // TODO this should be done once for all clients in the process, when a shared notification channel
 167 // will be shared by all clients...
 168 int JackLibClient::ClientNotifyImp(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2)
 169 {
 170     int res = 0;
 171     assert(JackGlobals::fSynchroMutex);
 172     JackGlobals::fSynchroMutex->Lock();
 173
 174     // Done all time
 175     switch (notify) {
 176
 177         case kAddClient:
 178             jack_log("JackClient::AddClient name = %s, ref = %ld ", name, refnum);
 179             // the synchro must be usable in I/O mode when several clients live in the same process
 180             res = fSynchroTable[refnum].Connect(name, fServerName) ? 0 : -1;
 181             break;
 182
 183         case kRemoveClient:
 184             jack_log("JackClient::RemoveClient name = %s, ref = %ld ", name, refnum);
 185             if (GetClientControl() && strcmp(GetClientControl()->fName, name) != 0) {
 186                 res = fSynchroTable[refnum].Disconnect() ? 0 : -1;
 187             }
 188             break;
 189     }
 190
 191     JackGlobals::fSynchroMutex->Unlock();
 192     return res;
 193 }
 194
 195 JackGraphManager* JackLibClient::GetGraphManager() const
 196 {
 197     assert(JackLibGlobals::fGlobals->fGraphManager);
 198     return JackLibGlobals::fGlobals->fGraphManager;
 199 }
 200
 201 JackEngineControl* JackLibClient::GetEngineControl() const
 202 {
 203     assert(JackLibGlobals::fGlobals->fEngineControl);
 204     return JackLibGlobals::fGlobals->fEngineControl;
 205 }
 206
 207 JackClientControl* JackLibClient::GetClientControl() const
 208 {
 209     return fClientControl;
 210 }
 211
 212 } // end of namespace
 213
 214
 215