common/JackServer.cpp

   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 #include "JackSystemDeps.h"
  22 #include "JackServerGlobals.h"
  23 #include "JackTime.h"
  24 #include "JackFreewheelDriver.h"
  25 #include "JackDummyDriver.h"
  26 #include "JackThreadedDriver.h"
  27 #include "JackGlobals.h"
  28 #include "JackLockedEngine.h"
  29 #include "JackAudioDriver.h"
  30 #include "JackChannel.h"
  31 #include "JackClientControl.h"
  32 #include "JackEngineControl.h"
  33 #include "JackGraphManager.h"
  34 #include "JackInternalClient.h"
  35 #include "JackError.h"
  36 #include "JackMessageBuffer.h"
  37
  38 namespace Jack
  39 {
  40
  41 JackServer::JackServer(bool sync, bool temporary, int timeout, bool rt, int priority, int port_max, bool verbose, jack_timer_type_t clock, const char* server_name)
  42 {
  43     if (rt) {
  44         jack_info("JACK server starting in realtime mode with priority %ld", priority);
  45     } else {
  46         jack_info("JACK server starting in non-realtime mode");
  47     }
  48
  49     fGraphManager = JackGraphManager::Allocate(port_max);
  50     fEngineControl = new JackEngineControl(sync, temporary, timeout, rt, priority, verbose, clock, server_name);
  51     fEngine = new JackLockedEngine(fGraphManager, GetSynchroTable(), fEngineControl);
  52
  53     // A distinction is made between the threaded freewheel driver and the
  54     // regular freewheel driver because the freewheel driver needs to run in
  55     // threaded mode when freewheel mode is active and needs to run as a slave
  56     // when freewheel mode isn't active.
  57     JackFreewheelDriver *freewheelDriver =
  58         new JackFreewheelDriver(fEngine, GetSynchroTable());
  59     fThreadedFreewheelDriver = new JackThreadedDriver(freewheelDriver);
  60
  61    fFreewheelDriver = freewheelDriver;
  62     fDriverInfo = new JackDriverInfo();
  63     fAudioDriver = NULL;
  64     fFreewheel = false;
  65     JackServerGlobals::fInstance = this;   // Unique instance
  66     JackServerGlobals::fUserCount = 1;     // One user
  67     JackGlobals::fVerbose = verbose;
  68 }
  69
  70 JackServer::~JackServer()
  71 {
  72     JackGraphManager::Destroy(fGraphManager);
  73     delete fDriverInfo;
  74     delete fThreadedFreewheelDriver;
  75     delete fEngine;
  76     delete fEngineControl;
  77 }
  78
  79 int JackServer::Open(jack_driver_desc_t* driver_desc, JSList* driver_params)
  80 {
  81     // TODO: move that in reworked JackServerGlobals::Init()
  82     JackMessageBuffer::Create();
  83
  84      if ((fAudioDriver = fDriverInfo->Open(driver_desc, fEngine, GetSynchroTable(), driver_params)) == NULL) {
  85         jack_error("Cannot initialize driver");
  86         goto fail_close1;
  87     }
  88
  89     if (fChannel.Open(fEngineControl->fServerName, this) < 0) {
  90         jack_error("Server channel open error");
  91         goto fail_close2;
  92     }
  93
  94     if (fEngine->Open() < 0) {
  95         jack_error("Cannot open engine");
  96         goto fail_close3;
  97     }
  98
  99     if (fFreewheelDriver->Open() < 0) {
 100         jack_error("Cannot open freewheel driver");
 101         goto fail_close4;
 102     }
 103
 104     if (fAudioDriver->Attach() < 0) {
 105         jack_error("Cannot attach audio driver");
 106         goto fail_close5;
 107     }
 108
 109     fFreewheelDriver->SetMaster(false);
 110     fAudioDriver->SetMaster(true);
 111     fAudioDriver->AddSlave(fFreewheelDriver);
 112     InitTime();
 113     SetClockSource(fEngineControl->fClockSource);
 114     return 0;
 115
 116 fail_close5:
 117     fFreewheelDriver->Close();
 118
 119 fail_close4:
 120     fEngine->Close();
 121
 122 fail_close3:
 123     fChannel.Close();
 124
 125 fail_close2:
 126     fAudioDriver->Close();
 127
 128 fail_close1:
 129     JackMessageBuffer::Destroy();
 130     return -1;
 131 }
 132
 133 int JackServer::Close()
 134 {
 135     jack_log("JackServer::Close");
 136     fEngine->NotifyQuit();
 137     fChannel.Close();
 138     fAudioDriver->Detach();
 139     fAudioDriver->Close();
 140     fFreewheelDriver->Close();
 141     fEngine->Close();
 142     // TODO: move that in reworked JackServerGlobals::Destroy()
 143     JackMessageBuffer::Destroy();
 144     return 0;
 145 }
 146
 147 int JackServer::InternalClientLoad1(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int uuid, int* status)
 148 {
 149     JackLoadableInternalClient* client = new JackLoadableInternalClient1(JackServerGlobals::fInstance, GetSynchroTable(), objet_data);
 150     assert(client);
 151     return InternalClientLoadAux(client, so_name, client_name, options, int_ref, uuid, status);
 152  }
 153
 154 int JackServer::InternalClientLoad2(const char* client_name, const char* so_name, const JSList * parameters, int options, int* int_ref, int uuid, int* status)
 155 {
 156     JackLoadableInternalClient* client = new JackLoadableInternalClient2(JackServerGlobals::fInstance, GetSynchroTable(), parameters);
 157     assert(client);
 158     return InternalClientLoadAux(client, so_name, client_name, options, int_ref, uuid, status);
 159 }
 160
 161 int JackServer::InternalClientLoadAux(JackLoadableInternalClient* client, const char* so_name, const char* client_name, int options, int* int_ref, int uuid, int* status)
 162 {
 163     // Clear status
 164     *status = 0;
 165
 166     // Client object is internally kept in JackEngine
 167     if ((client->Init(so_name) < 0) || (client->Open(JACK_DEFAULT_SERVER_NAME, client_name,  uuid, (jack_options_t)options, (jack_status_t*)status) < 0)) {
 168         delete client;
 169         int my_status1 = *status | JackFailure;
 170         *status = (jack_status_t)my_status1;
 171         *int_ref = 0;
 172         return -1;
 173     } else {
 174         *int_ref = client->GetClientControl()->fRefNum;
 175         return 0;
 176     }
 177  }
 178
 179 int JackServer::Start()
 180 {
 181     jack_log("JackServer::Start");
 182     if (fAudioDriver->Start() < 0) {
 183         return -1;
 184     }
 185     return fChannel.Start();
 186 }
 187
 188 int JackServer::Stop()
 189 {
 190     jack_log("JackServer::Stop");
 191     if (fFreewheel) {
 192         return fThreadedFreewheelDriver->Stop();
 193     } else {
 194         return fAudioDriver->Stop();
 195     }
 196 }
 197
 198 bool JackServer::IsRunning()
 199 {
 200     jack_log("JackServer::IsRunning");
 201     assert(fAudioDriver);
 202     return fAudioDriver->IsRunning();
 203 }
 204
 205 int JackServer::SetBufferSize(jack_nframes_t buffer_size)
 206 {
 207     jack_log("JackServer::SetBufferSize nframes = %ld", buffer_size);
 208     jack_nframes_t current_buffer_size = fEngineControl->fBufferSize;
 209
 210     if (current_buffer_size == buffer_size) {
 211         jack_log("SetBufferSize: requirement for new buffer size equals current value");
 212         return 0;
 213     }
 214
 215     if (fAudioDriver->IsFixedBufferSize()) {
 216         jack_log("SetBufferSize: driver only supports a fixed buffer size");
 217         return -1;
 218     }
 219
 220     if (fAudioDriver->Stop() != 0) {
 221         jack_error("Cannot stop audio driver");
 222         return -1;
 223     }
 224
 225     if (fAudioDriver->SetBufferSize(buffer_size) == 0) {
 226         fEngine->NotifyBufferSize(buffer_size);
 227         return fAudioDriver->Start();
 228     } else { // Failure: try to restore current value
 229         jack_error("Cannot SetBufferSize for audio driver, restore current value %ld", current_buffer_size);
 230         fAudioDriver->SetBufferSize(current_buffer_size);
 231         fAudioDriver->Start();
 232         // SetBufferSize actually failed, so return an error...
 233         return -1;
 234     }
 235 }
 236
 237 /*
 238 Freewheel mode is implemented by switching from the (audio + freewheel) driver to the freewheel driver only:
 239
 240     - "global" connection state is saved
 241     - all audio driver ports are deconnected, thus there is no more dependancies with the audio driver
 242     - the freewheel driver will be synchronized with the end of graph execution : all clients are connected to the freewheel driver
 243     - the freewheel driver becomes the "master"
 244
 245 Normal mode is restored with the connections state valid before freewheel mode was done. Thus one consider that
 246 no graph state change can be done during freewheel mode.
 247 */
 248
 249 int JackServer::SetFreewheel(bool onoff)
 250 {
 251     jack_log("JackServer::SetFreewheel is = %ld want = %ld", fFreewheel, onoff);
 252
 253     if (fFreewheel) {
 254         if (onoff) {
 255             return -1;
 256         } else {
 257             fFreewheel = false;
 258             fThreadedFreewheelDriver->Stop();
 259             fGraphManager->Restore(&fConnectionState);   // Restore previous connection state
 260             fEngine->NotifyFreewheel(onoff);
 261             fFreewheelDriver->SetMaster(false);
 262             fAudioDriver->SetMaster(true);
 263             return fAudioDriver->Start();
 264         }
 265     } else {
 266         if (onoff) {
 267             fFreewheel = true;
 268             fAudioDriver->Stop();
 269             fGraphManager->Save(&fConnectionState);     // Save connection state
 270             fGraphManager->DisconnectAllPorts(fAudioDriver->GetClientControl()->fRefNum);
 271             fEngine->NotifyFreewheel(onoff);
 272             fAudioDriver->SetMaster(false);
 273             fFreewheelDriver->SetMaster(true);
 274             return fThreadedFreewheelDriver->Start();
 275         } else {
 276             return -1;
 277         }
 278     }
 279 }
 280
 281 // Coming from the RT thread
 282 void JackServer::Notify(int refnum, int notify, int value)
 283 {
 284     switch (notify) {
 285
 286         case kGraphOrderCallback:
 287             fEngine->NotifyGraphReorder();
 288             break;
 289
 290         case kXRunCallback:
 291             fEngine->NotifyXRun(refnum);
 292             break;
 293     }
 294 }
 295
 296 void JackServer::ClientKill(int refnum)
 297 {
 298     jack_log("JackServer::ClientKill ref = %ld", refnum);
 299     if (fEngine->ClientDeactivate(refnum) < 0) {
 300         jack_error("JackServer::ClientKill ref = %ld cannot be removed from the graph !!", refnum);
 301     }
 302     if (fEngine->ClientExternalClose(refnum) < 0) {
 303         jack_error("JackServer::ClientKill ref = %ld cannot be closed", refnum);
 304     }
 305 }
 306
 307 //----------------------
 308 // Backend management
 309 //----------------------
 310
 311 JackDriverInfo* JackServer::AddSlave(jack_driver_desc_t* driver_desc, JSList* driver_params)
 312 {
 313     JackDriverInfo* info = new JackDriverInfo();
 314     JackDriverClientInterface* slave = info->Open(driver_desc, fEngine, GetSynchroTable(), driver_params);
 315     if (slave == NULL) {
 316         delete info;
 317         return NULL;
 318     }
 319     slave->Attach();
 320     slave->SetMaster(false);
 321     fAudioDriver->AddSlave(slave);
 322     return info;
 323 }
 324
 325 void JackServer::RemoveSlave(JackDriverInfo* info)
 326 {
 327     JackDriverClientInterface* slave = info->GetBackend();
 328     fAudioDriver->RemoveSlave(slave);
 329     slave->Detach();
 330     slave->Close();
 331 }
 332
 333 int JackServer::SwitchMaster(jack_driver_desc_t* driver_desc, JSList* driver_params)
 334 {
 335     /// Remove current master
 336     fAudioDriver->Stop();
 337     fAudioDriver->Detach();
 338     fAudioDriver->Close();
 339
 340     // Open new master
 341     JackDriverInfo* info = new JackDriverInfo();
 342     JackDriverClientInterface* master = info->Open(driver_desc, fEngine, GetSynchroTable(), driver_params);
 343
 344     if (master == NULL) {
 345         delete info;
 346         return -1;
 347     }
 348
 349     // Get slaves list
 350     std::list<JackDriverInterface*> slave_list = fAudioDriver->GetSlaves();
 351     std::list<JackDriverInterface*>::const_iterator it;
 352
 353     // Move slaves in new master
 354     for (it = slave_list.begin(); it != slave_list.end(); it++) {
 355         JackDriverInterface* slave = *it;
 356         master->AddSlave(slave);
 357     }
 358
 359     // Delete old master
 360     delete fDriverInfo;
 361
 362     // Activate master
 363     fAudioDriver = master;
 364     fDriverInfo = info;
 365     fAudioDriver->Attach();
 366     fAudioDriver->SetMaster(true);
 367     return fAudioDriver->Start();
 368 }
 369
 370 //----------------------
 371 // Transport management
 372 //----------------------
 373
 374 int JackServer::ReleaseTimebase(int refnum)
 375 {
 376     return fEngineControl->fTransport.ResetTimebase(refnum);
 377 }
 378
 379 int JackServer::SetTimebaseCallback(int refnum, int conditional)
 380 {
 381     return fEngineControl->fTransport.SetTimebaseMaster(refnum, conditional);
 382 }
 383
 384 JackLockedEngine* JackServer::GetEngine()
 385 {
 386     return fEngine;
 387 }
 388
 389 JackSynchro* JackServer::GetSynchroTable()
 390 {
 391     return fSynchroTable;
 392 }
 393
 394 JackEngineControl* JackServer::GetEngineControl()
 395 {
 396     return fEngineControl;
 397 }
 398
 399 JackGraphManager* JackServer::GetGraphManager()
 400 {
 401     return fGraphManager;
 402 }
 403
 404
 405 } // end of namespace
 406