21 #include "JackSystemDeps.h"    22 #include "JackServerGlobals.h"    24 #include "JackFreewheelDriver.h"    25 #include "JackThreadedDriver.h"    26 #include "JackGlobals.h"    27 #include "JackLockedEngine.h"    28 #include "JackAudioDriver.h"    29 #include "JackChannel.h"    30 #include "JackClientControl.h"    31 #include "JackEngineControl.h"    32 #include "JackGraphManager.h"    33 #include "JackInternalClient.h"    34 #include "JackError.h"    35 #include "JackMessageBuffer.h"    36 #include "JackInternalSessionLoader.h"    38 const char * jack_get_self_connect_mode_description(
char mode);
    46 JackServer::JackServer(
bool sync, 
bool temporary, 
int timeout, 
bool rt, 
int priority, 
int port_max, 
bool verbose, jack_timer_type_t clock, 
char self_connect_mode, 
const char* server_name)
    49         jack_info(
"JACK server starting in realtime mode with priority %ld", priority);
    51         jack_info(
"JACK server starting in non-realtime mode");
    54     jack_info(
"self-connect-mode is \"%s\"", jack_get_self_connect_mode_description(self_connect_mode));
    56     fGraphManager = JackGraphManager::Allocate(port_max);
    57     fEngineControl = 
new JackEngineControl(sync, temporary, timeout, rt, priority, verbose, clock, server_name);
    58     fEngine = 
new JackLockedEngine(fGraphManager, GetSynchroTable(), fEngineControl, self_connect_mode);
    64     JackFreewheelDriver* freewheelDriver = 
new JackFreewheelDriver(fEngine, GetSynchroTable());
    65     fThreadedFreewheelDriver = 
new JackThreadedDriver(freewheelDriver);
    67     fFreewheelDriver = freewheelDriver;
    71     JackServerGlobals::fInstance = 
this;   
    72     JackServerGlobals::fUserCount = 1;     
    73     JackGlobals::fVerbose = verbose;
    76 JackServer::~JackServer()
    78     JackGraphManager::Destroy(fGraphManager);
    80     delete fThreadedFreewheelDriver;
    82     delete fEngineControl;
    88     if (!JackMessageBuffer::Create()) {
    92      if ((fAudioDriver = fDriverInfo->Open(driver_desc, fEngine, GetSynchroTable(), driver_params)) == NULL) {
    97     if (fRequestChannel.Open(fEngineControl->fServerName, 
this) < 0) {
   102     if (fEngine->Open() < 0) {
   107     if (fFreewheelDriver->Open() < 0) {
   112     if (fAudioDriver->Attach() < 0) {
   117     fFreewheelDriver->SetMaster(
false);
   118     fAudioDriver->SetMaster(
true);
   119     fAudioDriver->AddSlave(fFreewheelDriver);
   121     SetClockSource(fEngineControl->fClockSource);
   125     fFreewheelDriver->Close();
   131     fRequestChannel.Close();
   134     fAudioDriver->Close();
   137     JackMessageBuffer::Destroy();
   141 int JackServer::Close()
   144     fRequestChannel.Close();
   145     fAudioDriver->Detach();
   146     fAudioDriver->Close();
   147     fFreewheelDriver->Close();
   150     JackMessageBuffer::Destroy();
   155 int JackServer::Start()
   158     if (fAudioDriver->Start() < 0) {
   161     return fRequestChannel.Start();
   164 int JackServer::Stop()
   170         if (fThreadedFreewheelDriver) {
   171             res = fThreadedFreewheelDriver->Stop();
   175             res = fAudioDriver->Stop();
   179     fEngine->NotifyQuit();
   180     fRequestChannel.Stop();
   181     fEngine->NotifyFailure(JackFailure | JackServerError, JACK_SERVER_FAILURE);
   186 bool JackServer::IsRunning()
   189     assert(fAudioDriver);
   190     return fAudioDriver->IsRunning();
   197 int JackServer::InternalClientLoad1(
const char* client_name, 
const char* so_name, 
const char* objet_data, 
int options, 
int* int_ref, 
int uuid, 
int* status)
   199     JackLoadableInternalClient* client = 
new JackLoadableInternalClient1(JackServerGlobals::fInstance, GetSynchroTable(), objet_data);
   201     return InternalClientLoadAux(client, so_name, client_name, options, int_ref, uuid, status);
   204 int JackServer::InternalClientLoad2(
const char* client_name, 
const char* so_name, 
const JSList * parameters, 
int options, 
int* int_ref, 
int uuid, 
int* status)
   206     JackLoadableInternalClient* client = 
new JackLoadableInternalClient2(JackServerGlobals::fInstance, GetSynchroTable(), parameters);
   208     return InternalClientLoadAux(client, so_name, client_name, options, int_ref, uuid, status);
   211 int JackServer::InternalClientLoadAux(JackLoadableInternalClient* client, 
const char* so_name, 
const char* client_name, 
int options, 
int* int_ref, 
int uuid, 
int* status)
   217     if ((client->Init(so_name) < 0) || (client->Open(JackTools::DefaultServerName(), client_name,  uuid, (jack_options_t)options, (jack_status_t*)status) < 0)) {
   219         int my_status1 = *status | JackFailure;
   220         *status = (jack_status_t)my_status1;
   224         *int_ref = client->GetClientControl()->fRefNum;
   233 int JackServer::LoadInternalSessionFile(
const char* file)
   235     JackInternalSessionLoader loader(
this);
   236     return loader.Load(file);
   243 int JackServer::SetBufferSize(jack_nframes_t buffer_size)
   245     jack_log(
"JackServer::SetBufferSize nframes = %ld", buffer_size);
   246     jack_nframes_t current_buffer_size = fEngineControl->fBufferSize;
   248     if (current_buffer_size == buffer_size) {
   249         jack_log(
"SetBufferSize: requirement for new buffer size equals current value");
   253     if (fAudioDriver->IsFixedBufferSize()) {
   254         jack_log(
"SetBufferSize: driver only supports a fixed buffer size");
   258     if (fAudioDriver->Stop() != 0) {
   263     if (fAudioDriver->SetBufferSize(buffer_size) == 0) {
   264         fEngine->NotifyBufferSize(buffer_size);
   265         return fAudioDriver->Start();
   267         jack_error(
"Cannot SetBufferSize for audio driver, restore current value %ld", current_buffer_size);
   268         fAudioDriver->SetBufferSize(current_buffer_size);
   269         fAudioDriver->Start();
   287 int JackServer::SetFreewheel(
bool onoff)
   289     jack_log(
"JackServer::SetFreewheel is = %ld want = %ld", fFreewheel, onoff);
   296             fThreadedFreewheelDriver->Stop();
   297             fGraphManager->Restore(&fConnectionState);   
   298             fEngine->NotifyFreewheel(onoff);
   299             fFreewheelDriver->SetMaster(
false);
   300             fAudioDriver->SetMaster(
true);
   301             return fAudioDriver->Start();
   306             fAudioDriver->Stop();
   307             fGraphManager->Save(&fConnectionState);     
   309             std::list<JackDriverInterface*> slave_list = fAudioDriver->GetSlaves();
   310             std::list<JackDriverInterface*>::const_iterator it;
   311             for (it = slave_list.begin(); it != slave_list.end(); it++) {
   312                 JackDriver* slave = dynamic_cast<JackDriver*>(*it);
   314                 fGraphManager->DisconnectAllPorts(slave->GetClientControl()->fRefNum);
   317             fGraphManager->DisconnectAllPorts(fAudioDriver->GetClientControl()->fRefNum);
   318             fEngine->NotifyFreewheel(onoff);
   319             fAudioDriver->SetMaster(
false);
   320             fFreewheelDriver->SetMaster(
true);
   321             return fThreadedFreewheelDriver->Start();
   332 void JackServer::Notify(
int refnum, 
int notify, 
int value)
   336         case kGraphOrderCallback:
   337             fEngine->NotifyGraphReorder();
   341             fEngine->NotifyClientXRun(refnum);
   353     JackDriverClientInterface* slave = info->Open(driver_desc, fEngine, GetSynchroTable(), driver_params);
   358     if (slave->Attach() < 0) {
   362     slave->SetMaster(
false);
   363     fAudioDriver->AddSlave(slave);
   376     JackDriverClientInterface* slave = info->GetBackend();
   377     fAudioDriver->RemoveSlave(slave);
   384     std::list<JackDriverInterface*> slave_list;
   385     std::list<JackDriverInterface*>::const_iterator it;
   388     fAudioDriver->Stop();
   389     fAudioDriver->Detach();
   390     fAudioDriver->Close();
   394     JackDriverClientInterface* master = info->Open(driver_desc, fEngine, GetSynchroTable(), driver_params);
   401     slave_list = fAudioDriver->GetSlaves();
   404     for (it = slave_list.begin(); it != slave_list.end(); it++) {
   405         JackDriverInterface* slave = *it;
   406         master->AddSlave(slave);
   413     fAudioDriver = master;
   416     if (fAudioDriver->Attach() < 0) {
   421     fEngine->NotifyBufferSize(fEngineControl->fBufferSize);
   422     fEngine->NotifySampleRate(fEngineControl->fSampleRate);
   425     fAudioDriver->SetMaster(
true);
   426     return fAudioDriver->Start();
   437 int JackServer::ReleaseTimebase(
int refnum)
   439     return fEngineControl->fTransport.ResetTimebase(refnum);
   442 int JackServer::SetTimebaseCallback(
int refnum, 
int conditional)
   444     return fEngineControl->fTransport.SetTimebaseMaster(refnum, conditional);
   447 JackLockedEngine* JackServer::GetEngine()
   452 JackSynchro* JackServer::GetSynchroTable()
   454     return fSynchroTable;
   457 JackEngineControl* JackServer::GetEngineControl()
   459     return fEngineControl;
   462 JackGraphManager* JackServer::GetGraphManager()
   464     return fGraphManager;
 SERVER_EXPORT void jack_error(const char *fmt,...)
SERVER_EXPORT void jack_info(const char *fmt,...)
SERVER_EXPORT void jack_log(const char *fmt,...)