JackInternalClient.cpp

00001 /*
00002 Copyright (C) 2001 Paul Davis 
00003 Copyright (C) 2004-2008 Grame
00004 
00005 This program is free software; you can redistribute it and/or modify
00006 it under the terms of the GNU General Public License as published by
00007 the Free Software Foundation; either version 2 of the License, or
00008 (at your option) any later version.
00009 
00010 This program is distributed in the hope that it will be useful,
00011 but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 GNU General Public License for more details.
00014 
00015 You should have received a copy of the GNU General Public License
00016 along with this program; if not, write to the Free Software
00017 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00018 
00019 */
00020 
00021 #ifdef WIN32 
00022 #pragma warning (disable : 4786)
00023 #endif
00024 
00025 #include "JackGraphManager.h"
00026 #include "JackInternalClient.h"
00027 #include "JackEngine.h"
00028 #include "JackServer.h"
00029 #include "JackEngineControl.h"
00030 #include "JackClientControl.h"
00031 #include "JackInternalClientChannel.h"
00032 #include <assert.h>
00033 
00034 namespace Jack
00035 {
00036 
00037 JackGraphManager* JackInternalClient::fGraphManager = NULL;
00038 JackEngineControl* JackInternalClient::fEngineControl = NULL;
00039 
00040 // Used for external C API (JackAPI.cpp)
00041 JackGraphManager* GetGraphManager()
00042 {
00043     return JackServer::fInstance->GetGraphManager();
00044 }
00045 
00046 JackEngineControl* GetEngineControl()
00047 {
00048     return JackServer::fInstance->GetEngineControl();
00049 }
00050 
00051 JackSynchro** GetSynchroTable()
00052 {
00053     return JackServer::fInstance->GetSynchroTable();
00054 }
00055 
00056 JackInternalClient::JackInternalClient(JackServer* server, JackSynchro** table): JackClient(table)
00057 {
00058     fClientControl = new JackClientControl();
00059     fChannel = new JackInternalClientChannel(server);
00060 }
00061 
00062 JackInternalClient::~JackInternalClient()
00063 {
00064     delete fClientControl;
00065     delete fChannel;
00066 }
00067 
00068 int JackInternalClient::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
00069 {
00070     int result;
00071         char name_res[JACK_CLIENT_NAME_SIZE]; 
00072     JackLog("JackInternalClient::Open name = %s\n", name);
00073         
00074         snprintf(fServerName, sizeof(fServerName), server_name);
00075         
00076         fChannel->ClientCheck(name, name_res, JACK_PROTOCOL_VERSION, (int)options, (int*)status, &result);
00077     if (result < 0) {
00078                 int status1 = *status;
00079         if (status1 & JackVersionError)
00080                         jack_error("JACK protocol mismatch %d", JACK_PROTOCOL_VERSION);
00081         else
00082                         jack_error("Client name = %s conflits with another running client", name);
00083         goto error;
00084     }
00085         
00086         strcpy(fClientControl->fName, name_res);
00087 
00088     // Require new client
00089     fChannel->ClientOpen(name_res, &fClientControl->fRefNum, &fEngineControl, &fGraphManager, this, &result);
00090     if (result < 0) {
00091         jack_error("Cannot open client name = %s", name_res);
00092         goto error;
00093     }
00094 
00095     SetupDriverSync(false);
00096     return 0;
00097 
00098 error:
00099     fChannel->Stop();
00100     fChannel->Close();
00101     return -1;
00102 }
00103 
00104 JackGraphManager* JackInternalClient::GetGraphManager() const
00105 {
00106     assert(fGraphManager);
00107     return fGraphManager;
00108 }
00109 
00110 JackEngineControl* JackInternalClient::GetEngineControl() const
00111 {
00112     assert(fEngineControl);
00113     return fEngineControl;
00114 }
00115 
00116 JackClientControl* JackInternalClient::GetClientControl() const
00117 {
00118     return fClientControl;
00119 }
00120 
00121 JackLoadableInternalClient::JackLoadableInternalClient(JackServer* server, JackSynchro** table, const char* so_name, const char* object_data)
00122         :JackInternalClient(server, table)
00123 {
00124         char path_to_so[PATH_MAX + 1];
00125         //snprintf(path_to_so, sizeof(path_to_so), ADDON_DIR "/%s.so", so_name);
00126         snprintf(path_to_so, sizeof(path_to_so), so_name);
00127         snprintf(fObjectData, JACK_LOAD_INIT_LIMIT, object_data);
00128         fHandle = LoadJackModule(path_to_so);
00129         
00130         JackLog("JackLoadableInternalClient::JackLoadableInternalClient path_to_so = %s\n", path_to_so);
00131         
00132         if (fHandle == 0) {
00133                 jack_error("error loading %s", so_name);
00134                 throw -1;
00135         }
00136 
00137         fInitialize = (InitializeCallback)GetJackProc(fHandle, "jack_initialize");
00138         if (!fInitialize) {
00139                 UnloadJackModule(fHandle);
00140                 jack_error("symbol jack_initialize cannot be found in %s", so_name);
00141                 throw -1;
00142         }
00143 
00144         fFinish = (FinishCallback)GetJackProc(fHandle, "jack_finish");
00145         if (!fFinish) {
00146                 UnloadJackModule(fHandle);
00147                 jack_error("symbol jack_finish cannot be found in %s", so_name);
00148                 throw -1;
00149         }
00150 }
00151 
00152 JackLoadableInternalClient::~JackLoadableInternalClient()
00153 {
00154         if (fFinish) 
00155                 fFinish(fProcessArg);
00156         UnloadJackModule(fHandle);
00157 }
00158 
00159 int JackLoadableInternalClient::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
00160 {
00161         int res = JackInternalClient::Open(server_name, name, options, status);
00162         if (res == 0) 
00163                 fInitialize((jack_client_t*)this, fObjectData);
00164         return res;
00165 }
00166 
00167 } // end of namespace
00168 

Generated on Thu Feb 14 11:16:01 2008 for Jackdmp by  doxygen 1.5.1