Jack2 1.9.7
JackRequest.h
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 "JackPlatformPlug.h"
00026 #include "types.h"
00027 #include <string.h>
00028 #include <stdio.h>
00029 #include <list>
00030 
00031 namespace Jack
00032 {
00033 
00034 #define CheckRes(exp) { if ((exp) < 0) return -1;}
00035 
00040 struct JackRequest
00041 {
00042 
00043     enum RequestType {
00044         kRegisterPort = 1,
00045         kUnRegisterPort = 2,
00046         kConnectPorts = 3,
00047         kDisconnectPorts = 4,
00048         kSetTimeBaseClient = 5,
00049         kActivateClient = 6,
00050         kDeactivateClient = 7,
00051         kDisconnectPort = 8,
00052         kSetClientCapabilities = 9,
00053         kGetPortConnections = 10,
00054         kGetPortNConnections = 11,
00055         kReleaseTimebase = 12,
00056         kSetTimebaseCallback = 13,
00057         kSetBufferSize = 20,
00058         kSetFreeWheel = 21,
00059         kClientCheck = 22,
00060         kClientOpen = 23,
00061         kClientClose = 24,
00062         kConnectNamePorts = 25,
00063         kDisconnectNamePorts = 26,
00064         kGetInternalClientName = 27,
00065         kInternalClientHandle = 28,
00066         kInternalClientLoad = 29,
00067         kInternalClientUnload = 30,
00068         kPortRename = 31,
00069         kNotification = 32,
00070         kSessionNotify = 33,
00071         kSessionReply  = 34,
00072         kGetClientByUUID = 35,
00073         kReserveClientName = 36,
00074         kGetUUIDByClient = 37,
00075         kClientHasSessionCallback = 38,
00076         kComputeTotalLatencies = 39
00077     };
00078 
00079     RequestType fType;
00080 
00081     JackRequest()
00082     {}
00083 
00084     JackRequest(RequestType type): fType(type)
00085     {}
00086 
00087     virtual ~JackRequest()
00088     {}
00089 
00090     virtual int Read(JackChannelTransaction* trans)
00091     {
00092         return trans->Read(&fType, sizeof(RequestType));
00093     }
00094 
00095     virtual int Write(JackChannelTransaction* trans)
00096     {
00097         return trans->Write(&fType, sizeof(RequestType));
00098     }
00099 
00100 };
00101 
00106 struct JackResult
00107 {
00108 
00109     int fResult;
00110 
00111     JackResult(): fResult( -1)
00112     {}
00113     JackResult(int result): fResult(result)
00114     {}
00115     virtual ~JackResult()
00116     {}
00117 
00118     virtual int Read(JackChannelTransaction* trans)
00119     {
00120         return trans->Read(&fResult, sizeof(int));
00121     }
00122 
00123     virtual int Write(JackChannelTransaction* trans)
00124     {
00125         return trans->Write(&fResult, sizeof(int));
00126     }
00127 
00128 };
00129 
00134 struct JackClientCheckRequest : public JackRequest
00135 {
00136 
00137     char fName[JACK_CLIENT_NAME_SIZE + 1];
00138     int fProtocol;
00139     int fOptions;
00140     int fUUID;
00141 
00142     JackClientCheckRequest()
00143     {}
00144     JackClientCheckRequest(const char* name, int protocol, int options, int uuid)
00145         : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options), fUUID(uuid)
00146     {
00147         snprintf(fName, sizeof(fName), "%s", name);
00148     }
00149 
00150     int Read(JackChannelTransaction* trans)
00151     {
00152         CheckRes(trans->Read(&fName, sizeof(fName)));
00153         CheckRes(trans->Read(&fProtocol, sizeof(int)));
00154         CheckRes(trans->Read(&fOptions, sizeof(int)));
00155         return trans->Read(&fUUID, sizeof(int));
00156     }
00157 
00158     int Write(JackChannelTransaction* trans)
00159     {
00160         CheckRes(JackRequest::Write(trans));
00161         CheckRes(trans->Write(&fName,  sizeof(fName)));
00162         CheckRes(trans->Write(&fProtocol, sizeof(int)));
00163         CheckRes(trans->Write(&fOptions, sizeof(int)));
00164         return trans->Write(&fUUID, sizeof(int));
00165     }
00166 
00167 };
00168 
00173 struct JackClientCheckResult : public JackResult
00174 {
00175 
00176     char fName[JACK_CLIENT_NAME_SIZE + 1];
00177     int fStatus;
00178 
00179     JackClientCheckResult(): JackResult(), fStatus(0)
00180     {}
00181     JackClientCheckResult(int32_t result, const char* name, int status)
00182             : JackResult(result), fStatus(status)
00183     {
00184         snprintf(fName, sizeof(fName), "%s", name);
00185     }
00186 
00187     int Read(JackChannelTransaction* trans)
00188     {
00189         CheckRes(JackResult::Read(trans));
00190         CheckRes(trans->Read(&fName, sizeof(fName)));
00191         CheckRes(trans->Read(&fStatus, sizeof(int)));
00192         return 0;
00193     }
00194 
00195     int Write(JackChannelTransaction* trans)
00196     {
00197         CheckRes(JackResult::Write(trans));
00198         CheckRes(trans->Write(&fName, sizeof(fName)));
00199         CheckRes(trans->Write(&fStatus, sizeof(int)));
00200         return 0;
00201     }
00202 
00203 };
00204 
00209 struct JackClientOpenRequest : public JackRequest
00210 {
00211 
00212     int fPID;
00213     int fUUID;
00214     char fName[JACK_CLIENT_NAME_SIZE + 1];
00215 
00216     JackClientOpenRequest()
00217     {}
00218     JackClientOpenRequest(const char* name, int pid, int uuid): JackRequest(JackRequest::kClientOpen)
00219     {
00220         snprintf(fName, sizeof(fName), "%s", name);
00221         fPID = pid;
00222         fUUID = uuid;
00223     }
00224 
00225     int Read(JackChannelTransaction* trans)
00226     {
00227         CheckRes(trans->Read(&fPID, sizeof(int)));
00228         CheckRes(trans->Read(&fUUID, sizeof(int)));
00229         return trans->Read(&fName,  sizeof(fName));
00230     }
00231 
00232     int Write(JackChannelTransaction* trans)
00233     {
00234         CheckRes(JackRequest::Write(trans));
00235         CheckRes(trans->Write(&fPID, sizeof(int)));
00236         CheckRes(trans->Write(&fUUID, sizeof(int)));
00237         return trans->Write(&fName,  sizeof(fName));
00238     }
00239 
00240 };
00241 
00246 struct JackClientOpenResult : public JackResult
00247 {
00248 
00249     int fSharedEngine;
00250     int fSharedClient;
00251     int fSharedGraph;
00252 
00253     JackClientOpenResult()
00254             : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
00255     {}
00256     JackClientOpenResult(int32_t result, int index1, int index2, int index3)
00257             : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
00258     {}
00259 
00260     int Read(JackChannelTransaction* trans)
00261     {
00262         CheckRes(JackResult::Read(trans));
00263         CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
00264         CheckRes(trans->Read(&fSharedClient, sizeof(int)));
00265         CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
00266         return 0;
00267     }
00268 
00269     int Write(JackChannelTransaction* trans)
00270     {
00271         CheckRes(JackResult::Write(trans));
00272         CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
00273         CheckRes(trans->Write(&fSharedClient, sizeof(int)));
00274         CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
00275         return 0;
00276     }
00277 
00278 };
00279 
00284 struct JackClientCloseRequest : public JackRequest
00285 {
00286 
00287     int fRefNum;
00288 
00289     JackClientCloseRequest()
00290     {}
00291     JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
00292     {}
00293 
00294     int Read(JackChannelTransaction* trans)
00295     {
00296         return trans->Read(&fRefNum, sizeof(int));
00297     }
00298 
00299     int Write(JackChannelTransaction* trans)
00300     {
00301         CheckRes(JackRequest::Write(trans));
00302         return trans->Write(&fRefNum, sizeof(int));
00303     }
00304 
00305 };
00306 
00311 struct JackActivateRequest : public JackRequest
00312 {
00313 
00314     int fRefNum;
00315     int fIsRealTime;
00316 
00317     JackActivateRequest()
00318     {}
00319     JackActivateRequest(int refnum, int is_real_time)
00320         : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fIsRealTime(is_real_time)
00321     {}
00322 
00323     int Read(JackChannelTransaction* trans)
00324     {
00325         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00326         return trans->Read(&fIsRealTime, sizeof(int));
00327     }
00328 
00329     int Write(JackChannelTransaction* trans)
00330     {
00331         CheckRes(JackRequest::Write(trans));
00332         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00333         return trans->Write(&fIsRealTime, sizeof(int));
00334     }
00335 
00336 };
00337 
00342 struct JackDeactivateRequest : public JackRequest
00343 {
00344 
00345     int fRefNum;
00346 
00347     JackDeactivateRequest()
00348     {}
00349     JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
00350     {}
00351 
00352     int Read(JackChannelTransaction* trans)
00353     {
00354         return trans->Read(&fRefNum, sizeof(int));
00355     }
00356 
00357     int Write(JackChannelTransaction* trans)
00358     {
00359         CheckRes(JackRequest::Write(trans));
00360         return trans->Write(&fRefNum, sizeof(int));
00361     }
00362 
00363 };
00364 
00369 struct JackPortRegisterRequest : public JackRequest
00370 {
00371 
00372     int fRefNum;
00373     char fName[JACK_PORT_NAME_SIZE + 1];
00374     char fPortType[JACK_PORT_TYPE_SIZE + 1];
00375     unsigned int fFlags;
00376     unsigned int fBufferSize;
00377 
00378     JackPortRegisterRequest()
00379     {}
00380     JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
00381             : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
00382     {
00383         strcpy(fName, name);
00384         strcpy(fPortType, port_type);
00385     }
00386 
00387     int Read(JackChannelTransaction* trans)
00388     {
00389         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00390         CheckRes(trans->Read(&fName, sizeof(fName)));
00391         CheckRes(trans->Read(&fPortType, sizeof(fPortType)));
00392         CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
00393         CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
00394         return 0;
00395     }
00396 
00397     int Write(JackChannelTransaction* trans)
00398     {
00399         CheckRes(JackRequest::Write(trans));
00400         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00401         CheckRes(trans->Write(&fName, sizeof(fName)));
00402         CheckRes(trans->Write(&fPortType, sizeof(fPortType)));
00403         CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
00404         CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
00405         return 0;
00406     }
00407 
00408 };
00409 
00414 struct JackPortRegisterResult : public JackResult
00415 {
00416 
00417     jack_port_id_t fPortIndex;
00418 
00419     JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
00420     {}
00421 
00422     int Read(JackChannelTransaction* trans)
00423     {
00424         CheckRes(JackResult::Read(trans));
00425         return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
00426     }
00427 
00428     int Write(JackChannelTransaction* trans)
00429     {
00430         CheckRes(JackResult::Write(trans));
00431         return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
00432     }
00433 
00434 };
00435 
00440 struct JackPortUnRegisterRequest : public JackRequest
00441 {
00442 
00443     int fRefNum;
00444     jack_port_id_t fPortIndex;
00445 
00446     JackPortUnRegisterRequest()
00447     {}
00448     JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
00449         : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
00450     {}
00451 
00452     int Read(JackChannelTransaction* trans)
00453     {
00454         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00455         CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
00456         return 0;
00457     }
00458 
00459     int Write(JackChannelTransaction* trans)
00460     {
00461         CheckRes(JackRequest::Write(trans));
00462         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00463         CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
00464         return 0;
00465     }
00466 
00467 };
00468 
00473 struct JackPortConnectNameRequest : public JackRequest
00474 {
00475 
00476     int fRefNum;
00477     char fSrc[JACK_PORT_NAME_SIZE + 1];
00478     char fDst[JACK_PORT_NAME_SIZE + 1];
00479 
00480     JackPortConnectNameRequest()
00481     {}
00482     JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00483         : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
00484     {
00485         strcpy(fSrc, src_name);
00486         strcpy(fDst, dst_name);
00487     }
00488 
00489     int Read(JackChannelTransaction* trans)
00490     {
00491         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00492         CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
00493         CheckRes(trans->Read(&fDst, sizeof(fDst)));
00494         return 0;
00495 
00496     }
00497 
00498     int Write(JackChannelTransaction* trans)
00499     {
00500         CheckRes(JackRequest::Write(trans));
00501         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00502         CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
00503         CheckRes(trans->Write(&fDst, sizeof(fDst)));
00504         return 0;
00505     }
00506 
00507 };
00508 
00513 struct JackPortDisconnectNameRequest : public JackRequest
00514 {
00515 
00516     int fRefNum;
00517     char fSrc[JACK_PORT_NAME_SIZE + 1];
00518     char fDst[JACK_PORT_NAME_SIZE + 1];
00519 
00520     JackPortDisconnectNameRequest()
00521     {}
00522     JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00523         : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
00524     {
00525         strcpy(fSrc, src_name);
00526         strcpy(fDst, dst_name);
00527     }
00528 
00529     int Read(JackChannelTransaction* trans)
00530     {
00531         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00532         CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
00533         CheckRes(trans->Read(&fDst, sizeof(fDst)));
00534         return 0;
00535     }
00536 
00537     int Write(JackChannelTransaction* trans)
00538     {
00539         CheckRes(JackRequest::Write(trans));
00540         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00541         CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
00542         CheckRes(trans->Write(&fDst, sizeof(fDst)));
00543         return 0;
00544     }
00545 
00546 };
00547 
00552 struct JackPortConnectRequest : public JackRequest
00553 {
00554 
00555     int fRefNum;
00556     jack_port_id_t fSrc;
00557     jack_port_id_t fDst;
00558 
00559     JackPortConnectRequest()
00560     {}
00561     JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00562         : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00563     {}
00564 
00565     int Read(JackChannelTransaction* trans)
00566     {
00567         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00568         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00569         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00570         return 0;
00571     }
00572 
00573     int Write(JackChannelTransaction* trans)
00574     {
00575         CheckRes(JackRequest::Write(trans));
00576         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00577         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00578         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00579         return 0;
00580     }
00581 
00582 };
00583 
00588 struct JackPortDisconnectRequest : public JackRequest
00589 {
00590 
00591     int fRefNum;
00592     jack_port_id_t fSrc;
00593     jack_port_id_t fDst;
00594 
00595     JackPortDisconnectRequest()
00596     {}
00597     JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00598         : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00599     {}
00600 
00601     int Read(JackChannelTransaction* trans)
00602     {
00603         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00604         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00605         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00606         return 0;
00607     }
00608 
00609     int Write(JackChannelTransaction* trans)
00610     {
00611         CheckRes(JackRequest::Write(trans));
00612         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00613         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00614         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00615         return 0;
00616     }
00617 
00618 };
00619 
00624 struct JackPortRenameRequest : public JackRequest
00625 {
00626 
00627     int fRefNum;
00628     jack_port_id_t fPort;
00629     char fName[JACK_PORT_NAME_SIZE + 1];
00630 
00631     JackPortRenameRequest()
00632     {}
00633     JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
00634         : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
00635     {
00636         strcpy(fName, name);
00637     }
00638 
00639     int Read(JackChannelTransaction* trans)
00640     {
00641         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00642         CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
00643         CheckRes(trans->Read(&fName, sizeof(fName)));
00644         return 0;
00645     }
00646 
00647     int Write(JackChannelTransaction* trans)
00648     {
00649         CheckRes(JackRequest::Write(trans));
00650         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00651         CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
00652         CheckRes(trans->Write(&fName, sizeof(fName)));
00653         return 0;
00654 
00655     }
00656 
00657 };
00658 
00663 struct JackSetBufferSizeRequest : public JackRequest
00664 {
00665 
00666     jack_nframes_t fBufferSize;
00667 
00668     JackSetBufferSizeRequest()
00669     {}
00670     JackSetBufferSizeRequest(jack_nframes_t buffer_size)
00671         : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
00672     {}
00673 
00674     int Read(JackChannelTransaction* trans)
00675     {
00676         return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
00677     }
00678 
00679     int Write(JackChannelTransaction* trans)
00680     {
00681         CheckRes(JackRequest::Write(trans));
00682         return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
00683     }
00684 
00685 };
00686 
00691 struct JackSetFreeWheelRequest : public JackRequest
00692 {
00693 
00694     int fOnOff;
00695 
00696     JackSetFreeWheelRequest()
00697     {}
00698     JackSetFreeWheelRequest(int onoff)
00699         : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
00700     {}
00701 
00702     int Read(JackChannelTransaction* trans)
00703     {
00704         return trans->Read(&fOnOff, sizeof(int));
00705     }
00706 
00707     int Write(JackChannelTransaction* trans)
00708     {
00709         CheckRes(JackRequest::Write(trans));
00710         return trans->Write(&fOnOff, sizeof(int));
00711     }
00712 
00713 };
00714 
00719 struct JackComputeTotalLatenciesRequest : public JackRequest
00720 {
00721 
00722     JackComputeTotalLatenciesRequest()
00723         : JackRequest(JackRequest::kComputeTotalLatencies)
00724     {}
00725 
00726     int Read(JackChannelTransaction* trans)
00727     {
00728         return 0;
00729     }
00730 
00731     int Write(JackChannelTransaction* trans)
00732     {
00733         CheckRes(JackRequest::Write(trans));
00734         return 0;
00735     }
00736 
00737 };
00738 
00743 struct JackReleaseTimebaseRequest : public JackRequest
00744 {
00745 
00746     int fRefNum;
00747 
00748     JackReleaseTimebaseRequest()
00749     {}
00750     JackReleaseTimebaseRequest(int refnum)
00751         : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
00752     {}
00753 
00754     int Read(JackChannelTransaction* trans)
00755     {
00756         return trans->Read(&fRefNum, sizeof(int));
00757     }
00758 
00759     int Write(JackChannelTransaction* trans)
00760     {
00761         CheckRes(JackRequest::Write(trans));
00762         return trans->Write(&fRefNum, sizeof(int));
00763     }
00764 
00765 };
00766 
00771 struct JackSetTimebaseCallbackRequest : public JackRequest
00772 {
00773 
00774     int fRefNum;
00775     int fConditionnal;
00776 
00777     JackSetTimebaseCallbackRequest()
00778     {}
00779     JackSetTimebaseCallbackRequest(int refnum, int conditional)
00780         : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
00781     {}
00782 
00783     int Read(JackChannelTransaction* trans)
00784     {
00785         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00786         return trans->Read(&fConditionnal, sizeof(int));
00787     }
00788 
00789     int Write(JackChannelTransaction* trans)
00790     {
00791         CheckRes(JackRequest::Write(trans));
00792         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00793         return trans->Write(&fConditionnal, sizeof(int));
00794     }
00795 
00796 };
00797 
00802 struct JackGetInternalClientNameRequest : public JackRequest
00803 {
00804 
00805     int fRefNum;
00806     int fIntRefNum;
00807 
00808     JackGetInternalClientNameRequest()
00809     {}
00810     JackGetInternalClientNameRequest(int refnum, int int_ref)
00811             : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
00812     {}
00813 
00814     int Read(JackChannelTransaction* trans)
00815     {
00816         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00817         return trans->Read(&fIntRefNum, sizeof(int));
00818     }
00819 
00820     int Write(JackChannelTransaction* trans)
00821     {
00822         CheckRes(JackRequest::Write(trans));
00823         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00824         return trans->Write(&fIntRefNum, sizeof(int));
00825     }
00826 
00827 };
00828 
00833 struct JackGetInternalClientNameResult : public JackResult
00834 {
00835 
00836     char fName[JACK_CLIENT_NAME_SIZE + 1];
00837 
00838     JackGetInternalClientNameResult(): JackResult()
00839     {}
00840     JackGetInternalClientNameResult(int32_t result, const char* name)
00841             : JackResult(result)
00842     {
00843         snprintf(fName, sizeof(fName), "%s", name);
00844     }
00845 
00846     int Read(JackChannelTransaction* trans)
00847     {
00848         CheckRes(JackResult::Read(trans));
00849         CheckRes(trans->Read(&fName,  sizeof(fName)));
00850         return 0;
00851     }
00852 
00853     int Write(JackChannelTransaction* trans)
00854     {
00855         CheckRes(JackResult::Write(trans));
00856         CheckRes(trans->Write(&fName,  sizeof(fName)));
00857         return 0;
00858     }
00859 
00860 };
00861 
00866 struct JackInternalClientHandleRequest : public JackRequest
00867 {
00868 
00869     int fRefNum;
00870     char fName[JACK_CLIENT_NAME_SIZE + 1];
00871 
00872     JackInternalClientHandleRequest()
00873     {}
00874     JackInternalClientHandleRequest(int refnum, const char* client_name)
00875             : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
00876     {
00877         snprintf(fName, sizeof(fName), "%s", client_name);
00878     }
00879 
00880     int Read(JackChannelTransaction* trans)
00881     {
00882         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00883         return trans->Read(&fName,  sizeof(fName));
00884     }
00885 
00886     int Write(JackChannelTransaction* trans)
00887     {
00888         CheckRes(JackRequest::Write(trans));
00889         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00890         return trans->Write(&fName,  sizeof(fName));
00891     }
00892 
00893 };
00894 
00899 struct JackInternalClientHandleResult : public JackResult
00900 {
00901 
00902     int fStatus;
00903     int fIntRefNum;
00904 
00905     JackInternalClientHandleResult(): JackResult()
00906     {}
00907     JackInternalClientHandleResult(int32_t result, int status, int int_ref)
00908             : JackResult(result), fStatus(status), fIntRefNum(int_ref)
00909     {}
00910 
00911     int Read(JackChannelTransaction* trans)
00912     {
00913         CheckRes(JackResult::Read(trans));
00914         CheckRes(trans->Read(&fStatus, sizeof(int)));
00915         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00916         return 0;
00917     }
00918 
00919     int Write(JackChannelTransaction* trans)
00920     {
00921         CheckRes(JackResult::Write(trans));
00922         CheckRes(trans->Write(&fStatus, sizeof(int)));
00923         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00924         return 0;
00925     }
00926 
00927 };
00928 
00933 struct JackInternalClientLoadRequest : public JackRequest
00934 {
00935 
00936 #ifndef MAX_PATH
00937 #define MAX_PATH 256
00938 #endif
00939 
00940     int fRefNum;
00941     char fName[JACK_CLIENT_NAME_SIZE + 1];
00942     char fDllName[MAX_PATH + 1];
00943     char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
00944     int fOptions;
00945     int fUUID;
00946 
00947     JackInternalClientLoadRequest()
00948     {}
00949     JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int uuid )
00950             : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options), fUUID(uuid)
00951     {
00952         snprintf(fName, sizeof(fName), "%s", client_name);
00953         snprintf(fDllName, sizeof(fDllName), "%s", so_name);
00954         snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
00955         snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
00956     }
00957 
00958     int Read(JackChannelTransaction* trans)
00959     {
00960         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00961         CheckRes(trans->Read(&fName,  sizeof(fName)));
00962         CheckRes(trans->Read(&fDllName, sizeof(fDllName)));
00963         CheckRes(trans->Read(&fLoadInitName, sizeof(fLoadInitName)));
00964         CheckRes(trans->Read(&fUUID, sizeof(int)));
00965         return trans->Read(&fOptions, sizeof(int));
00966     }
00967 
00968     int Write(JackChannelTransaction* trans)
00969     {
00970         CheckRes(JackRequest::Write(trans));
00971         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00972         CheckRes(trans->Write(&fName,  sizeof(fName)));
00973         CheckRes(trans->Write(&fDllName, sizeof(fDllName)));
00974         CheckRes(trans->Write(&fLoadInitName, sizeof(fLoadInitName)));
00975         CheckRes(trans->Write(&fUUID, sizeof(int)));
00976         return trans->Write(&fOptions, sizeof(int));
00977     }
00978 
00979 };
00980 
00985 struct JackInternalClientLoadResult : public JackResult
00986 {
00987 
00988     int fStatus;
00989     int fIntRefNum;
00990 
00991     JackInternalClientLoadResult(): JackResult()
00992     {}
00993     JackInternalClientLoadResult(int32_t result, int status, int int_ref)
00994             : JackResult(result), fStatus(status), fIntRefNum(int_ref)
00995     {}
00996 
00997     int Read(JackChannelTransaction* trans)
00998     {
00999         CheckRes(JackResult::Read(trans));
01000         CheckRes(trans->Read(&fStatus, sizeof(int)));
01001         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
01002         return 0;
01003     }
01004 
01005     int Write(JackChannelTransaction* trans)
01006     {
01007         CheckRes(JackResult::Write(trans));
01008         CheckRes(trans->Write(&fStatus, sizeof(int)));
01009         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
01010         return 0;
01011     }
01012 
01013 };
01014 
01019 struct JackInternalClientUnloadRequest : public JackRequest
01020 {
01021 
01022     int fRefNum;
01023     int fIntRefNum;
01024 
01025     JackInternalClientUnloadRequest()
01026     {}
01027     JackInternalClientUnloadRequest(int refnum, int int_ref)
01028             : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
01029     {}
01030 
01031     int Read(JackChannelTransaction* trans)
01032     {
01033         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01034         return trans->Read(&fIntRefNum, sizeof(int));
01035     }
01036 
01037     int Write(JackChannelTransaction* trans)
01038     {
01039         CheckRes(JackRequest::Write(trans));
01040         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01041         return trans->Write(&fIntRefNum, sizeof(int));
01042     }
01043 };
01044 
01049 struct JackInternalClientUnloadResult : public JackResult
01050 {
01051 
01052     int fStatus;
01053 
01054     JackInternalClientUnloadResult(): JackResult()
01055     {}
01056     JackInternalClientUnloadResult(int32_t result, int status)
01057             : JackResult(result), fStatus(status)
01058     {}
01059 
01060     int Read(JackChannelTransaction* trans)
01061     {
01062         CheckRes(JackResult::Read(trans));
01063         CheckRes(trans->Read(&fStatus, sizeof(int)));
01064         return 0;
01065     }
01066 
01067     int Write(JackChannelTransaction* trans)
01068     {
01069         CheckRes(JackResult::Write(trans));
01070         CheckRes(trans->Write(&fStatus, sizeof(int)));
01071         return 0;
01072     }
01073 
01074 };
01075 
01080 struct JackClientNotificationRequest : public JackRequest
01081 {
01082 
01083     int fRefNum;
01084     int fNotify;
01085     int fValue;
01086 
01087     JackClientNotificationRequest()
01088     {}
01089     JackClientNotificationRequest(int refnum, int notify, int value)
01090             : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
01091     {}
01092 
01093     int Read(JackChannelTransaction* trans)
01094     {
01095         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01096         CheckRes(trans->Read(&fNotify, sizeof(int)));
01097         CheckRes(trans->Read(&fValue, sizeof(int)));
01098         return 0;
01099     }
01100 
01101     int Write(JackChannelTransaction* trans)
01102     {
01103         CheckRes(JackRequest::Write(trans));
01104         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01105         CheckRes(trans->Write(&fNotify, sizeof(int)));
01106         CheckRes(trans->Write(&fValue, sizeof(int)));
01107         return 0;
01108     }
01109 
01110 };
01111 
01112 struct JackSessionCommand
01113 {
01114     char fUUID[JACK_UUID_SIZE];
01115     char fClientName[JACK_CLIENT_NAME_SIZE+1];
01116     char fCommand[JACK_SESSION_COMMAND_SIZE];
01117     jack_session_flags_t fFlags;
01118 
01119     JackSessionCommand()
01120     {}
01121 
01122     JackSessionCommand( const char *uuid, const char *clientname, const char *command, jack_session_flags_t flags )
01123     {
01124         strncpy( fUUID, uuid, sizeof(fUUID));
01125         strncpy( fClientName, clientname, sizeof(fClientName));
01126         strncpy( fCommand, command, sizeof(fCommand));
01127         fFlags = flags;
01128     }
01129 };
01130 
01131 struct JackSessionNotifyResult : public JackResult
01132 {
01133 
01134     std::list<JackSessionCommand> fCommandList;
01135 
01136     JackSessionNotifyResult(): JackResult()
01137     {}
01138     JackSessionNotifyResult(int32_t result)
01139             : JackResult(result)
01140     {}
01141 
01142     int Read(JackChannelTransaction* trans)
01143     {
01144         CheckRes(JackResult::Read(trans));
01145         while(1) {
01146             JackSessionCommand buffer;
01147 
01148             CheckRes(trans->Read(buffer.fUUID, sizeof(buffer.fUUID)));
01149             if (buffer.fUUID[0] == '\0')
01150                 break;
01151 
01152             CheckRes(trans->Read(buffer.fClientName, sizeof(buffer.fClientName)));
01153             CheckRes(trans->Read(buffer.fCommand, sizeof(buffer.fCommand)));
01154             CheckRes(trans->Read(&(buffer.fFlags), sizeof(buffer.fFlags)));
01155 
01156             fCommandList.push_back(buffer);
01157         }
01158         return 0;
01159     }
01160 
01161     int Write(JackChannelTransaction* trans)
01162     {
01163         char terminator[JACK_UUID_SIZE];
01164         terminator[0] = '\0';
01165 
01166         CheckRes(JackResult::Write(trans));
01167         for (std::list<JackSessionCommand>::iterator i=fCommandList.begin(); i!=fCommandList.end(); i++) {
01168             CheckRes(trans->Write(i->fUUID, sizeof(i->fUUID)));
01169             CheckRes(trans->Write(i->fClientName, sizeof(i->fClientName)));
01170             CheckRes(trans->Write(i->fCommand, sizeof(i->fCommand)));
01171             CheckRes(trans->Write(&(i->fFlags), sizeof(i->fFlags)));
01172         }
01173         CheckRes(trans->Write(terminator, sizeof(terminator)));
01174         return 0;
01175     }
01176 
01177 };
01178 
01183 struct JackSessionNotifyRequest : public JackRequest
01184 {
01185     char fPath[JACK_MESSAGE_SIZE + 1];
01186     char fDst[JACK_CLIENT_NAME_SIZE + 1];
01187     jack_session_event_type_t  fEventType;
01188     int  fRefNum;
01189 
01190     JackSessionNotifyRequest()
01191     {}
01192     JackSessionNotifyRequest(int refnum, const char *path, jack_session_event_type_t type, const char *dst)
01193             : JackRequest(JackRequest::kSessionNotify), fEventType(type), fRefNum(refnum)
01194     {
01195         snprintf(fPath, sizeof(fPath), "%s", path);
01196         if (dst)
01197             snprintf(fDst, sizeof(fDst), "%s", dst);
01198         else
01199             fDst[0] = '\0';
01200     }
01201 
01202     int Read(JackChannelTransaction* trans)
01203     {
01204         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
01205         CheckRes(trans->Read(&fPath, sizeof(fPath)));
01206         CheckRes(trans->Read(&fDst, sizeof(fDst)));
01207         CheckRes(trans->Read(&fEventType, sizeof(fEventType)));
01208         return 0;
01209     }
01210 
01211     int Write(JackChannelTransaction* trans)
01212     {
01213         CheckRes(JackRequest::Write(trans));
01214         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
01215         CheckRes(trans->Write(&fPath, sizeof(fPath)));
01216         CheckRes(trans->Write(&fDst, sizeof(fDst)));
01217         CheckRes(trans->Write(&fEventType, sizeof(fEventType)));
01218         return 0;
01219     }
01220 
01221 };
01222 
01223 struct JackSessionReplyRequest : public JackRequest
01224 {
01225     int fRefNum;
01226 
01227     JackSessionReplyRequest()
01228     {}
01229 
01230     JackSessionReplyRequest(int refnum)
01231             : JackRequest(JackRequest::kSessionReply), fRefNum(refnum)
01232     {}
01233 
01234     int Read(JackChannelTransaction* trans)
01235     {
01236         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
01237         return 0;
01238     }
01239 
01240     int Write(JackChannelTransaction* trans)
01241     {
01242         CheckRes(JackRequest::Write(trans));
01243         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
01244         return 0;
01245     }
01246 
01247 };
01248 
01249 struct JackClientNameResult : public JackResult
01250 {
01251     char fName[JACK_CLIENT_NAME_SIZE + 1];
01252 
01253     JackClientNameResult(): JackResult()
01254     {}
01255     JackClientNameResult(int32_t result, const char* name)
01256             : JackResult(result)
01257     {
01258         snprintf(fName, sizeof(fName), "%s", name);
01259     }
01260 
01261     int Read(JackChannelTransaction* trans)
01262     {
01263         CheckRes(JackResult::Read(trans));
01264         CheckRes(trans->Read(&fName, sizeof(fName)));
01265         return 0;
01266     }
01267 
01268     int Write(JackChannelTransaction* trans)
01269     {
01270         CheckRes(JackResult::Write(trans));
01271         CheckRes(trans->Write(&fName, sizeof(fName)));
01272         return 0;
01273     }
01274 
01275 };
01276 
01277 struct JackUUIDResult : public JackResult
01278 {
01279 
01280     char fUUID[JACK_UUID_SIZE];
01281 
01282     JackUUIDResult(): JackResult()
01283     {}
01284     JackUUIDResult(int32_t result, const char* uuid)
01285             : JackResult(result)
01286     {
01287         snprintf(fUUID, sizeof(fUUID), "%s", uuid);
01288     }
01289 
01290     int Read(JackChannelTransaction* trans)
01291     {
01292         CheckRes(JackResult::Read(trans));
01293         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
01294         return 0;
01295     }
01296 
01297     int Write(JackChannelTransaction* trans)
01298     {
01299         CheckRes(JackResult::Write(trans));
01300         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
01301         return 0;
01302     }
01303 
01304 };
01305 
01306 struct JackGetUUIDRequest : public JackRequest
01307 {
01308     char fName[JACK_CLIENT_NAME_SIZE + 1];
01309 
01310     JackGetUUIDRequest()
01311     {}
01312 
01313     JackGetUUIDRequest(const char* client_name)
01314             : JackRequest(JackRequest::kGetUUIDByClient)
01315     {
01316         strncpy(fName, client_name, sizeof(fName));
01317     }
01318 
01319     int Read(JackChannelTransaction* trans)
01320     {
01321         CheckRes(trans->Read(&fName, sizeof(fName)));
01322         return 0;
01323     }
01324 
01325     int Write(JackChannelTransaction* trans)
01326     {
01327         CheckRes(JackRequest::Write(trans));
01328         CheckRes(trans->Write(&fName, sizeof(fName)));
01329         return 0;
01330     }
01331 
01332 };
01333 
01334 struct JackGetClientNameRequest : public JackRequest
01335 {
01336     char fUUID[JACK_UUID_SIZE];
01337 
01338     JackGetClientNameRequest()
01339     {}
01340 
01341     JackGetClientNameRequest(const char* uuid)
01342             : JackRequest(JackRequest::kGetClientByUUID)
01343     {
01344         strncpy(fUUID, uuid, sizeof(fUUID));
01345     }
01346 
01347     int Read(JackChannelTransaction* trans)
01348     {
01349         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
01350         return 0;
01351     }
01352 
01353     int Write(JackChannelTransaction* trans)
01354     {
01355         CheckRes(JackRequest::Write(trans));
01356         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
01357         return 0;
01358     }
01359 
01360 };
01361 
01362 struct JackReserveNameRequest : public JackRequest
01363 {
01364     int  fRefNum;
01365     char fName[JACK_CLIENT_NAME_SIZE + 1];
01366     char fUUID[JACK_UUID_SIZE];
01367 
01368     JackReserveNameRequest()
01369     {}
01370 
01371     JackReserveNameRequest(int refnum, const char *name, const char* uuid)
01372             : JackRequest(JackRequest::kReserveClientName), fRefNum(refnum)
01373     {
01374         strncpy(fName, name, sizeof(fName));
01375         strncpy(fUUID, uuid, sizeof(fUUID));
01376     }
01377 
01378     int Read(JackChannelTransaction* trans)
01379     {
01380         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
01381         CheckRes(trans->Read(&fName, sizeof(fName)));
01382         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
01383         return 0;
01384     }
01385 
01386     int Write(JackChannelTransaction* trans)
01387     {
01388         CheckRes(JackRequest::Write(trans));
01389         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
01390         CheckRes(trans->Write(&fName, sizeof(fName)));
01391         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
01392         return 0;
01393     }
01394 
01395 };
01396 
01397 struct JackClientHasSessionCallbackRequest : public JackRequest
01398 {
01399     char fName[JACK_CLIENT_NAME_SIZE + 1];
01400 
01401     JackClientHasSessionCallbackRequest()
01402     {}
01403 
01404     JackClientHasSessionCallbackRequest(const char *name)
01405             : JackRequest(JackRequest::kClientHasSessionCallback)
01406     {
01407         strncpy(fName, name, sizeof(fName));
01408     }
01409 
01410     int Read(JackChannelTransaction* trans)
01411     {
01412         CheckRes(trans->Read(&fName, sizeof(fName)));
01413         return 0;
01414     }
01415 
01416     int Write(JackChannelTransaction* trans)
01417     {
01418         CheckRes(JackRequest::Write(trans));
01419         CheckRes(trans->Write(&fName, sizeof(fName)));
01420         return 0;
01421     }
01422 
01423 };
01424 
01429 struct JackClientNotification
01430 {
01431     char fName[JACK_CLIENT_NAME_SIZE + 1];
01432     int fRefNum;
01433     int fNotify;
01434     int fValue1;
01435     int fValue2;
01436     int fSync;
01437     char fMessage[JACK_MESSAGE_SIZE + 1];
01438 
01439     JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)
01440     {}
01441     JackClientNotification(const char* name, int refnum, int notify, int sync, const char* message, int value1, int value2)
01442             : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
01443     {
01444         snprintf(fName, sizeof(fName), "%s", name);
01445         snprintf(fMessage, sizeof(fMessage), "%s", message);
01446     }
01447 
01448     int Read(JackChannelTransaction* trans)
01449     {
01450         CheckRes(trans->Read(&fName, sizeof(fName)));
01451         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01452         CheckRes(trans->Read(&fNotify, sizeof(int)));
01453         CheckRes(trans->Read(&fValue1, sizeof(int)));
01454         CheckRes(trans->Read(&fValue2, sizeof(int)));
01455         CheckRes(trans->Read(&fSync, sizeof(int)));
01456         CheckRes(trans->Read(&fMessage, sizeof(fName)));
01457         return 0;
01458     }
01459 
01460     int Write(JackChannelTransaction* trans)
01461     {
01462         CheckRes(trans->Write(&fName, sizeof(fName)));
01463         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01464         CheckRes(trans->Write(&fNotify, sizeof(int)));
01465         CheckRes(trans->Write(&fValue1, sizeof(int)));
01466         CheckRes(trans->Write(&fValue2, sizeof(int)));
01467         CheckRes(trans->Write(&fSync, sizeof(int)));
01468         CheckRes(trans->Write(&fMessage, sizeof(fName)));
01469         return 0;
01470     }
01471 
01472 };
01473 
01474 } // end of namespace
01475 
01476 #endif