jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
Browse Source

Works again on Windows. 

git-svn-id: http://subversion.jackaudio.org/jack/jack2/trunk/jackmp@4702 0c269be4-1314-0410-8aa9-9f06e86f4224
tags/1.9.9.5
sletz 13 years ago
parent
5d7fbdc066
commit
92ccd4f840
4 changed files with 25 additions and 391 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +5
    -4
      common/JackRequestDecoder.cpp
  2. +11
    -376
      windows/JackWinNamedPipeServerChannel.cpp
  3. +4
    -9
      windows/JackWinNamedPipeServerChannel.h
  4. +5
    -2
      windows/JackWinServerLaunch.cpp

+ 5
- 4
common/JackRequestDecoder.cpp View File

@@ -45,7 +45,7 @@ JackRequestDecoder::~JackRequestDecoder()
int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* socket, int type_aux)
{
JackRequest::RequestType type = (JackRequest::RequestType)type_aux;
// Read data
switch (type) {

@@ -82,8 +82,9 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
CheckRead(req, socket);
res.fResult = fServer->GetEngine()->ClientExternalClose(req.fRefNum);
CheckWriteRefNum("JackRequest::ClientClose", socket);
fHandler->ClientRemove(socket, req.fRefNum);
break;
fHandler->ClientRemove(socket, req.fRefNum);
// Will cause the wrapping thread to stop
return -1;
}

case JackRequest::kActivateClient: {
@@ -341,7 +342,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
jack_error("Unknown request %ld", type);
return -1;
}
return 0;
}



+ 11
- 376
windows/JackWinNamedPipeServerChannel.cpp View File

@@ -53,13 +53,6 @@ JackClientPipeThread::~JackClientPipeThread()
delete fPipe;
}

bool JackClientPipeThread::IsRunning()
{
return (fRefNum >= 0);
//return (fRefNum >= GetEngineControl()->fDriverNum);
}


int JackClientPipeThread::Open(JackServer* server) // Open the Server/Client connection
{
// Start listening
@@ -75,14 +68,9 @@ int JackClientPipeThread::Open(JackServer* server) // Open the Server/Clien

void JackClientPipeThread::Close() // Close the Server/Client connection
{
jack_log("JackClientPipeThread::Close %x %ld", this, fRefNum);
/*
TODO : solve WIN32 thread Kill issue
This would hang.. since Close will be followed by a delete,
all ressources will be deallocated at the end.
*/
jack_log("JackClientPipeThread::Close 0 %x %ld", this, fRefNum);

fThread.Kill();
//fThread.Kill();
fPipe->Close();
fRefNum = -1;

@@ -94,7 +82,7 @@ bool JackClientPipeThread::Execute()
{
try {

jack_log("JackClientPipeThread::Execute");
jack_log("JackClientPipeThread::Execute %x", this);
JackRequest header;
int res = header.Read(fPipe);
bool ret = true;
@@ -112,6 +100,7 @@ bool JackClientPipeThread::Execute()
// Decode request
} else if (fDecoder->HandleRequest(fPipe, header.fType) < 0) {
jack_log("JackClientPipeThread::Execute : cannot decode request");
ret = false;
}

// Unlock the global mutex
@@ -126,380 +115,27 @@ bool JackClientPipeThread::Execute()
}
}

/*
void JackClientPipeThread::ClientAdd(char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
{
jack_log("JackClientPipeThread::ClientAdd %s", name);
fRefNum = -1;
*result = fServer->GetEngine()->ClientExternalOpen(name, pid, uuid, &fRefNum, shared_engine, shared_client, shared_graph);
}

void JackClientPipeThread::ClientRemove()
{
jack_log("JackClientPipeThread::ClientRemove ref = %d", fRefNum);
// TODO : solve WIN32 thread Kill issue
//Close();
//
fRefNum = -1;
fPipe->Close();
}
*/

void JackClientPipeThread::ClientAdd(detail::JackChannelTransactionInterface* socket, JackClientOpenRequest* req, JackClientOpenResult *res)
{
jack_info("JackClientPipeThread::ClientAdd %s", req->fName);
jack_log("JackClientPipeThread::ClientAdd %x %s", this, req->fName);
fRefNum = -1;
res->fResult = fServer->GetEngine()->ClientExternalOpen(req->fName, req->fPID, req->fUUID, &fRefNum, &res->fSharedEngine, &res->fSharedClient, &res->fSharedGraph);
}

void JackClientPipeThread::ClientRemove(detail::JackChannelTransactionInterface* socket_aux, int refnum)
{
jack_info("JackClientPipeThread::ClientRemove ref = %d", refnum);
// TODO : solve WIN32 thread Kill issue
//Close();
//
fRefNum = -1;
fPipe->Close();
}



/*
bool JackClientPipeThread::HandleRequest()
{
// Read header
JackRequest header;
int res = header.Read(fPipe);
bool ret = true;

// Lock the global mutex
if (WaitForSingleObject(fMutex, INFINITE) == WAIT_FAILED) {
jack_error("JackClientPipeThread::HandleRequest: mutex wait error");
}

if (res < 0) {
jack_error("HandleRequest: cannot read header");
ClientKill();
ret = false;
} else {

// Read data
switch (header.fType) {

case JackRequest::kClientCheck: {
jack_log("JackRequest::ClientCheck");
JackClientCheckRequest req;
JackClientCheckResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->ClientCheck(req.fName, req.fUUID, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
res.Write(fPipe);
// Atomic ClientCheck followed by ClientOpen on same pipe
if (req.fOpen)
HandleRequest();
break;
}

case JackRequest::kClientOpen: {
jack_log("JackRequest::ClientOpen");
JackClientOpenRequest req;
JackClientOpenResult res;
if (req.Read(fPipe) == 0)
ClientAdd(req.fName, req.fPID, req.fUUID, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);
res.Write(fPipe);
break;
}

case JackRequest::kClientClose: {
jack_log("JackRequest::ClientClose");
JackClientCloseRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->ClientExternalClose(req.fRefNum);
res.Write(fPipe);
ClientRemove();
ret = false;
break;
}

case JackRequest::kActivateClient: {
JackActivateRequest req;
JackResult res;
jack_log("JackRequest::ActivateClient");
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->ClientActivate(req.fRefNum, req.fIsRealTime);
res.Write(fPipe);
break;
}

case JackRequest::kDeactivateClient: {
jack_log("JackRequest::DeactivateClient");
JackDeactivateRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->ClientDeactivate(req.fRefNum);
res.Write(fPipe);
break;
}

case JackRequest::kRegisterPort: {
jack_log("JackRequest::RegisterPort");
JackPortRegisterRequest req;
JackPortRegisterResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->PortRegister(req.fRefNum, req.fName, req.fPortType, req.fFlags, req.fBufferSize, &res.fPortIndex);
res.Write(fPipe);
break;
}

case JackRequest::kUnRegisterPort: {
jack_log("JackRequest::UnRegisterPort");
JackPortUnRegisterRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->PortUnRegister(req.fRefNum, req.fPortIndex);
res.Write(fPipe);
break;
}

case JackRequest::kConnectNamePorts: {
jack_log("JackRequest::ConnectNamePorts");
JackPortConnectNameRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
res.Write(fPipe);
break;
}

case JackRequest::kDisconnectNamePorts: {
jack_log("JackRequest::DisconnectNamePorts");
JackPortDisconnectNameRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
res.Write(fPipe);
break;
}

case JackRequest::kConnectPorts: {
jack_log("JackRequest::ConnectPorts");
JackPortConnectRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
res.Write(fPipe);
break;
}

case JackRequest::kDisconnectPorts: {
jack_log("JackRequest::DisconnectPorts");
JackPortDisconnectRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
res.Write(fPipe);
break;
}

case JackRequest::kPortRename: {
jack_log("JackRequest::PortRename");
JackPortRenameRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->PortRename(req.fRefNum, req.fPort, req.fName);
res.Write(fPipe);
break;
}

case JackRequest::kSetBufferSize: {
jack_log("JackRequest::SetBufferSize");
JackSetBufferSizeRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->SetBufferSize(req.fBufferSize);
res.Write(fPipe);
break;
}

case JackRequest::kSetFreeWheel: {
jack_log("JackRequest::SetFreeWheel");
JackSetFreeWheelRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->SetFreewheel(req.fOnOff);
res.Write(fPipe);
break;
}

case JackRequest::kComputeTotalLatencies: {
jack_log("JackRequest::ComputeTotalLatencies");
JackComputeTotalLatenciesRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->ComputeTotalLatencies();
res.Write(fPipe);
break;
}

case JackRequest::kReleaseTimebase: {
jack_log("JackRequest::ReleaseTimebase");
JackReleaseTimebaseRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->ReleaseTimebase(req.fRefNum);
res.Write(fPipe);
break;
}

case JackRequest::kSetTimebaseCallback: {
jack_log("JackRequest::SetTimebaseCallback");
JackSetTimebaseCallbackRequest req;
JackResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->SetTimebaseCallback(req.fRefNum, req.fConditionnal);
res.Write(fPipe);
break;
}

case JackRequest::kGetInternalClientName: {
jack_log("JackRequest::GetInternalClientName");
JackGetInternalClientNameRequest req;
JackGetInternalClientNameResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->GetInternalClientName(req.fIntRefNum, res.fName);
res.Write(fPipe);
break;
}

case JackRequest::kInternalClientHandle: {
jack_log("JackRequest::InternalClientHandle");
JackInternalClientHandleRequest req;
JackInternalClientHandleResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->InternalClientHandle(req.fName, &res.fStatus, &res.fIntRefNum);
res.Write(fPipe);
break;
}

case JackRequest::kInternalClientLoad: {
jack_log("JackRequest::InternalClientLoad");
JackInternalClientLoadRequest req;
JackInternalClientLoadResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->InternalClientLoad1(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, req.fUUID, &res.fStatus);
res.Write(fPipe);
break;
}

case JackRequest::kInternalClientUnload: {
jack_log("JackRequest::InternalClientUnload");
JackInternalClientUnloadRequest req;
JackInternalClientUnloadResult res;
if (req.Read(fPipe) == 0)
res.fResult = fServer->GetEngine()->InternalClientUnload(req.fIntRefNum, &res.fStatus);
res.Write(fPipe);
break;
}

case JackRequest::kNotification: {
jack_log("JackRequest::Notification");
JackClientNotificationRequest req;
if (req.Read(fPipe) == 0) {
if (req.fNotify == kQUIT) {
jack_log("JackRequest::Notification kQUIT");
throw JackQuitException();
} else {
fServer->Notify(req.fRefNum, req.fNotify, req.fValue);
}
}
break;
}

case JackRequest::kSessionNotify: {
jack_log("JackRequest::SessionNotify");
JackSessionNotifyRequest req;
if (req.Read(fPipe) == 0) {
fServer->GetEngine()->SessionNotify(req.fRefNum, req.fDst, req.fEventType, req.fPath, fPipe, NULL);
}
break;
}

case JackRequest::kSessionReply: {
jack_log("JackRequest::SessionReply");
JackSessionReplyRequest req;
JackResult res;
if (req.Read(fPipe) == 0) {
fServer->GetEngine()->SessionReply(req.fRefNum);
res.fResult = 0;
}
res.Write(fPipe);
break;
}

case JackRequest::kGetClientByUUID: {
jack_log("JackRequest::GetClientByUUID");
JackGetClientNameRequest req;
JackClientNameResult res;
if (req.Read(fPipe) == 0) {
res.fResult = fServer->GetEngine()->GetClientNameForUUID(req.fUUID, res.fName);
}
res.Write(fPipe);
break;
}

case JackRequest::kGetUUIDByClient: {
jack_log("JackRequest::GetUUIDByClient");
JackGetUUIDRequest req;
JackUUIDResult res;
if (req.Read(fPipe) == 0) {
res.fResult = fServer->GetEngine()->GetUUIDForClientName(req.fName, res.fUUID);
}
res.Write(fPipe);
break;
}

case JackRequest::kReserveClientName: {
jack_log("JackRequest::ReserveClientName");
JackReserveNameRequest req;
JackResult res;
if (req.Read(fPipe) == 0) {
res.fResult = fServer->GetEngine()->ReserveClientName(req.fName, req.fUUID);
}
res.Write(fPipe);
break;
}

case JackRequest::kClientHasSessionCallback: {
jack_log("JackRequest::ClientHasSessionCallback");
JackClientHasSessionCallbackRequest req;
JackResult res;
if (req.Read(fPipe) == 0) {
res.fResult = fServer->GetEngine()->ClientHasSessionCallback(req.fName);
}
res.Write(fPipe);
break;
}

default:
jack_log("Unknown request %ld", header.fType);
break;
}
}

// Unlock the global mutex
ReleaseMutex(fMutex);
return ret;
jack_log("JackClientPipeThread::ClientRemove ref = %d", refnum);
Close();
}
*/

void JackClientPipeThread::ClientKill()
{
jack_log("JackClientPipeThread::ClientKill ref = %d", fRefNum);

if (fRefNum == -1) { // Correspond to an already removed client.
jack_log("Kill a closed client");
jack_log("Kill a closed client %x", this);
} else if (fRefNum == 0) { // Correspond to a still not opened client.
jack_log("Kill a not opened client");
jack_log("Kill a not opened client %x", this);
} else {
fServer->ClientKill(fRefNum);
}
@@ -564,7 +200,6 @@ void JackWinNamedPipeServerChannel::Stop()
fThread.Kill();
}


bool JackWinNamedPipeServerChannel::Init()
{
jack_log("JackWinNamedPipeServerChannel::Init");
@@ -610,11 +245,10 @@ void JackWinNamedPipeServerChannel::ClientAdd(JackWinNamedPipeClient* pipe)
std::list<JackClientPipeThread*>::iterator it = fClientList.begin();
JackClientPipeThread* client;

jack_info("JackWinNamedPipeServerChannel::ClientAdd size %ld", fClientList.size());
jack_log("JackWinNamedPipeServerChannel::ClientAdd size %ld", fClientList.size());

while (it != fClientList.end()) {
client = *it;
jack_info("Remove dead client = %x running = %ld ref = %d", client, client->IsRunning(), client->GetRefNum());
if (client->IsRunning()) {
it++;
} else {
@@ -625,6 +259,7 @@ void JackWinNamedPipeServerChannel::ClientAdd(JackWinNamedPipeClient* pipe)

client = new JackClientPipeThread(pipe);
client->Open(fServer);

// Here we are sure that the client is running (because it's thread is in "running" state).
fClientList.push_back(client);
}


+ 4
- 9
windows/JackWinNamedPipeServerChannel.h View File

@@ -35,7 +35,6 @@ namespace Jack
class JackServer;

class JackClientPipeThread : public JackRunnableInterface, public JackClientHandlerInterface
//class JackClientPipeThread : public JackRunnableInterface
{

private:
@@ -46,9 +45,6 @@ class JackClientPipeThread : public JackRunnableInterface, public JackClientHand
JackThread fThread;
int fRefNum;

//void ClientAdd(char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
//void ClientRemove();

void ClientAdd(detail::JackChannelTransactionInterface* socket, JackClientOpenRequest* req, JackClientOpenResult *res);
void ClientRemove(detail::JackChannelTransactionInterface* socket, int refnum);

@@ -64,15 +60,14 @@ class JackClientPipeThread : public JackRunnableInterface, public JackClientHand
int Open(JackServer* server); // Open the Server/Client connection
void Close(); // Close the Server/Client connection

//bool HandleRequest();

// JackRunnableInterface interface
bool Execute();

// To be used for find out if the object can be deleted
bool IsRunning();

int GetRefNum() { return fRefNum; }
bool IsRunning()
{
return (fRefNum >= 0);
}

};



+ 5
- 2
windows/JackWinServerLaunch.cpp View File

@@ -285,9 +285,12 @@ static int server_connect(const char* server_name)
{
JackClientChannel channel;
int res = channel.ServerCheck(server_name);
channel.Close();
channel.Close();
/*
JackSleep(2000); // Added by JE - 02-01-2009 (gives
// the channel some time to close)
// the channel some time to close)
*/
JackSleep(500);
return res;
}



Write Preview
Loading…
Cancel
Save