Jack2 1.9.6

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 
00030 namespace Jack
00031 {
00032 
00033 #define CheckRes(exp) { if ((exp) < 0) return -1;}
00034 
00039 struct JackRequest
00040 {
00041 
00042     enum RequestType {
00043         kRegisterPort = 1,
00044         kUnRegisterPort = 2,
00045         kConnectPorts = 3,
00046         kDisconnectPorts = 4,
00047         kSetTimeBaseClient = 5,
00048         kActivateClient = 6,
00049         kDeactivateClient = 7,
00050         kDisconnectPort = 8,
00051         kSetClientCapabilities = 9,
00052         kGetPortConnections = 10,
00053         kGetPortNConnections = 11,
00054         kReleaseTimebase = 12,
00055         kSetTimebaseCallback = 13,
00056         kSetBufferSize = 20,
00057         kSetFreeWheel = 21,
00058         kClientCheck = 22,
00059         kClientOpen = 23,
00060         kClientClose = 24,
00061         kConnectNamePorts = 25,
00062         kDisconnectNamePorts = 26,
00063         kGetInternalClientName = 27,
00064         kInternalClientHandle = 28,
00065         kInternalClientLoad = 29,
00066         kInternalClientUnload = 30,
00067         kPortRename = 31,
00068         kNotification = 32
00069     };
00070 
00071     RequestType fType;
00072 
00073     JackRequest()
00074     {}
00075 
00076     JackRequest(RequestType type): fType(type)
00077     {}
00078 
00079     virtual ~JackRequest()
00080     {}
00081 
00082     virtual int Read(JackChannelTransaction* trans)
00083     {
00084         return trans->Read(&fType, sizeof(RequestType));
00085     }
00086 
00087     virtual int Write(JackChannelTransaction* trans)
00088     {
00089         return trans->Write(&fType, sizeof(RequestType));
00090     }
00091 
00092 };
00093 
00098 struct JackResult
00099 {
00100 
00101     int fResult;
00102 
00103     JackResult(): fResult( -1)
00104     {}
00105     JackResult(int result): fResult(result)
00106     {}
00107     virtual ~JackResult()
00108     {}
00109 
00110     virtual int Read(JackChannelTransaction* trans)
00111     {
00112         return trans->Read(&fResult, sizeof(int));
00113     }
00114 
00115     virtual int Write(JackChannelTransaction* trans)
00116     {
00117         return trans->Write(&fResult, sizeof(int));
00118     }
00119     
00120 };
00121 
00126 struct JackClientCheckRequest : public JackRequest
00127 {
00128 
00129     char fName[JACK_CLIENT_NAME_SIZE + 1];
00130     int fProtocol;
00131     int fOptions;
00132 
00133     JackClientCheckRequest()
00134     {}
00135     JackClientCheckRequest(const char* name, int protocol, int options)
00136         : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options)
00137     {
00138         snprintf(fName, sizeof(fName), "%s", name);
00139     }
00140 
00141     int Read(JackChannelTransaction* trans)
00142     {
00143         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00144         CheckRes(trans->Read(&fProtocol, sizeof(int)));
00145         return trans->Read(&fOptions, sizeof(int));
00146     }
00147 
00148     int Write(JackChannelTransaction* trans)
00149     {
00150         CheckRes(JackRequest::Write(trans));
00151         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00152         CheckRes(trans->Write(&fProtocol, sizeof(int)));
00153         return trans->Write(&fOptions, sizeof(int));
00154     }
00155     
00156 } POST_PACKED_STRUCTURE;
00157 
00162 struct JackClientCheckResult : public JackResult
00163 {
00164 
00165     char fName[JACK_CLIENT_NAME_SIZE + 1];
00166     int fStatus;
00167 
00168     JackClientCheckResult(): JackResult(), fStatus(0)
00169     {}
00170     JackClientCheckResult(int32_t result, const char* name, int status)
00171             : JackResult(result), fStatus(status)
00172     {
00173         snprintf(fName, sizeof(fName), "%s", name);
00174     }
00175 
00176     int Read(JackChannelTransaction* trans)
00177     {
00178         CheckRes(JackResult::Read(trans));
00179         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00180         CheckRes(trans->Read(&fStatus, sizeof(int)));
00181         return 0;
00182     }
00183 
00184     int Write(JackChannelTransaction* trans)
00185     {
00186         CheckRes(JackResult::Write(trans));
00187         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00188         CheckRes(trans->Write(&fStatus, sizeof(int)));
00189         return 0;
00190     }
00191     
00192 } POST_PACKED_STRUCTURE;
00193 
00198 struct JackClientOpenRequest : public JackRequest
00199 {
00200 
00201     int fPID;
00202     char fName[JACK_CLIENT_NAME_SIZE + 1];
00203 
00204     JackClientOpenRequest()
00205     {}
00206     JackClientOpenRequest(const char* name, int pid): JackRequest(JackRequest::kClientOpen)
00207     {
00208         snprintf(fName, sizeof(fName), "%s", name);
00209         fPID = pid;
00210     }
00211 
00212     int Read(JackChannelTransaction* trans)
00213     {
00214         CheckRes(trans->Read(&fPID, sizeof(int)));
00215         return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
00216     }
00217 
00218     int Write(JackChannelTransaction* trans)
00219     {
00220         CheckRes(JackRequest::Write(trans));
00221         CheckRes(trans->Write(&fPID, sizeof(int)));
00222         return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
00223     }
00224     
00225 } POST_PACKED_STRUCTURE;
00226 
00231 struct JackClientOpenResult : public JackResult
00232 {
00233 
00234     int fSharedEngine;
00235     int fSharedClient;
00236     int fSharedGraph;
00237    
00238     JackClientOpenResult()
00239             : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
00240     {}
00241     JackClientOpenResult(int32_t result, int index1, int index2, int index3)
00242             : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
00243     {}
00244 
00245     int Read(JackChannelTransaction* trans)
00246     {
00247         CheckRes(JackResult::Read(trans));
00248         CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
00249         CheckRes(trans->Read(&fSharedClient, sizeof(int)));
00250         CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
00251         return 0;
00252     }
00253 
00254     int Write(JackChannelTransaction* trans)
00255     {
00256         CheckRes(JackResult::Write(trans));
00257         CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
00258         CheckRes(trans->Write(&fSharedClient, sizeof(int)));
00259         CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
00260         return 0;
00261     }
00262     
00263 } POST_PACKED_STRUCTURE;
00264 
00269 struct JackClientCloseRequest : public JackRequest
00270 {
00271 
00272     int fRefNum;
00273 
00274     JackClientCloseRequest()
00275     {}
00276     JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
00277     {}
00278 
00279     int Read(JackChannelTransaction* trans)
00280     {
00281         return trans->Read(&fRefNum, sizeof(int));
00282     }
00283 
00284     int Write(JackChannelTransaction* trans)
00285     {
00286         CheckRes(JackRequest::Write(trans));
00287         return trans->Write(&fRefNum, sizeof(int));
00288     }
00289     
00290 } POST_PACKED_STRUCTURE;
00291 
00296 struct JackActivateRequest : public JackRequest
00297 {
00298 
00299     int fRefNum;
00300     int fIsRealTime;
00301 
00302     JackActivateRequest()
00303     {}
00304     JackActivateRequest(int refnum, int is_real_time)
00305         : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fIsRealTime(is_real_time)
00306     {}
00307 
00308     int Read(JackChannelTransaction* trans)
00309     {
00310         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00311         return trans->Read(&fIsRealTime, sizeof(int));
00312     }
00313 
00314     int Write(JackChannelTransaction* trans)
00315     {
00316         CheckRes(JackRequest::Write(trans));
00317         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00318         return trans->Write(&fIsRealTime, sizeof(int));
00319     }
00320 
00321 } POST_PACKED_STRUCTURE;
00322 
00327 struct JackDeactivateRequest : public JackRequest
00328 {
00329 
00330     int fRefNum;
00331 
00332     JackDeactivateRequest()
00333     {}
00334     JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
00335     {}
00336 
00337     int Read(JackChannelTransaction* trans)
00338     {
00339         return trans->Read(&fRefNum, sizeof(int));
00340     }
00341 
00342     int Write(JackChannelTransaction* trans)
00343     {
00344         CheckRes(JackRequest::Write(trans));
00345         return trans->Write(&fRefNum, sizeof(int));
00346     }
00347 
00348 } POST_PACKED_STRUCTURE;
00349 
00354 struct JackPortRegisterRequest : public JackRequest
00355 {
00356 
00357     int fRefNum;
00358     char fName[JACK_PORT_NAME_SIZE + 1];
00359     char fPortType[JACK_PORT_TYPE_SIZE + 1];
00360     unsigned int fFlags;
00361     unsigned int fBufferSize;
00362 
00363     JackPortRegisterRequest()
00364     {}
00365     JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
00366             : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
00367     {
00368         strcpy(fName, name);
00369         strcpy(fPortType, port_type);
00370     }
00371 
00372     int Read(JackChannelTransaction* trans)
00373     {
00374         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00375         CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
00376         CheckRes(trans->Read(&fPortType, JACK_PORT_TYPE_SIZE + 1));
00377         CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
00378         CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
00379         return 0;
00380     }
00381 
00382     int Write(JackChannelTransaction* trans)
00383     {
00384         CheckRes(JackRequest::Write(trans));
00385         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00386         CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
00387         CheckRes(trans->Write(&fPortType, JACK_PORT_TYPE_SIZE + 1));
00388         CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
00389         CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
00390         return 0;
00391     }
00392     
00393 } POST_PACKED_STRUCTURE;
00394 
00399 struct JackPortRegisterResult : public JackResult
00400 {
00401 
00402     jack_port_id_t fPortIndex;
00403 
00404     JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
00405     {}
00406 
00407     int Read(JackChannelTransaction* trans)
00408     {
00409         CheckRes(JackResult::Read(trans));
00410         return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
00411     }
00412 
00413     int Write(JackChannelTransaction* trans)
00414     {
00415         CheckRes(JackResult::Write(trans));
00416         return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
00417     }
00418     
00419 } POST_PACKED_STRUCTURE;
00420 
00425 struct JackPortUnRegisterRequest : public JackRequest
00426 {
00427 
00428     int fRefNum;
00429     jack_port_id_t fPortIndex;
00430 
00431     JackPortUnRegisterRequest()
00432     {}
00433     JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
00434         : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
00435     {}
00436 
00437     int Read(JackChannelTransaction* trans)
00438     {
00439         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00440         CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
00441         return 0;
00442     }
00443 
00444     int Write(JackChannelTransaction* trans)
00445     {
00446         CheckRes(JackRequest::Write(trans));
00447         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00448         CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
00449         return 0;
00450     }
00451     
00452 } POST_PACKED_STRUCTURE;
00453 
00458 struct JackPortConnectNameRequest : public JackRequest
00459 {
00460 
00461     int fRefNum;
00462     char fSrc[JACK_PORT_NAME_SIZE + 1];
00463     char fDst[JACK_PORT_NAME_SIZE + 1];
00464 
00465     JackPortConnectNameRequest()
00466     {}
00467     JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00468         : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
00469     {
00470         strcpy(fSrc, src_name);
00471         strcpy(fDst, dst_name);
00472     }
00473 
00474     int Read(JackChannelTransaction* trans)
00475     {
00476         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00477         CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
00478         CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
00479         return 0;
00480 
00481     }
00482 
00483     int Write(JackChannelTransaction* trans)
00484     {
00485         CheckRes(JackRequest::Write(trans));
00486         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00487         CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
00488         CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
00489         return 0;
00490     }
00491     
00492 } POST_PACKED_STRUCTURE;
00493 
00498 struct JackPortDisconnectNameRequest : public JackRequest
00499 {
00500 
00501     int fRefNum;
00502     char fSrc[JACK_PORT_NAME_SIZE + 1];
00503     char fDst[JACK_PORT_NAME_SIZE + 1];
00504 
00505     JackPortDisconnectNameRequest()
00506     {}
00507     JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00508         : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
00509     {
00510         strcpy(fSrc, src_name);
00511         strcpy(fDst, dst_name);
00512     }
00513 
00514     int Read(JackChannelTransaction* trans)
00515     {
00516         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00517         CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
00518         CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
00519         return 0;
00520     }
00521 
00522     int Write(JackChannelTransaction* trans)
00523     {
00524         CheckRes(JackRequest::Write(trans));
00525         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00526         CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
00527         CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
00528         return 0;
00529     }
00530     
00531 } POST_PACKED_STRUCTURE;
00532 
00537 struct JackPortConnectRequest : public JackRequest
00538 {
00539 
00540     int fRefNum;
00541     jack_port_id_t fSrc;
00542     jack_port_id_t fDst;
00543 
00544     JackPortConnectRequest()
00545     {}
00546     JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00547         : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00548     {}
00549 
00550     int Read(JackChannelTransaction* trans)
00551     {
00552         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00553         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00554         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00555         return 0;
00556     }
00557 
00558     int Write(JackChannelTransaction* trans)
00559     {
00560         CheckRes(JackRequest::Write(trans));
00561         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00562         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00563         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00564         return 0;
00565     }
00566     
00567 } POST_PACKED_STRUCTURE;
00568 
00573 struct JackPortDisconnectRequest : public JackRequest
00574 {
00575 
00576     int fRefNum;
00577     jack_port_id_t fSrc;
00578     jack_port_id_t fDst;
00579 
00580     JackPortDisconnectRequest()
00581     {}
00582     JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00583         : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00584     {}
00585 
00586     int Read(JackChannelTransaction* trans)
00587     {
00588         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00589         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00590         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00591         return 0;
00592     }
00593 
00594     int Write(JackChannelTransaction* trans)
00595     {
00596         CheckRes(JackRequest::Write(trans));
00597         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00598         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00599         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00600         return 0;
00601 
00602     }
00603     
00604 } POST_PACKED_STRUCTURE;
00605 
00610 struct JackPortRenameRequest : public JackRequest
00611 {
00612 
00613     int fRefNum;
00614     jack_port_id_t fPort;
00615     char fName[JACK_PORT_NAME_SIZE + 1];
00616 
00617     JackPortRenameRequest()
00618     {}
00619     JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
00620         : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
00621     {
00622         strcpy(fName, name);
00623     }
00624 
00625     int Read(JackChannelTransaction* trans)
00626     {
00627         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00628         CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
00629         CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
00630         return 0;
00631     }
00632 
00633     int Write(JackChannelTransaction* trans)
00634     {
00635         CheckRes(JackRequest::Write(trans));
00636         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00637         CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
00638         CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
00639         return 0;
00640 
00641     }
00642     
00643 } POST_PACKED_STRUCTURE;
00644 
00649 struct JackSetBufferSizeRequest : public JackRequest
00650 {
00651 
00652     jack_nframes_t fBufferSize;
00653 
00654     JackSetBufferSizeRequest()
00655     {}
00656     JackSetBufferSizeRequest(jack_nframes_t buffer_size)
00657         : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
00658     {}
00659 
00660     int Read(JackChannelTransaction* trans)
00661     {
00662         return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
00663     }
00664 
00665     int Write(JackChannelTransaction* trans)
00666     {
00667         CheckRes(JackRequest::Write(trans));
00668         return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
00669     }
00670     
00671 } POST_PACKED_STRUCTURE;
00672 
00677 struct JackSetFreeWheelRequest : public JackRequest
00678 {
00679 
00680     int fOnOff;
00681 
00682     JackSetFreeWheelRequest()
00683     {}
00684     JackSetFreeWheelRequest(int onoff)
00685         : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
00686     {}
00687 
00688     int Read(JackChannelTransaction* trans)
00689     {
00690         return trans->Read(&fOnOff, sizeof(int));
00691     }
00692 
00693     int Write(JackChannelTransaction* trans)
00694     {
00695         CheckRes(JackRequest::Write(trans));
00696         return trans->Write(&fOnOff, sizeof(int));
00697     }
00698     
00699 } POST_PACKED_STRUCTURE;
00700 
00705 struct JackReleaseTimebaseRequest : public JackRequest
00706 {
00707 
00708     int fRefNum;
00709 
00710     JackReleaseTimebaseRequest()
00711     {}
00712     JackReleaseTimebaseRequest(int refnum)
00713         : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
00714     {}
00715 
00716     int Read(JackChannelTransaction* trans)
00717     {
00718         return trans->Read(&fRefNum, sizeof(int));
00719     }
00720 
00721     int Write(JackChannelTransaction* trans)
00722     {
00723         CheckRes(JackRequest::Write(trans));
00724         return trans->Write(&fRefNum, sizeof(int));
00725     }
00726     
00727 } POST_PACKED_STRUCTURE;
00728 
00733 struct JackSetTimebaseCallbackRequest : public JackRequest
00734 {
00735 
00736     int fRefNum;
00737     int fConditionnal;
00738 
00739     JackSetTimebaseCallbackRequest()
00740     {}
00741     JackSetTimebaseCallbackRequest(int refnum, int conditional)
00742         : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
00743     {}
00744 
00745     int Read(JackChannelTransaction* trans)
00746     {
00747         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00748         return trans->Read(&fConditionnal, sizeof(int));
00749     }
00750 
00751     int Write(JackChannelTransaction* trans)
00752     {
00753         CheckRes(JackRequest::Write(trans));
00754         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00755         return trans->Write(&fConditionnal, sizeof(int));
00756     }
00757     
00758 } POST_PACKED_STRUCTURE;
00759 
00764 struct JackGetInternalClientNameRequest : public JackRequest
00765 {
00766 
00767     int fRefNum;
00768     int fIntRefNum;
00769 
00770     JackGetInternalClientNameRequest()
00771     {}
00772     JackGetInternalClientNameRequest(int refnum, int int_ref)
00773             : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
00774     {}
00775 
00776     int Read(JackChannelTransaction* trans)
00777     {
00778         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00779         return trans->Read(&fIntRefNum, sizeof(int));
00780     }
00781 
00782     int Write(JackChannelTransaction* trans)
00783     {
00784         CheckRes(JackRequest::Write(trans));
00785         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00786         return trans->Write(&fIntRefNum, sizeof(int));
00787     }
00788     
00789 } POST_PACKED_STRUCTURE;
00790 
00795 struct JackGetInternalClientNameResult : public JackResult
00796 {
00797 
00798     char fName[JACK_CLIENT_NAME_SIZE + 1];
00799 
00800     JackGetInternalClientNameResult(): JackResult()
00801     {}
00802     JackGetInternalClientNameResult(int32_t result, const char* name)
00803             : JackResult(result)
00804     {
00805         snprintf(fName, sizeof(fName), "%s", name);
00806     }
00807 
00808     int Read(JackChannelTransaction* trans)
00809     {
00810         CheckRes(JackResult::Read(trans));
00811         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00812         return 0;
00813     }
00814 
00815     int Write(JackChannelTransaction* trans)
00816     {
00817         CheckRes(JackResult::Write(trans));
00818         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00819         return 0;
00820     }
00821     
00822 } POST_PACKED_STRUCTURE;
00823 
00828 struct JackInternalClientHandleRequest : public JackRequest
00829 {
00830 
00831     int fRefNum;
00832     char fName[JACK_CLIENT_NAME_SIZE + 1];
00833 
00834     JackInternalClientHandleRequest()
00835     {}
00836     JackInternalClientHandleRequest(int refnum, const char* client_name)
00837             : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
00838     {
00839         snprintf(fName, sizeof(fName), "%s", client_name);
00840     }
00841 
00842     int Read(JackChannelTransaction* trans)
00843     {
00844         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00845         return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
00846     }
00847 
00848     int Write(JackChannelTransaction* trans)
00849     {
00850         CheckRes(JackRequest::Write(trans));
00851         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00852         return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
00853     }
00854     
00855 } POST_PACKED_STRUCTURE;
00856 
00861 struct JackInternalClientHandleResult : public JackResult
00862 {
00863 
00864     int fStatus;
00865     int fIntRefNum;
00866 
00867     JackInternalClientHandleResult(): JackResult()
00868     {}
00869     JackInternalClientHandleResult(int32_t result, int status, int int_ref)
00870             : JackResult(result), fStatus(status), fIntRefNum(int_ref)
00871     {}
00872 
00873     int Read(JackChannelTransaction* trans)
00874     {
00875         CheckRes(JackResult::Read(trans));
00876         CheckRes(trans->Read(&fStatus, sizeof(int)));
00877         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00878         return 0;
00879     }
00880 
00881     int Write(JackChannelTransaction* trans)
00882     {
00883         CheckRes(JackResult::Write(trans));
00884         CheckRes(trans->Write(&fStatus, sizeof(int)));
00885         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00886         return 0;
00887     }
00888     
00889 } POST_PACKED_STRUCTURE;
00890 
00895 struct JackInternalClientLoadRequest : public JackRequest
00896 {
00897 
00898 #ifndef MAX_PATH
00899 #define MAX_PATH 256
00900 #endif
00901 
00902     int fRefNum;
00903     char fName[JACK_CLIENT_NAME_SIZE + 1];
00904     char fDllName[MAX_PATH + 1];
00905     char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
00906     int fOptions;
00907 
00908     JackInternalClientLoadRequest()
00909     {}
00910     JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options)
00911             : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options)
00912     {
00913         snprintf(fName, sizeof(fName), "%s", client_name);
00914         snprintf(fDllName, sizeof(fDllName), "%s", so_name);
00915         snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
00916     }
00917 
00918     int Read(JackChannelTransaction* trans)
00919     {
00920         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00921         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00922         CheckRes(trans->Read(&fDllName, MAX_PATH + 1));
00923         CheckRes(trans->Read(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
00924         return trans->Read(&fOptions, sizeof(int));
00925     }
00926 
00927     int Write(JackChannelTransaction* trans)
00928     {
00929         CheckRes(JackRequest::Write(trans));
00930         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00931         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00932         CheckRes(trans->Write(&fDllName, MAX_PATH + 1));
00933         CheckRes(trans->Write(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
00934         return trans->Write(&fOptions, sizeof(int));
00935     }
00936     
00937 } POST_PACKED_STRUCTURE;
00938 
00943 struct JackInternalClientLoadResult : public JackResult
00944 {
00945 
00946     int fStatus;
00947     int fIntRefNum;
00948 
00949     JackInternalClientLoadResult(): JackResult()
00950     {}
00951     JackInternalClientLoadResult(int32_t result, int status, int int_ref)
00952             : JackResult(result), fStatus(status), fIntRefNum(int_ref)
00953     {}
00954 
00955     int Read(JackChannelTransaction* trans)
00956     {
00957         CheckRes(JackResult::Read(trans));
00958         CheckRes(trans->Read(&fStatus, sizeof(int)));
00959         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00960         return 0;
00961     }
00962 
00963     int Write(JackChannelTransaction* trans)
00964     {
00965         CheckRes(JackResult::Write(trans));
00966         CheckRes(trans->Write(&fStatus, sizeof(int)));
00967         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00968         return 0;
00969     }
00970     
00971 } POST_PACKED_STRUCTURE;
00972 
00977 struct JackInternalClientUnloadRequest : public JackRequest
00978 {
00979 
00980     int fRefNum;
00981     int fIntRefNum;
00982 
00983     JackInternalClientUnloadRequest()
00984     {}
00985     JackInternalClientUnloadRequest(int refnum, int int_ref)
00986             : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
00987     {}
00988 
00989     int Read(JackChannelTransaction* trans)
00990     {
00991         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00992         return trans->Read(&fIntRefNum, sizeof(int));
00993     }
00994 
00995     int Write(JackChannelTransaction* trans)
00996     {
00997         CheckRes(JackRequest::Write(trans));
00998         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00999         return trans->Write(&fIntRefNum, sizeof(int));
01000     }
01001 } POST_PACKED_STRUCTURE;
01002 
01007 struct JackInternalClientUnloadResult : public JackResult
01008 {
01009 
01010     int fStatus;
01011 
01012     JackInternalClientUnloadResult(): JackResult()
01013     {}
01014     JackInternalClientUnloadResult(int32_t result, int status)
01015             : JackResult(result), fStatus(status)
01016     {}
01017 
01018     int Read(JackChannelTransaction* trans)
01019     {
01020         CheckRes(JackResult::Read(trans));
01021         CheckRes(trans->Read(&fStatus, sizeof(int)));
01022         return 0;
01023     }
01024 
01025     int Write(JackChannelTransaction* trans)
01026     {
01027         CheckRes(JackResult::Write(trans));
01028         CheckRes(trans->Write(&fStatus, sizeof(int)));
01029         return 0;
01030     }
01031     
01032 } POST_PACKED_STRUCTURE;
01033 
01038 struct JackClientNotificationRequest : public JackRequest
01039 {
01040 
01041     int fRefNum;
01042     int fNotify;
01043     int fValue;
01044 
01045     JackClientNotificationRequest()
01046     {}
01047     JackClientNotificationRequest(int refnum, int notify, int value)
01048             : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
01049     {}
01050 
01051     int Read(JackChannelTransaction* trans)
01052     {
01053         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01054         CheckRes(trans->Read(&fNotify, sizeof(int)));
01055         CheckRes(trans->Read(&fValue, sizeof(int)));
01056         return 0;
01057     }
01058 
01059     int Write(JackChannelTransaction* trans)
01060     {
01061         CheckRes(JackRequest::Write(trans));
01062         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01063         CheckRes(trans->Write(&fNotify, sizeof(int)));
01064         CheckRes(trans->Write(&fValue, sizeof(int)));
01065         return 0;
01066     }
01067 
01068 } POST_PACKED_STRUCTURE;
01069 
01074 struct JackClientNotification
01075 {
01076     char fName[JACK_CLIENT_NAME_SIZE + 1];
01077     int fRefNum;
01078     int fNotify;
01079     int fValue1;
01080     int fValue2;
01081     int fSync;
01082     char fMessage[JACK_MESSAGE_SIZE + 1];
01083 
01084     JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)
01085     {}
01086     JackClientNotification(const char* name, int refnum, int notify, int sync, const char* message, int value1, int value2)
01087             : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
01088     {
01089         snprintf(fName, sizeof(fName), "%s", name);
01090         snprintf(fMessage, sizeof(fMessage), "%s", message);
01091     }
01092 
01093     int Read(JackChannelTransaction* trans)
01094     {
01095         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
01096         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01097         CheckRes(trans->Read(&fNotify, sizeof(int)));
01098         CheckRes(trans->Read(&fValue1, sizeof(int)));
01099         CheckRes(trans->Read(&fValue2, sizeof(int)));
01100         CheckRes(trans->Read(&fSync, sizeof(int)));
01101         CheckRes(trans->Read(&fMessage, JACK_MESSAGE_SIZE + 1));
01102         return 0;
01103     }
01104 
01105     int Write(JackChannelTransaction* trans)
01106     {
01107         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
01108         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01109         CheckRes(trans->Write(&fNotify, sizeof(int)));
01110         CheckRes(trans->Write(&fValue1, sizeof(int)));
01111         CheckRes(trans->Write(&fValue2, sizeof(int)));
01112         CheckRes(trans->Write(&fSync, sizeof(int)));
01113         CheckRes(trans->Write(&fMessage, JACK_MESSAGE_SIZE + 1));
01114         return 0;
01115     }
01116 
01117 } POST_PACKED_STRUCTURE;
01118 
01119 } // end of namespace
01120 
01121 #endif