Jack2: JackRequest.h Source File

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 Lesser General Public License as published by
00007 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
00014 
00015 You should have received a copy of the GNU Lesser General Public License
00016 along with this program; if not, write to the Free Software
00017 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00018 
00019 */
00020 
00021 #ifndef __JackRequest__
00022 #define __JackRequest__
00023 
00024 #include "JackConstants.h"
00025 #include "JackError.h"
00026 #include "JackPlatformPlug.h"
00027 #include "JackChannel.h"
00028 #include "JackTime.h"
00029 #include "types.h"
00030 #include <string.h>
00031 #include <stdio.h>
00032 #include <stdlib.h>
00033 #include <list>
00034 
00035 namespace Jack
00036 {
00037 
00038 #define CheckRes(exp) { if ((exp) < 0) { jack_error("CheckRes error"); return -1; } }
00039 #define CheckSize() { CheckRes(trans->Read(&fSize, sizeof(int))); if (fSize != Size()) { jack_error("CheckSize error size = %d Size() = %d", fSize, Size()); return -1; } }
00040 
00045 enum JackSessionReply {
00046 
00047     kImmediateSessionReply = 1,
00048     kPendingSessionReply = 2
00049 
00050 };
00051 
00056 struct JackRequest
00057 {
00058 
00059     enum RequestType {
00060         kRegisterPort = 1,
00061         kUnRegisterPort = 2,
00062         kConnectPorts = 3,
00063         kDisconnectPorts = 4,
00064         kSetTimeBaseClient = 5,
00065         kActivateClient = 6,
00066         kDeactivateClient = 7,
00067         kDisconnectPort = 8,
00068         kSetClientCapabilities = 9,
00069         kGetPortConnections = 10,
00070         kGetPortNConnections = 11,
00071         kReleaseTimebase = 12,
00072         kSetTimebaseCallback = 13,
00073         kSetBufferSize = 20,
00074         kSetFreeWheel = 21,
00075         kClientCheck = 22,
00076         kClientOpen = 23,
00077         kClientClose = 24,
00078         kConnectNamePorts = 25,
00079         kDisconnectNamePorts = 26,
00080         kGetInternalClientName = 27,
00081         kInternalClientHandle = 28,
00082         kInternalClientLoad = 29,
00083         kInternalClientUnload = 30,
00084         kPortRename = 31,
00085         kNotification = 32,
00086         kSessionNotify = 33,
00087         kSessionReply  = 34,
00088         kGetClientByUUID = 35,
00089         kReserveClientName = 36,
00090         kGetUUIDByClient = 37,
00091         kClientHasSessionCallback = 38,
00092         kComputeTotalLatencies = 39
00093     };
00094 
00095     RequestType fType;
00096     int fSize;
00097 
00098     JackRequest(): fType((RequestType)0), fSize(0)
00099     {}
00100 
00101     JackRequest(RequestType type): fType(type), fSize(0)
00102     {}
00103 
00104     virtual ~JackRequest()
00105     {}
00106 
00107     virtual int Read(detail::JackChannelTransactionInterface* trans)
00108     {
00109         return trans->Read(&fType, sizeof(RequestType));
00110     }
00111 
00112     virtual int Write(detail::JackChannelTransactionInterface* trans) { return -1; }
00113     
00114     virtual int Write(detail::JackChannelTransactionInterface* trans, int size)
00115     {
00116         fSize = size;
00117         CheckRes(trans->Write(&fType, sizeof(RequestType)));
00118         return trans->Write(&fSize, sizeof(int));
00119     }
00120     
00121     virtual int Size() { return 0; }
00122 
00123 };
00124 
00129 struct JackResult
00130 {
00131 
00132     int fResult;
00133 
00134     JackResult(): fResult( -1)
00135     {}
00136     JackResult(int result): fResult(result)
00137     {}
00138     virtual ~JackResult()
00139     {}
00140 
00141     virtual int Read(detail::JackChannelTransactionInterface* trans)
00142     {
00143         return trans->Read(&fResult, sizeof(int));
00144     }
00145 
00146     virtual int Write(detail::JackChannelTransactionInterface* trans)
00147     {
00148         return trans->Write(&fResult, sizeof(int));
00149     }
00150 
00151 };
00152 
00157 struct JackClientCheckRequest : public JackRequest
00158 {
00159 
00160     char fName[JACK_CLIENT_NAME_SIZE + 1];
00161     int fProtocol;
00162     int fOptions;
00163     int fUUID;
00164     int fOpen;
00165 
00166     JackClientCheckRequest()
00167     {}
00168     JackClientCheckRequest(const char* name, int protocol, int options, int uuid, int open = false)
00169         : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options), fUUID(uuid), fOpen(open)
00170     {
00171         snprintf(fName, sizeof(fName), "%s", name);
00172     }
00173 
00174     int Read(detail::JackChannelTransactionInterface* trans)
00175     {
00176         CheckSize();
00177         CheckRes(trans->Read(&fName, sizeof(fName)));
00178         CheckRes(trans->Read(&fProtocol, sizeof(int)));
00179         CheckRes(trans->Read(&fOptions, sizeof(int)));
00180         CheckRes(trans->Read(&fUUID, sizeof(int)));
00181         return trans->Read(&fOpen, sizeof(int));
00182     }
00183 
00184     int Write(detail::JackChannelTransactionInterface* trans)
00185     {
00186         CheckRes(JackRequest::Write(trans, Size()));
00187         CheckRes(trans->Write(&fName, sizeof(fName)));
00188         CheckRes(trans->Write(&fProtocol, sizeof(int)));
00189         CheckRes(trans->Write(&fOptions, sizeof(int)));
00190         CheckRes(trans->Write(&fUUID, sizeof(int)));
00191         return trans->Write(&fOpen, sizeof(int));
00192     }
00193     
00194     int Size() { return sizeof(fName) + 4 * sizeof(int); }
00195 
00196 };
00197 
00202 struct JackClientCheckResult : public JackResult
00203 {
00204 
00205     char fName[JACK_CLIENT_NAME_SIZE + 1];
00206     int fStatus;
00207 
00208     JackClientCheckResult(): JackResult(), fStatus(0)
00209     {}
00210     JackClientCheckResult(int32_t result, const char* name, int status)
00211             : JackResult(result), fStatus(status)
00212     {
00213         snprintf(fName, sizeof(fName), "%s", name);
00214     }
00215 
00216     int Read(detail::JackChannelTransactionInterface* trans)
00217     {
00218         CheckRes(JackResult::Read(trans));
00219         CheckRes(trans->Read(&fName, sizeof(fName)));
00220         CheckRes(trans->Read(&fStatus, sizeof(int)));
00221         return 0;
00222     }
00223 
00224     int Write(detail::JackChannelTransactionInterface* trans)
00225     {
00226         CheckRes(JackResult::Write(trans));
00227         CheckRes(trans->Write(&fName, sizeof(fName)));
00228         CheckRes(trans->Write(&fStatus, sizeof(int)));
00229         return 0;
00230     }
00231 
00232 };
00233 
00238 struct JackClientOpenRequest : public JackRequest
00239 {
00240 
00241     int fPID;
00242     int fUUID;
00243     char fName[JACK_CLIENT_NAME_SIZE + 1];
00244 
00245     JackClientOpenRequest()
00246     {}
00247     JackClientOpenRequest(const char* name, int pid, int uuid): JackRequest(JackRequest::kClientOpen)
00248     {
00249         snprintf(fName, sizeof(fName), "%s", name);
00250         fPID = pid;
00251         fUUID = uuid;
00252     }
00253 
00254     int Read(detail::JackChannelTransactionInterface* trans)
00255     {
00256         CheckSize();
00257         CheckRes(trans->Read(&fPID, sizeof(int)));
00258         CheckRes(trans->Read(&fUUID, sizeof(int)));
00259         return trans->Read(&fName, sizeof(fName));
00260     }
00261 
00262     int Write(detail::JackChannelTransactionInterface* trans)
00263     {
00264         CheckRes(JackRequest::Write(trans, Size()));
00265         CheckRes(trans->Write(&fPID, sizeof(int)));
00266         CheckRes(trans->Write(&fUUID, sizeof(int)));
00267         return trans->Write(&fName, sizeof(fName));
00268     }
00269 
00270     int Size() { return 2 * sizeof(int) + sizeof(fName); }
00271     
00272 };
00273 
00278 struct JackClientOpenResult : public JackResult
00279 {
00280 
00281     int fSharedEngine;
00282     int fSharedClient;
00283     int fSharedGraph;
00284 
00285     JackClientOpenResult()
00286             : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
00287     {}
00288     JackClientOpenResult(int32_t result, int index1, int index2, int index3)
00289             : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
00290     {}
00291 
00292     int Read(detail::JackChannelTransactionInterface* trans)
00293     {
00294         CheckRes(JackResult::Read(trans));
00295         CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
00296         CheckRes(trans->Read(&fSharedClient, sizeof(int)));
00297         CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
00298         return 0;
00299     }
00300 
00301     int Write(detail::JackChannelTransactionInterface* trans)
00302     {
00303         CheckRes(JackResult::Write(trans));
00304         CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
00305         CheckRes(trans->Write(&fSharedClient, sizeof(int)));
00306         CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
00307         return 0;
00308     }
00309 
00310 };
00311 
00316 struct JackClientCloseRequest : public JackRequest
00317 {
00318 
00319     int fRefNum;
00320 
00321     JackClientCloseRequest()
00322     {}
00323     JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
00324     {}
00325 
00326     int Read(detail::JackChannelTransactionInterface* trans)
00327     {
00328         CheckSize();
00329         return trans->Read(&fRefNum, sizeof(int));
00330     }
00331 
00332     int Write(detail::JackChannelTransactionInterface* trans)
00333     {
00334         CheckRes(JackRequest::Write(trans, Size()));
00335         return trans->Write(&fRefNum, sizeof(int));
00336     }
00337 
00338     int Size() { return sizeof(int); }
00339 };
00340 
00345 struct JackActivateRequest : public JackRequest
00346 {
00347 
00348     int fRefNum;
00349     int fIsRealTime;
00350 
00351     JackActivateRequest()
00352     {}
00353     JackActivateRequest(int refnum, int is_real_time)
00354         : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fIsRealTime(is_real_time)
00355     {}
00356 
00357     int Read(detail::JackChannelTransactionInterface* trans)
00358     {
00359         CheckSize();
00360         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00361         return trans->Read(&fIsRealTime, sizeof(int));
00362     }
00363 
00364     int Write(detail::JackChannelTransactionInterface* trans)
00365     {
00366         CheckRes(JackRequest::Write(trans, Size()));
00367         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00368         return trans->Write(&fIsRealTime, sizeof(int));
00369     }
00370 
00371     int Size() { return 2 * sizeof(int); }
00372 };
00373 
00378 struct JackDeactivateRequest : public JackRequest
00379 {
00380 
00381     int fRefNum;
00382 
00383     JackDeactivateRequest()
00384     {}
00385     JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
00386     {}
00387 
00388     int Read(detail::JackChannelTransactionInterface* trans)
00389     {
00390         CheckSize();
00391         return trans->Read(&fRefNum, sizeof(int));
00392     }
00393 
00394     int Write(detail::JackChannelTransactionInterface* trans)
00395     {
00396         CheckRes(JackRequest::Write(trans, Size()));
00397         return trans->Write(&fRefNum, sizeof(int));
00398     }
00399 
00400     int Size() { return sizeof(int); }
00401 };
00402 
00407 struct JackPortRegisterRequest : public JackRequest
00408 {
00409 
00410     int fRefNum;
00411     char fName[JACK_PORT_NAME_SIZE + 1];   // port short name
00412     char fPortType[JACK_PORT_TYPE_SIZE + 1];
00413     unsigned int fFlags;
00414     unsigned int fBufferSize;
00415 
00416     JackPortRegisterRequest()
00417     {}
00418     JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
00419             : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
00420     {
00421         strcpy(fName, name);
00422         strcpy(fPortType, port_type);
00423     }
00424 
00425     int Read(detail::JackChannelTransactionInterface* trans)
00426     {
00427         CheckSize();
00428         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00429         CheckRes(trans->Read(&fName, sizeof(fName)));
00430         CheckRes(trans->Read(&fPortType, sizeof(fPortType)));
00431         CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
00432         CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
00433         return 0;
00434     }
00435 
00436     int Write(detail::JackChannelTransactionInterface* trans)
00437     {
00438         CheckRes(JackRequest::Write(trans, Size()));
00439         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00440         CheckRes(trans->Write(&fName, sizeof(fName)));
00441         CheckRes(trans->Write(&fPortType, sizeof(fPortType)));
00442         CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
00443         CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
00444         return 0;
00445     }
00446     
00447     int Size() { return sizeof(int) + sizeof(fName) + sizeof(fPortType) + 2 * sizeof(unsigned int); }
00448 
00449 };
00450 
00455 struct JackPortRegisterResult : public JackResult
00456 {
00457 
00458     jack_port_id_t fPortIndex;
00459 
00460     JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
00461     {}
00462 
00463     int Read(detail::JackChannelTransactionInterface* trans)
00464     {
00465         CheckRes(JackResult::Read(trans));
00466         return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
00467     }
00468 
00469     int Write(detail::JackChannelTransactionInterface* trans)
00470     {
00471         CheckRes(JackResult::Write(trans));
00472         return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
00473     }
00474 
00475 };
00476 
00481 struct JackPortUnRegisterRequest : public JackRequest
00482 {
00483 
00484     int fRefNum;
00485     jack_port_id_t fPortIndex;
00486 
00487     JackPortUnRegisterRequest()
00488     {}
00489     JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
00490         : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
00491     {}
00492 
00493     int Read(detail::JackChannelTransactionInterface* trans)
00494     {
00495         CheckSize();
00496         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00497         CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
00498         return 0;
00499     }
00500 
00501     int Write(detail::JackChannelTransactionInterface* trans)
00502     {
00503         CheckRes(JackRequest::Write(trans, Size()));
00504         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00505         CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
00506         return 0;
00507     }
00508 
00509     int Size() { return sizeof(int) + sizeof(jack_port_id_t); }
00510 };
00511 
00516 struct JackPortConnectNameRequest : public JackRequest
00517 {
00518 
00519     int fRefNum;
00520     char fSrc[REAL_JACK_PORT_NAME_SIZE + 1];    // port full name
00521     char fDst[REAL_JACK_PORT_NAME_SIZE + 1];    // port full name
00522 
00523     JackPortConnectNameRequest()
00524     {}
00525     JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00526         : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
00527     {
00528         strcpy(fSrc, src_name);
00529         strcpy(fDst, dst_name);
00530     }
00531 
00532     int Read(detail::JackChannelTransactionInterface* trans)
00533     {
00534         CheckSize();
00535         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00536         CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
00537         CheckRes(trans->Read(&fDst, sizeof(fDst)));
00538         return 0;
00539     }
00540 
00541     int Write(detail::JackChannelTransactionInterface* trans)
00542     {
00543         CheckRes(JackRequest::Write(trans, Size()));
00544         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00545         CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
00546         CheckRes(trans->Write(&fDst, sizeof(fDst)));
00547         return 0;
00548     }
00549     
00550     int Size() { return sizeof(int) + sizeof(fSrc) + sizeof(fDst); }
00551 
00552 };
00553 
00558 struct JackPortDisconnectNameRequest : public JackRequest
00559 {
00560 
00561     int fRefNum;
00562     char fSrc[REAL_JACK_PORT_NAME_SIZE + 1];    // port full name
00563     char fDst[REAL_JACK_PORT_NAME_SIZE + 1];    // port full name
00564 
00565     JackPortDisconnectNameRequest()
00566     {}
00567     JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00568         : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
00569     {
00570         strcpy(fSrc, src_name);
00571         strcpy(fDst, dst_name);
00572     }
00573 
00574     int Read(detail::JackChannelTransactionInterface* trans)
00575     {
00576         CheckSize();
00577         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00578         CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
00579         CheckRes(trans->Read(&fDst, sizeof(fDst)));
00580         return 0;
00581     }
00582 
00583     int Write(detail::JackChannelTransactionInterface* trans)
00584     {
00585         CheckRes(JackRequest::Write(trans, Size()));
00586         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00587         CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
00588         CheckRes(trans->Write(&fDst, sizeof(fDst)));
00589         return 0;
00590     }
00591 
00592     int Size() { return sizeof(int) + sizeof(fSrc) + sizeof(fDst); }
00593     
00594 };
00595 
00600 struct JackPortConnectRequest : public JackRequest
00601 {
00602 
00603     int fRefNum;
00604     jack_port_id_t fSrc;
00605     jack_port_id_t fDst;
00606 
00607     JackPortConnectRequest()
00608     {}
00609     JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00610         : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00611     {}
00612 
00613     int Read(detail::JackChannelTransactionInterface* trans)
00614     {
00615         CheckSize();
00616         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00617         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00618         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00619         return 0;
00620     }
00621 
00622     int Write(detail::JackChannelTransactionInterface* trans)
00623     {
00624         CheckRes(JackRequest::Write(trans, Size()));
00625         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00626         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00627         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00628         return 0;
00629     }
00630 
00631     int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(jack_port_id_t); }
00632 };
00633 
00638 struct JackPortDisconnectRequest : public JackRequest
00639 {
00640 
00641     int fRefNum;
00642     jack_port_id_t fSrc;
00643     jack_port_id_t fDst;
00644 
00645     JackPortDisconnectRequest()
00646     {}
00647     JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00648         : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00649     {}
00650 
00651     int Read(detail::JackChannelTransactionInterface* trans)
00652     {
00653         CheckSize();
00654         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00655         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00656         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00657         return 0;
00658     }
00659 
00660     int Write(detail::JackChannelTransactionInterface* trans)
00661     {
00662         CheckRes(JackRequest::Write(trans, Size()));
00663         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00664         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00665         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00666         return 0;
00667     }
00668 
00669     int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(jack_port_id_t); }
00670 };
00671 
00676 struct JackPortRenameRequest : public JackRequest
00677 {
00678 
00679     int fRefNum;
00680     jack_port_id_t fPort;
00681     char fName[JACK_PORT_NAME_SIZE + 1];   // port short name
00682 
00683     JackPortRenameRequest()
00684     {}
00685     JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
00686         : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
00687     {
00688         strcpy(fName, name);
00689     }
00690 
00691     int Read(detail::JackChannelTransactionInterface* trans)
00692     {
00693         CheckSize();
00694         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00695         CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
00696         CheckRes(trans->Read(&fName, sizeof(fName)));
00697         return 0;
00698     }
00699 
00700     int Write(detail::JackChannelTransactionInterface* trans)
00701     {
00702         CheckRes(JackRequest::Write(trans, Size()));
00703         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00704         CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
00705         CheckRes(trans->Write(&fName, sizeof(fName)));
00706         return 0;
00707     }
00708     
00709     int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(fName); }
00710 
00711 };
00712 
00717 struct JackSetBufferSizeRequest : public JackRequest
00718 {
00719 
00720     jack_nframes_t fBufferSize;
00721 
00722     JackSetBufferSizeRequest()
00723     {}
00724     JackSetBufferSizeRequest(jack_nframes_t buffer_size)
00725         : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
00726     {}
00727 
00728     int Read(detail::JackChannelTransactionInterface* trans)
00729     {
00730         CheckSize();
00731         return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
00732     }
00733 
00734     int Write(detail::JackChannelTransactionInterface* trans)
00735     {
00736         CheckRes(JackRequest::Write(trans, Size()));
00737         return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
00738     }
00739 
00740     int Size() { return sizeof(jack_nframes_t); }
00741 };
00742 
00747 struct JackSetFreeWheelRequest : public JackRequest
00748 {
00749 
00750     int fOnOff;
00751 
00752     JackSetFreeWheelRequest()
00753     {}
00754     JackSetFreeWheelRequest(int onoff)
00755         : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
00756     {}
00757 
00758     int Read(detail::JackChannelTransactionInterface* trans)
00759     {
00760         CheckSize();
00761         return trans->Read(&fOnOff, sizeof(int));
00762     }
00763 
00764     int Write(detail::JackChannelTransactionInterface* trans)
00765     {
00766         CheckRes(JackRequest::Write(trans, Size()));
00767         return trans->Write(&fOnOff, sizeof(int));
00768     }
00769     
00770     int Size() { return sizeof(int); }
00771 
00772 };
00773 
00778 struct JackComputeTotalLatenciesRequest : public JackRequest
00779 {
00780 
00781     JackComputeTotalLatenciesRequest()
00782         : JackRequest(JackRequest::kComputeTotalLatencies)
00783     {}
00784 
00785     int Read(detail::JackChannelTransactionInterface* trans)
00786     {
00787         CheckSize();
00788         return 0;
00789     }
00790 
00791     int Write(detail::JackChannelTransactionInterface* trans)
00792     {
00793         CheckRes(JackRequest::Write(trans, Size()));
00794         return 0;
00795     }
00796 
00797     int Size() { return 0; }
00798 };
00799 
00804 struct JackReleaseTimebaseRequest : public JackRequest
00805 {
00806 
00807     int fRefNum;
00808 
00809     JackReleaseTimebaseRequest()
00810     {}
00811     JackReleaseTimebaseRequest(int refnum)
00812         : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
00813     {}
00814 
00815     int Read(detail::JackChannelTransactionInterface* trans)
00816     {
00817         CheckSize();
00818         return trans->Read(&fRefNum, sizeof(int));
00819     }
00820 
00821     int Write(detail::JackChannelTransactionInterface* trans)
00822     {
00823         CheckRes(JackRequest::Write(trans, Size()));
00824         return trans->Write(&fRefNum, sizeof(int));
00825     }
00826     
00827     int Size() { return sizeof(int); }
00828 
00829 };
00830 
00835 struct JackSetTimebaseCallbackRequest : public JackRequest
00836 {
00837 
00838     int fRefNum;
00839     int fConditionnal;
00840 
00841     JackSetTimebaseCallbackRequest()
00842     {}
00843     JackSetTimebaseCallbackRequest(int refnum, int conditional)
00844         : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
00845     {}
00846 
00847     int Read(detail::JackChannelTransactionInterface* trans)
00848     {
00849         CheckSize();
00850         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00851         return trans->Read(&fConditionnal, sizeof(int));
00852     }
00853 
00854     int Write(detail::JackChannelTransactionInterface* trans)
00855     {
00856         CheckRes(JackRequest::Write(trans, Size()));
00857         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00858         return trans->Write(&fConditionnal, sizeof(int));
00859     }
00860 
00861     int Size() { return sizeof(int) + sizeof(int); }
00862 };
00863 
00868 struct JackGetInternalClientNameRequest : public JackRequest
00869 {
00870 
00871     int fRefNum;
00872     int fIntRefNum;
00873 
00874     JackGetInternalClientNameRequest()
00875     {}
00876     JackGetInternalClientNameRequest(int refnum, int int_ref)
00877             : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
00878     {}
00879 
00880     int Read(detail::JackChannelTransactionInterface* trans)
00881     {
00882         CheckSize();
00883         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00884         return trans->Read(&fIntRefNum, sizeof(int));
00885     }
00886 
00887     int Write(detail::JackChannelTransactionInterface* trans)
00888     {
00889         CheckRes(JackRequest::Write(trans, Size()));
00890         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00891         return trans->Write(&fIntRefNum, sizeof(int));
00892     }
00893 
00894     int Size() { return sizeof(int) + sizeof(int); }
00895 };
00896 
00901 struct JackGetInternalClientNameResult : public JackResult
00902 {
00903 
00904     char fName[JACK_CLIENT_NAME_SIZE + 1];
00905 
00906     JackGetInternalClientNameResult(): JackResult()
00907     {}
00908     JackGetInternalClientNameResult(int32_t result, const char* name)
00909             : JackResult(result)
00910     {
00911         snprintf(fName, sizeof(fName), "%s", name);
00912     }
00913 
00914     int Read(detail::JackChannelTransactionInterface* trans)
00915     {
00916         CheckRes(JackResult::Read(trans));
00917         CheckRes(trans->Read(&fName, sizeof(fName)));
00918         return 0;
00919     }
00920 
00921     int Write(detail::JackChannelTransactionInterface* trans)
00922     {
00923         CheckRes(JackResult::Write(trans));
00924         CheckRes(trans->Write(&fName, sizeof(fName)));
00925         return 0;
00926     }
00927 
00928     int Size() { return sizeof(fName); }
00929 };
00930 
00935 struct JackInternalClientHandleRequest : public JackRequest
00936 {
00937 
00938     int fRefNum;
00939     char fName[JACK_CLIENT_NAME_SIZE + 1];
00940 
00941     JackInternalClientHandleRequest()
00942     {}
00943     JackInternalClientHandleRequest(int refnum, const char* client_name)
00944             : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
00945     {
00946         snprintf(fName, sizeof(fName), "%s", client_name);
00947     }
00948 
00949     int Read(detail::JackChannelTransactionInterface* trans)
00950     {
00951         CheckSize();
00952         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00953         return trans->Read(&fName, sizeof(fName));
00954     }
00955 
00956     int Write(detail::JackChannelTransactionInterface* trans)
00957     {
00958         CheckRes(JackRequest::Write(trans, Size()));
00959         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00960         return trans->Write(&fName, sizeof(fName));
00961     }
00962 
00963     int Size() { return sizeof(int) + sizeof(fName); }
00964 };
00965 
00970 struct JackInternalClientHandleResult : public JackResult
00971 {
00972 
00973     int fStatus;
00974     int fIntRefNum;
00975 
00976     JackInternalClientHandleResult(): JackResult()
00977     {}
00978     JackInternalClientHandleResult(int32_t result, int status, int int_ref)
00979             : JackResult(result), fStatus(status), fIntRefNum(int_ref)
00980     {}
00981 
00982     int Read(detail::JackChannelTransactionInterface* trans)
00983     {
00984         CheckRes(JackResult::Read(trans));
00985         CheckRes(trans->Read(&fStatus, sizeof(int)));
00986         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00987         return 0;
00988     }
00989 
00990     int Write(detail::JackChannelTransactionInterface* trans)
00991     {
00992         CheckRes(JackResult::Write(trans));
00993         CheckRes(trans->Write(&fStatus, sizeof(int)));
00994         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00995         return 0;
00996     }
00997 
00998     int Size() { return sizeof(int) + sizeof(int); }
00999 };
01000 
01005 struct JackInternalClientLoadRequest : public JackRequest
01006 {
01007 
01008 #ifndef MAX_PATH
01009 #define MAX_PATH 256
01010 #endif
01011 
01012     int fRefNum;
01013     char fName[JACK_CLIENT_NAME_SIZE + 1];
01014     char fDllName[MAX_PATH + 1];
01015     char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
01016     int fOptions;
01017     int fUUID;
01018 
01019     JackInternalClientLoadRequest()
01020     {}
01021     JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int uuid )
01022             : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options), fUUID(uuid)
01023     {
01024         snprintf(fName, sizeof(fName), "%s", client_name);
01025         snprintf(fDllName, sizeof(fDllName), "%s", so_name);
01026         snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
01027         snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
01028     }
01029 
01030     int Read(detail::JackChannelTransactionInterface* trans)
01031     {
01032         CheckSize();
01033         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01034         CheckRes(trans->Read(&fName, sizeof(fName)));
01035         CheckRes(trans->Read(&fDllName, sizeof(fDllName)));
01036         CheckRes(trans->Read(&fLoadInitName, sizeof(fLoadInitName)));
01037         CheckRes(trans->Read(&fUUID, sizeof(int)));
01038         return trans->Read(&fOptions, sizeof(int));
01039     }
01040 
01041     int Write(detail::JackChannelTransactionInterface* trans)
01042     {
01043         CheckRes(JackRequest::Write(trans, Size()));
01044         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01045         CheckRes(trans->Write(&fName, sizeof(fName)));
01046         CheckRes(trans->Write(&fDllName, sizeof(fDllName)));
01047         CheckRes(trans->Write(&fLoadInitName, sizeof(fLoadInitName)));
01048         CheckRes(trans->Write(&fUUID, sizeof(int)));
01049         return trans->Write(&fOptions, sizeof(int));
01050     }
01051 
01052     int Size() { return sizeof(int) + sizeof(fName) + sizeof(fDllName) + sizeof(fLoadInitName) + 2 * sizeof(int); }
01053 };
01054 
01059 struct JackInternalClientLoadResult : public JackResult
01060 {
01061 
01062     int fStatus;
01063     int fIntRefNum;
01064 
01065     JackInternalClientLoadResult(): JackResult()
01066     {}
01067     JackInternalClientLoadResult(int32_t result, int status, int int_ref)
01068             : JackResult(result), fStatus(status), fIntRefNum(int_ref)
01069     {}
01070 
01071     int Read(detail::JackChannelTransactionInterface* trans)
01072     {
01073         CheckRes(JackResult::Read(trans));
01074         CheckRes(trans->Read(&fStatus, sizeof(int)));
01075         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
01076         return 0;
01077     }
01078 
01079     int Write(detail::JackChannelTransactionInterface* trans)
01080     {
01081         CheckRes(JackResult::Write(trans));
01082         CheckRes(trans->Write(&fStatus, sizeof(int)));
01083         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
01084         return 0;
01085     }
01086 
01087     int Size() { return sizeof(int) + sizeof(int); }
01088 };
01089 
01094 struct JackInternalClientUnloadRequest : public JackRequest
01095 {
01096 
01097     int fRefNum;
01098     int fIntRefNum;
01099 
01100     JackInternalClientUnloadRequest()
01101     {}
01102     JackInternalClientUnloadRequest(int refnum, int int_ref)
01103             : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
01104     {}
01105 
01106     int Read(detail::JackChannelTransactionInterface* trans)
01107     {
01108         CheckSize();
01109         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01110         return trans->Read(&fIntRefNum, sizeof(int));
01111     }
01112 
01113     int Write(detail::JackChannelTransactionInterface* trans)
01114     {
01115         CheckRes(JackRequest::Write(trans, Size()));
01116         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01117         return trans->Write(&fIntRefNum, sizeof(int));
01118     }
01119     
01120     int Size() { return sizeof(int) + sizeof(int); }
01121 };
01122 
01127 struct JackInternalClientUnloadResult : public JackResult
01128 {
01129 
01130     int fStatus;
01131 
01132     JackInternalClientUnloadResult(): JackResult()
01133     {}
01134     JackInternalClientUnloadResult(int32_t result, int status)
01135             : JackResult(result), fStatus(status)
01136     {}
01137 
01138     int Read(detail::JackChannelTransactionInterface* trans)
01139     {
01140         CheckRes(JackResult::Read(trans));
01141         CheckRes(trans->Read(&fStatus, sizeof(int)));
01142         return 0;
01143     }
01144 
01145     int Write(detail::JackChannelTransactionInterface* trans)
01146     {
01147         CheckRes(JackResult::Write(trans));
01148         CheckRes(trans->Write(&fStatus, sizeof(int)));
01149         return 0;
01150     }
01151 
01152     int Size() { return sizeof(int); }
01153 };
01154 
01159 struct JackClientNotificationRequest : public JackRequest
01160 {
01161 
01162     int fRefNum;
01163     int fNotify;
01164     int fValue;
01165 
01166     JackClientNotificationRequest()
01167     {}
01168     JackClientNotificationRequest(int refnum, int notify, int value)
01169             : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
01170     {}
01171 
01172     int Read(detail::JackChannelTransactionInterface* trans)
01173     {
01174         CheckSize();
01175         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01176         CheckRes(trans->Read(&fNotify, sizeof(int)));
01177         CheckRes(trans->Read(&fValue, sizeof(int)));
01178         return 0;
01179     }
01180 
01181     int Write(detail::JackChannelTransactionInterface* trans)
01182     {
01183         CheckRes(JackRequest::Write(trans, Size()));
01184         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01185         CheckRes(trans->Write(&fNotify, sizeof(int)));
01186         CheckRes(trans->Write(&fValue, sizeof(int)));
01187         return 0;
01188     }
01189     
01190     int Size() { return 3 * sizeof(int); }
01191 
01192 };
01193 
01194 struct JackSessionCommand
01195 {
01196     char fUUID[JACK_UUID_SIZE];
01197     char fClientName[JACK_CLIENT_NAME_SIZE + 1];
01198     char fCommand[JACK_SESSION_COMMAND_SIZE];
01199     jack_session_flags_t fFlags;
01200 
01201     JackSessionCommand()
01202     {}
01203 
01204     JackSessionCommand(const char *uuid, const char *clientname, const char *command, jack_session_flags_t flags)
01205     {
01206         strncpy(fUUID, uuid, sizeof(fUUID));
01207         strncpy(fClientName, clientname, sizeof(fClientName));
01208         strncpy(fCommand, command, sizeof(fCommand));
01209         fFlags = flags;
01210     }
01211 };
01212 
01213 struct JackSessionNotifyResult : public JackResult
01214 {
01215 
01216     std::list<JackSessionCommand> fCommandList;
01217     bool fDone;
01218 
01219     JackSessionNotifyResult(): JackResult(), fDone(false)
01220     {}
01221     JackSessionNotifyResult(int32_t result)
01222             : JackResult(result), fDone(false)
01223     {}
01224 
01225     int Read(detail::JackChannelTransactionInterface* trans)
01226     {
01227         if (trans == NULL)
01228         {
01229             return 0;
01230         }
01231 
01232         CheckRes(JackResult::Read(trans));
01233         while (true) {
01234             JackSessionCommand buffer;
01235 
01236             CheckRes(trans->Read(buffer.fUUID, sizeof(buffer.fUUID)));
01237             if (buffer.fUUID[0] == '\0')
01238                 break;
01239 
01240             CheckRes(trans->Read(buffer.fClientName, sizeof(buffer.fClientName)));
01241             CheckRes(trans->Read(buffer.fCommand, sizeof(buffer.fCommand)));
01242             CheckRes(trans->Read(&(buffer.fFlags), sizeof(buffer.fFlags)));
01243 
01244             fCommandList.push_back(buffer);
01245         }
01246 
01247         fDone = true;
01248 
01249         return 0;
01250     }
01251 
01252     int Write(detail::JackChannelTransactionInterface* trans)
01253     {
01254         if (trans == NULL)
01255         {
01256             fDone = true;
01257             return 0;
01258         }
01259 
01260         char terminator[JACK_UUID_SIZE];
01261         terminator[0] = '\0';
01262 
01263         CheckRes(JackResult::Write(trans));
01264         for (std::list<JackSessionCommand>::iterator i = fCommandList.begin(); i != fCommandList.end(); i++) {
01265             CheckRes(trans->Write(i->fUUID, sizeof(i->fUUID)));
01266             CheckRes(trans->Write(i->fClientName, sizeof(i->fClientName)));
01267             CheckRes(trans->Write(i->fCommand, sizeof(i->fCommand)));
01268             CheckRes(trans->Write(&(i->fFlags), sizeof(i->fFlags)));
01269         }
01270         CheckRes(trans->Write(terminator, sizeof(terminator)));
01271         return 0;
01272     }
01273 
01274     jack_session_command_t* GetCommands()
01275     {
01276         /* TODO: some kind of signal should be used instead */
01277         while (!fDone)
01278         {
01279             JackSleep(50000);    /* 50 ms */
01280         }
01281 
01282         jack_session_command_t* session_command = (jack_session_command_t *)malloc(sizeof(jack_session_command_t) * (fCommandList.size() + 1));
01283         int i = 0;
01284 
01285         for (std::list<JackSessionCommand>::iterator ci = fCommandList.begin(); ci != fCommandList.end(); ci++) {
01286             session_command[i].uuid = strdup(ci->fUUID);
01287             session_command[i].client_name = strdup(ci->fClientName);
01288             session_command[i].command = strdup(ci->fCommand);
01289             session_command[i].flags = ci->fFlags;
01290             i += 1;
01291         }
01292 
01293         session_command[i].uuid = NULL;
01294         session_command[i].client_name = NULL;
01295         session_command[i].command = NULL;
01296         session_command[i].flags = (jack_session_flags_t)0;
01297 
01298         return session_command;
01299     }
01300 };
01301 
01306 struct JackSessionNotifyRequest : public JackRequest
01307 {
01308     char fPath[JACK_MESSAGE_SIZE + 1];
01309     char fDst[JACK_CLIENT_NAME_SIZE + 1];
01310     jack_session_event_type_t fEventType;
01311     int fRefNum;
01312 
01313     JackSessionNotifyRequest()
01314     {}
01315     JackSessionNotifyRequest(int refnum, const char* path, jack_session_event_type_t type, const char* dst)
01316             : JackRequest(JackRequest::kSessionNotify), fEventType(type), fRefNum(refnum)
01317     {
01318         snprintf(fPath, sizeof(fPath), "%s", path);
01319         if (dst) {
01320             snprintf(fDst, sizeof(fDst), "%s", dst);
01321         } else {
01322             fDst[0] = '\0';
01323         }
01324     }
01325 
01326     int Read(detail::JackChannelTransactionInterface* trans)
01327     {
01328         CheckSize();
01329         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
01330         CheckRes(trans->Read(&fPath, sizeof(fPath)));
01331         CheckRes(trans->Read(&fDst, sizeof(fDst)));
01332         CheckRes(trans->Read(&fEventType, sizeof(fEventType)));
01333         return 0;
01334     }
01335 
01336     int Write(detail::JackChannelTransactionInterface* trans)
01337     {
01338         CheckRes(JackRequest::Write(trans, Size()));
01339         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
01340         CheckRes(trans->Write(&fPath, sizeof(fPath)));
01341         CheckRes(trans->Write(&fDst, sizeof(fDst)));
01342         CheckRes(trans->Write(&fEventType, sizeof(fEventType)));
01343         return 0;
01344     }
01345 
01346     int Size() { return sizeof(fRefNum) + sizeof(fPath) + sizeof(fDst) + sizeof(fEventType); }
01347 };
01348 
01349 struct JackSessionReplyRequest : public JackRequest
01350 {
01351     int fRefNum;
01352 
01353     JackSessionReplyRequest()
01354     {}
01355 
01356     JackSessionReplyRequest(int refnum)
01357             : JackRequest(JackRequest::kSessionReply), fRefNum(refnum)
01358     {}
01359 
01360     int Read(detail::JackChannelTransactionInterface* trans)
01361     {
01362         CheckSize();
01363         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01364         return 0;
01365     }
01366 
01367     int Write(detail::JackChannelTransactionInterface* trans)
01368     {
01369         CheckRes(JackRequest::Write(trans, Size()));
01370         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01371         return 0;
01372     }
01373 
01374     int Size() { return sizeof(int); }
01375     
01376 };
01377 
01378 struct JackClientNameResult : public JackResult
01379 {
01380     char fName[JACK_CLIENT_NAME_SIZE + 1];
01381 
01382     JackClientNameResult(): JackResult()
01383     {}
01384     JackClientNameResult(int32_t result, const char* name)
01385             : JackResult(result)
01386     {
01387         snprintf(fName, sizeof(fName), "%s", name);
01388     }
01389 
01390     int Read(detail::JackChannelTransactionInterface* trans)
01391     {
01392         CheckRes(JackResult::Read(trans));
01393         CheckRes(trans->Read(&fName, sizeof(fName)));
01394         return 0;
01395     }
01396 
01397     int Write(detail::JackChannelTransactionInterface* trans)
01398     {
01399         CheckRes(JackResult::Write(trans));
01400         CheckRes(trans->Write(&fName, sizeof(fName)));
01401         return 0;
01402     }
01403    
01404 };
01405 
01406 struct JackUUIDResult : public JackResult
01407 {
01408     char fUUID[JACK_UUID_SIZE];
01409 
01410     JackUUIDResult(): JackResult()
01411     {}
01412     JackUUIDResult(int32_t result, const char* uuid)
01413             : JackResult(result)
01414     {
01415         snprintf(fUUID, sizeof(fUUID), "%s", uuid);
01416     }
01417 
01418     int Read(detail::JackChannelTransactionInterface* trans)
01419     {
01420         CheckRes(JackResult::Read(trans));
01421         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
01422         return 0;
01423     }
01424 
01425     int Write(detail::JackChannelTransactionInterface* trans)
01426     {
01427         CheckRes(JackResult::Write(trans));
01428         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
01429         return 0;
01430     }
01431 
01432 };
01433 
01434 struct JackGetUUIDRequest : public JackRequest
01435 {
01436     char fName[JACK_CLIENT_NAME_SIZE + 1];
01437 
01438     JackGetUUIDRequest()
01439     {}
01440 
01441     JackGetUUIDRequest(const char* client_name)
01442             : JackRequest(JackRequest::kGetUUIDByClient)
01443     {
01444         strncpy(fName, client_name, sizeof(fName));
01445     }
01446 
01447     int Read(detail::JackChannelTransactionInterface* trans)
01448     {
01449         CheckSize();
01450         CheckRes(trans->Read(&fName, sizeof(fName)));
01451         return 0;
01452     }
01453 
01454     int Write(detail::JackChannelTransactionInterface* trans)
01455     {
01456         CheckRes(JackRequest::Write(trans, Size()));
01457         CheckRes(trans->Write(&fName, sizeof(fName)));
01458         return 0;
01459     }
01460 
01461     int Size() { return sizeof(fName); }
01462     
01463 };
01464 
01465 struct JackGetClientNameRequest : public JackRequest
01466 {
01467     char fUUID[JACK_UUID_SIZE];
01468 
01469     JackGetClientNameRequest()
01470     {}
01471 
01472     JackGetClientNameRequest(const char* uuid)
01473             : JackRequest(JackRequest::kGetClientByUUID)
01474     {
01475         strncpy(fUUID, uuid, sizeof(fUUID));
01476     }
01477 
01478     int Read(detail::JackChannelTransactionInterface* trans)
01479     {   
01480         CheckSize();
01481         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
01482         return 0;
01483     }
01484 
01485     int Write(detail::JackChannelTransactionInterface* trans)
01486     {
01487         CheckRes(JackRequest::Write(trans, Size()));
01488         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
01489         return 0;
01490     }
01491 
01492     int Size() { return sizeof(fUUID); }
01493     
01494 };
01495 
01496 struct JackReserveNameRequest : public JackRequest
01497 {
01498     int  fRefNum;
01499     char fName[JACK_CLIENT_NAME_SIZE + 1];
01500     char fUUID[JACK_UUID_SIZE];
01501 
01502     JackReserveNameRequest()
01503     {}
01504 
01505     JackReserveNameRequest(int refnum, const char *name, const char* uuid)
01506             : JackRequest(JackRequest::kReserveClientName), fRefNum(refnum)
01507     {
01508         strncpy(fName, name, sizeof(fName));
01509         strncpy(fUUID, uuid, sizeof(fUUID));
01510     }
01511 
01512     int Read(detail::JackChannelTransactionInterface* trans)
01513     {
01514         CheckSize();
01515         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
01516         CheckRes(trans->Read(&fName, sizeof(fName)));
01517         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
01518         return 0;
01519     }
01520 
01521     int Write(detail::JackChannelTransactionInterface* trans)
01522     {
01523         CheckRes(JackRequest::Write(trans, Size()));
01524         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
01525         CheckRes(trans->Write(&fName, sizeof(fName)));
01526         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
01527         return 0;
01528     }
01529 
01530     int Size() { return sizeof(fUUID) + sizeof(fName) + sizeof(fRefNum); }
01531     
01532 };
01533 
01534 struct JackClientHasSessionCallbackRequest : public JackRequest
01535 {
01536     char fName[JACK_CLIENT_NAME_SIZE + 1];
01537 
01538     JackClientHasSessionCallbackRequest()
01539     {}
01540 
01541     JackClientHasSessionCallbackRequest(const char *name)
01542             : JackRequest(JackRequest::kClientHasSessionCallback)
01543     {
01544         strncpy(fName, name, sizeof(fName));
01545     }
01546 
01547     int Read(detail::JackChannelTransactionInterface* trans)
01548     {
01549         CheckSize();
01550         CheckRes(trans->Read(&fName, sizeof(fName)));
01551         return 0;
01552     }
01553 
01554     int Write(detail::JackChannelTransactionInterface* trans)
01555     {
01556         CheckRes(JackRequest::Write(trans, Size()));
01557         CheckRes(trans->Write(&fName, sizeof(fName)));
01558         return 0;
01559     }
01560 
01561     int Size() { return sizeof(fName); }
01562     
01563 };
01564 
01569 struct JackClientNotification
01570 {
01571     int fSize; 
01572     char fName[JACK_CLIENT_NAME_SIZE + 1];
01573     int fRefNum;
01574     int fNotify;
01575     int fValue1;
01576     int fValue2;
01577     int fSync;
01578     char fMessage[JACK_MESSAGE_SIZE + 1];
01579 
01580     JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)
01581     {}
01582     JackClientNotification(const char* name, int refnum, int notify, int sync, const char* message, int value1, int value2)
01583             : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
01584     {
01585         snprintf(fName, sizeof(fName), "%s", name);
01586         snprintf(fMessage, sizeof(fMessage), "%s", message);
01587         fSize = Size();
01588     }
01589 
01590     int Read(detail::JackChannelTransactionInterface* trans)
01591     {
01592         CheckSize();
01593         CheckRes(trans->Read(&fName, sizeof(fName)));
01594         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01595         CheckRes(trans->Read(&fNotify, sizeof(int)));
01596         CheckRes(trans->Read(&fValue1, sizeof(int)));
01597         CheckRes(trans->Read(&fValue2, sizeof(int)));
01598         CheckRes(trans->Read(&fSync, sizeof(int)));
01599         CheckRes(trans->Read(&fMessage, sizeof(fMessage)));
01600         return 0;
01601     }
01602 
01603     int Write(detail::JackChannelTransactionInterface* trans)
01604     {
01605         CheckRes(trans->Write(&fSize, sizeof(int)));
01606         CheckRes(trans->Write(&fName, sizeof(fName)));
01607         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01608         CheckRes(trans->Write(&fNotify, sizeof(int)));
01609         CheckRes(trans->Write(&fValue1, sizeof(int)));
01610         CheckRes(trans->Write(&fValue2, sizeof(int)));
01611         CheckRes(trans->Write(&fSync, sizeof(int)));
01612         CheckRes(trans->Write(&fMessage, sizeof(fMessage)));
01613         return 0;
01614     }
01615     
01616     int Size() { return sizeof(int) + sizeof(fName) + 5 * sizeof(int) + sizeof(fMessage); }
01617 
01618 };
01619 
01620 } // end of namespace
01621 
01622 #endif