JackRequest.h

00001 
00002 
00003 /*
00004     Copyright (C) 2001 Paul Davis 
00005  
00006     This program is free software; you can redistribute it and/or modify
00007     it under the terms of the GNU General Public License as published by
00008     the Free Software Foundation; either version 2 of the License, or
00009     (at your option) any later version.
00010  
00011     This program is distributed in the hope that it will be useful,
00012     but WITHOUT ANY WARRANTY; without even the implied warranty of
00013     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014     GNU General Public License for more details.
00015  
00016     You should have received a copy of the GNU General Public License
00017     along with this program; if not, write to the Free Software
00018     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00019  
00020 */
00021 
00022 #ifndef __JackRequest__
00023 #define __JackRequest__
00024 
00025 #include "JackConstants.h"
00026 #include "JackChannelTransaction.h"
00027 #include "JackError.h"
00028 #include <stdio.h>
00029 
00030 namespace Jack
00031 {
00032 
00033 #define CheckRes(res) {if (res < 0) return res;}
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         kNotification = 31
00068     };
00069 
00070     RequestType fType;
00071 
00072     JackRequest()
00073     {}
00074 
00075     JackRequest(RequestType type): fType(type)
00076     {}
00077 
00078         virtual ~JackRequest()
00079     {}
00080 
00081         virtual int Read(JackChannelTransaction* trans)
00082     {
00083                 return trans->Read(&fType, sizeof(RequestType));
00084     }
00085 
00086         virtual int Write(JackChannelTransaction* trans)
00087     {
00088                 return trans->Write(&fType, sizeof(RequestType));
00089     }
00090 
00091 };
00092 
00097 struct JackResult
00098 {
00099 
00100     int fResult;
00101 
00102     JackResult(): fResult( -1)
00103     {}
00104     JackResult(int result): fResult(result)
00105     {}
00106     virtual ~JackResult()
00107     {}
00108 
00109     virtual int Read(JackChannelTransaction* trans)
00110     {
00111                 return trans->Read(&fResult, sizeof(int));
00112     }
00113 
00114     virtual int Write(JackChannelTransaction* trans)
00115     {
00116                 return trans->Write(&fResult, sizeof(int));
00117     }
00118 };
00119 
00124 struct JackClientCheckRequest : public JackRequest
00125 {
00126 
00127     char fName[JACK_CLIENT_NAME_SIZE + 1];
00128         int fProtocol;
00129     int fOptions;
00130 
00131     JackClientCheckRequest()
00132     {}
00133     JackClientCheckRequest(const char* name, int protocol, int options): JackRequest(JackRequest::kClientCheck),fProtocol(protocol),fOptions(options)
00134     {
00135         snprintf(fName, sizeof(fName), "%s", name);
00136     }
00137 
00138     int Read(JackChannelTransaction* trans)
00139     {
00140                 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00141                 CheckRes(trans->Read(&fProtocol, sizeof(int)));
00142                 return trans->Read(&fOptions, sizeof(int));
00143     }
00144 
00145     int Write(JackChannelTransaction* trans)
00146     {
00147                 CheckRes(JackRequest::Write(trans));
00148                 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00149                 CheckRes(trans->Write(&fProtocol, sizeof(int)));
00150                 return trans->Write(&fOptions, sizeof(int));
00151     }
00152 };
00153 
00158 struct JackClientCheckResult : public JackResult
00159 {
00160 
00161         char fName[JACK_CLIENT_NAME_SIZE + 1];
00162         int fStatus;
00163 
00164     JackClientCheckResult():JackResult(),fStatus(0)
00165     {}
00166     JackClientCheckResult(int32_t result, const char* name, int status)
00167          : JackResult(result), fStatus(status)
00168     {
00169                   snprintf(fName, sizeof(fName), "%s", name);
00170         }
00171 
00172         int Read(JackChannelTransaction* trans)
00173     {
00174                 CheckRes(JackResult::Read(trans));
00175                 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00176                 CheckRes(trans->Read(&fStatus, sizeof(int)));
00177                 return 0;
00178     }
00179 
00180     int Write(JackChannelTransaction* trans)
00181     {
00182                 CheckRes(JackResult::Write(trans));
00183                 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00184                 CheckRes(trans->Write(&fStatus, sizeof(int)));
00185                 return 0;
00186     }
00187 };
00188 
00193 struct JackClientOpenRequest : public JackRequest
00194 {
00195 
00196     char fName[JACK_CLIENT_NAME_SIZE + 1];
00197 
00198     JackClientOpenRequest()
00199     {}
00200     JackClientOpenRequest(const char* name): JackRequest(JackRequest::kClientOpen)
00201     {
00202         snprintf(fName, sizeof(fName), "%s", name);
00203     }
00204 
00205     int Read(JackChannelTransaction* trans)
00206     {
00207                 return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
00208     }
00209 
00210     int Write(JackChannelTransaction* trans)
00211     {
00212                 CheckRes(JackRequest::Write(trans));
00213                 return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
00214     }
00215 };
00216 
00221 struct JackClientOpenResult : public JackResult
00222 {
00223 
00224     int fSharedEngine;
00225     int fSharedClient;
00226     int fSharedGraph;
00227     uint32_t fProtocolVersion;
00228 
00229     JackClientOpenResult()
00230                 :JackResult(),fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1), fProtocolVersion(0)
00231     {}
00232     JackClientOpenResult(int32_t result, int index1, int index2, int index3)
00233          : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3), fProtocolVersion(0)
00234     {}
00235 
00236    int Read(JackChannelTransaction* trans)
00237     {
00238                 CheckRes(JackResult::Read(trans));
00239                 CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
00240                 CheckRes(trans->Read(&fSharedClient, sizeof(int)));
00241                 CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
00242                 CheckRes(trans->Read(&fProtocolVersion, sizeof(uint32_t)));
00243                 return 0;
00244     }
00245 
00246     int Write(JackChannelTransaction* trans)
00247     {
00248                 CheckRes(JackResult::Write(trans));
00249                 CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
00250                 CheckRes(trans->Write(&fSharedClient, sizeof(int)));
00251                 CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
00252                 CheckRes(trans->Write(&fProtocolVersion, sizeof(uint32_t)));
00253                 return 0;
00254     }
00255 };
00256 
00261 struct JackClientCloseRequest : public JackRequest
00262 {
00263 
00264     int fRefNum;
00265 
00266     JackClientCloseRequest()
00267     {}
00268     JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
00269     {}
00270 
00271     int Read(JackChannelTransaction* trans)
00272     {
00273                 return trans->Read(&fRefNum, sizeof(int));
00274     }
00275 
00276     int Write(JackChannelTransaction* trans)
00277     {
00278                 CheckRes(JackRequest::Write(trans));
00279                 return trans->Write(&fRefNum, sizeof(int));
00280     }
00281 };
00282 
00287 struct JackActivateRequest : public JackRequest
00288 {
00289 
00290     int fRefNum;
00291 
00292     JackActivateRequest()
00293     {}
00294     JackActivateRequest(int refnum): JackRequest(JackRequest::kActivateClient), fRefNum(refnum)
00295     {}
00296 
00297     int Read(JackChannelTransaction* trans)
00298     {
00299                 return trans->Read(&fRefNum, sizeof(int));
00300     }
00301 
00302     int Write(JackChannelTransaction* trans)
00303     {
00304                 CheckRes(JackRequest::Write(trans));
00305                 return trans->Write(&fRefNum, sizeof(int));
00306     }
00307 
00308 };
00309 
00314 struct JackDeactivateRequest : public JackRequest
00315 {
00316 
00317     int fRefNum;
00318 
00319     JackDeactivateRequest()
00320     {}
00321     JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
00322     {}
00323 
00324     int Read(JackChannelTransaction* trans)
00325     {
00326                 return trans->Read(&fRefNum, sizeof(int));
00327     }
00328 
00329     int Write(JackChannelTransaction* trans)
00330     {
00331                 CheckRes(JackRequest::Write(trans));
00332                 return trans->Write(&fRefNum, sizeof(int));
00333     }
00334 
00335 };
00336 
00341 struct JackPortRegisterRequest : public JackRequest
00342 {
00343 
00344     int fRefNum;
00345     char fName[JACK_PORT_NAME_SIZE + 1];
00346     char fPortType[JACK_PORT_TYPE_SIZE + 1];
00347     unsigned int fFlags;
00348     unsigned int fBufferSize;
00349 
00350     JackPortRegisterRequest()
00351     {}
00352     JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
00353             : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
00354     {
00355         strcpy(fName, name);
00356         strcpy(fPortType, port_type);
00357     }
00358 
00359     int Read(JackChannelTransaction* trans)
00360     {
00361                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00362                 CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
00363                 CheckRes(trans->Read(&fPortType, JACK_PORT_TYPE_SIZE + 1));
00364                 CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
00365                 CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
00366                 return 0;
00367     }
00368 
00369     int Write(JackChannelTransaction* trans)
00370     {
00371                 CheckRes(JackRequest::Write(trans));
00372                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00373                 CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
00374                 CheckRes(trans->Write(&fPortType, JACK_PORT_TYPE_SIZE + 1));
00375                 CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
00376                 CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
00377                 return 0;
00378     }
00379 };
00380 
00385 struct JackPortRegisterResult : public JackResult
00386 {
00387 
00388     unsigned int fPortIndex;
00389 
00390     JackPortRegisterResult():JackResult(),fPortIndex(NO_PORT)
00391     {}
00392 
00393     int Read(JackChannelTransaction* trans)
00394     {
00395                 CheckRes(JackResult::Read(trans));
00396                 return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
00397     }
00398 
00399     int Write(JackChannelTransaction* trans)
00400     {
00401                 CheckRes(JackResult::Write(trans));
00402                 return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
00403     }
00404 };
00405 
00410 struct JackPortUnRegisterRequest : public JackRequest
00411 {
00412 
00413     int fRefNum;
00414     int fPortIndex;
00415 
00416     JackPortUnRegisterRequest()
00417     {}
00418     JackPortUnRegisterRequest(int refnum, int index): JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
00419     {}
00420 
00421     int Read(JackChannelTransaction* trans)
00422     {
00423                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00424                 CheckRes(trans->Read(&fPortIndex, sizeof(int)));
00425                 return 0;
00426     }
00427 
00428     int Write(JackChannelTransaction* trans)
00429     {
00430                 CheckRes(JackRequest::Write(trans));
00431                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00432                 CheckRes(trans->Write(&fPortIndex, sizeof(int)));
00433                 return 0;
00434     }
00435 };
00436 
00441 struct JackPortConnectNameRequest : public JackRequest
00442 {
00443         
00444     int fRefNum;
00445     char fSrc[JACK_PORT_NAME_SIZE + 1];
00446     char fDst[JACK_PORT_NAME_SIZE + 1];
00447 
00448     JackPortConnectNameRequest()
00449     {}
00450     JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
00451     {
00452         strcpy(fSrc, src_name);
00453         strcpy(fDst, dst_name);
00454     }
00455 
00456     int Read(JackChannelTransaction* trans)
00457     {
00458                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00459                 CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
00460                 CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
00461                 return 0;
00462 
00463     }
00464 
00465     int Write(JackChannelTransaction* trans)
00466     {
00467                 CheckRes(JackRequest::Write(trans));
00468                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00469                 CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
00470                 CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
00471                 return 0;
00472     }
00473 };
00474 
00479 struct JackPortDisconnectNameRequest : public JackRequest
00480 {
00481 
00482     int fRefNum;
00483     char fSrc[JACK_PORT_NAME_SIZE + 1];
00484     char fDst[JACK_PORT_NAME_SIZE + 1];
00485 
00486     JackPortDisconnectNameRequest()
00487     {}
00488     JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
00489     {
00490         strcpy(fSrc, src_name);
00491         strcpy(fDst, dst_name);
00492     }
00493 
00494     int Read(JackChannelTransaction* trans)
00495     {
00496                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00497                 CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
00498                 CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
00499                 return 0;
00500     }
00501 
00502     int Write(JackChannelTransaction* trans)
00503     {
00504                 CheckRes(JackRequest::Write(trans));
00505                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00506                 CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
00507                 CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
00508                 return 0;
00509     }
00510 };
00511 
00516 struct JackPortConnectRequest : public JackRequest
00517 {
00518 
00519     int fRefNum;
00520     jack_port_id_t fSrc;
00521     jack_port_id_t fDst;
00522 
00523     JackPortConnectRequest()
00524     {}
00525     JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00526     {}
00527 
00528     int Read(JackChannelTransaction* trans)
00529     {
00530                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00531                 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00532                 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00533                 return 0;
00534     }
00535 
00536     int Write(JackChannelTransaction* trans)
00537     {
00538                 CheckRes(JackRequest::Write(trans));
00539                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00540                 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00541                 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00542                 return 0;
00543     }
00544 };
00545 
00546 
00551 struct JackPortDisconnectRequest : public JackRequest
00552 {
00553 
00554     int fRefNum;
00555     jack_port_id_t fSrc;
00556     jack_port_id_t fDst;
00557 
00558     JackPortDisconnectRequest()
00559     {}
00560     JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00561     {}
00562 
00563     int Read(JackChannelTransaction* trans)
00564     {
00565                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00566                 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00567                 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00568                 return 0;
00569     }
00570 
00571     int Write(JackChannelTransaction* trans)
00572     {
00573                 CheckRes(JackRequest::Write(trans));
00574                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00575                 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00576                 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00577                 return 0;
00578 
00579     }
00580 };
00581 
00586 struct JackSetBufferSizeRequest : public JackRequest
00587 {
00588 
00589     jack_nframes_t fBufferSize;
00590 
00591     JackSetBufferSizeRequest()
00592     {}
00593     JackSetBufferSizeRequest(jack_nframes_t buffer_size): JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
00594     {}
00595 
00596     int Read(JackChannelTransaction* trans)
00597     {
00598                 return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
00599     }
00600 
00601     int Write(JackChannelTransaction* trans)
00602     {
00603                 CheckRes(JackRequest::Write(trans));
00604                 return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
00605     }
00606 };
00607 
00612 struct JackSetFreeWheelRequest : public JackRequest
00613 {
00614 
00615     int fOnOff;
00616 
00617     JackSetFreeWheelRequest()
00618     {}
00619     JackSetFreeWheelRequest(int onoff): JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
00620     {}
00621 
00622     int Read(JackChannelTransaction* trans)
00623     {
00624                 return trans->Read(&fOnOff, sizeof(int));
00625     }
00626 
00627     int Write(JackChannelTransaction* trans)
00628     {
00629                 CheckRes(JackRequest::Write(trans));
00630                 return trans->Write(&fOnOff, sizeof(int));
00631     }
00632 };
00633 
00638 struct JackReleaseTimebaseRequest : public JackRequest
00639 {
00640 
00641     int fRefNum;
00642 
00643     JackReleaseTimebaseRequest()
00644     {}
00645     JackReleaseTimebaseRequest(int refnum): JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
00646     {}
00647 
00648     int Read(JackChannelTransaction* trans)
00649     {
00650                 return trans->Read(&fRefNum, sizeof(int));
00651     }
00652 
00653     int Write(JackChannelTransaction* trans)
00654     {
00655                 CheckRes(JackRequest::Write(trans));
00656                 return trans->Write(&fRefNum, sizeof(int));
00657     }
00658 };
00659 
00664 struct JackSetTimebaseCallbackRequest : public JackRequest
00665 {
00666 
00667     int fRefNum;
00668     int fConditionnal;
00669 
00670     JackSetTimebaseCallbackRequest()
00671     {}
00672     JackSetTimebaseCallbackRequest(int refnum, int conditional): JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
00673     {}
00674 
00675     int Read(JackChannelTransaction* trans)
00676     {
00677                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00678                 return trans->Read(&fConditionnal, sizeof(int));
00679     }
00680 
00681     int Write(JackChannelTransaction* trans)
00682     {
00683                 CheckRes(JackRequest::Write(trans));
00684                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00685                 return trans->Write(&fConditionnal, sizeof(int));
00686     }
00687 };
00688 
00693 struct JackGetInternalClientNameRequest : public JackRequest
00694 {
00695 
00696         int fRefNum;
00697     int fIntRefNum;
00698 
00699     JackGetInternalClientNameRequest()
00700     {}
00701     JackGetInternalClientNameRequest(int refnum, int int_ref)
00702                 : JackRequest(JackRequest::kGetInternalClientName),fRefNum(refnum),fIntRefNum(int_ref)
00703     {}
00704 
00705     int Read(JackChannelTransaction* trans)
00706     {
00707                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00708                 return trans->Read(&fIntRefNum, sizeof(int));
00709     }
00710 
00711     int Write(JackChannelTransaction* trans)
00712     {
00713                 CheckRes(JackRequest::Write(trans));
00714                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00715                 return trans->Write(&fIntRefNum, sizeof(int));
00716     }
00717 };
00718 
00723 struct JackGetInternalClientNameResult : public JackResult
00724 {
00725 
00726         char fName[JACK_CLIENT_NAME_SIZE + 1];
00727 
00728     JackGetInternalClientNameResult():JackResult()
00729     {}
00730     JackGetInternalClientNameResult(int32_t result, const char* name)
00731          : JackResult(result)
00732     {
00733                   snprintf(fName, sizeof(fName), "%s", name);
00734         }
00735 
00736         int Read(JackChannelTransaction* trans)
00737     {
00738                 CheckRes(JackResult::Read(trans));
00739                 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00740                 return 0;
00741     }
00742 
00743     int Write(JackChannelTransaction* trans)
00744     {
00745                 CheckRes(JackResult::Write(trans));
00746                 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00747                 return 0;
00748     }
00749 };
00750 
00755 struct JackInternalClientHandleRequest : public JackRequest
00756 {
00757 
00758         int fRefNum;
00759     char fName[JACK_CLIENT_NAME_SIZE + 1];
00760 
00761     JackInternalClientHandleRequest()
00762     {}
00763     JackInternalClientHandleRequest(int refnum, const char* client_name)
00764                 : JackRequest(JackRequest::kInternalClientHandle),fRefNum(refnum)
00765     {
00766                 snprintf(fName, sizeof(fName), "%s", client_name);
00767         }
00768 
00769     int Read(JackChannelTransaction* trans)
00770     {
00771                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00772                 return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
00773     }
00774 
00775     int Write(JackChannelTransaction* trans)
00776     {
00777                 CheckRes(JackRequest::Write(trans));
00778                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00779                 return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
00780     }
00781 };
00782 
00787 struct JackInternalClientHandleResult : public JackResult
00788 {
00789 
00790         int fStatus;
00791         int fIntRefNum;
00792 
00793     JackInternalClientHandleResult():JackResult()
00794     {}
00795     JackInternalClientHandleResult(int32_t result, int status, int int_ref)
00796          : JackResult(result),fStatus(status),fIntRefNum(int_ref)
00797     {}
00798 
00799         int Read(JackChannelTransaction* trans)
00800     {
00801                 CheckRes(JackResult::Read(trans));
00802                 CheckRes(trans->Read(&fStatus, sizeof(int)));
00803                 CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00804                 return 0;
00805     }
00806 
00807     int Write(JackChannelTransaction* trans)
00808     {
00809                 CheckRes(JackResult::Write(trans));
00810                 CheckRes(trans->Write(&fStatus, sizeof(int)));
00811                 CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00812                 return 0;
00813     }
00814 };
00815 
00820 struct JackInternalClientLoadRequest : public JackRequest
00821 {
00822 
00823         #define MAX_PATH 256
00824         
00825         int fRefNum;
00826     char fName[JACK_CLIENT_NAME_SIZE + 1];
00827         char fDllName[MAX_PATH + 1];
00828         char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
00829         int fOptions;
00830 
00831     JackInternalClientLoadRequest()
00832     {}
00833     JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options)
00834                 : JackRequest(JackRequest::kInternalClientLoad),fRefNum(refnum),fOptions(options)
00835     {
00836                 snprintf(fName, sizeof(fName), "%s", client_name);
00837                 snprintf(fDllName, sizeof(fDllName), "%s", so_name);
00838                 snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
00839         }
00840 
00841     int Read(JackChannelTransaction* trans)
00842     {
00843                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00844                 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00845                 CheckRes(trans->Read(&fDllName, MAX_PATH + 1));
00846                 CheckRes(trans->Read(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
00847                 return trans->Read(&fOptions, sizeof(int));
00848     }
00849 
00850     int Write(JackChannelTransaction* trans)
00851     {
00852                 CheckRes(JackRequest::Write(trans));
00853                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00854                 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00855                 CheckRes(trans->Write(&fDllName, MAX_PATH + 1));
00856                 CheckRes(trans->Write(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
00857                 return trans->Write(&fOptions, sizeof(int));
00858     }
00859 };
00860 
00865 struct JackInternalClientLoadResult : public JackResult
00866 {
00867 
00868         int fStatus;
00869         int fIntRefNum;
00870 
00871     JackInternalClientLoadResult():JackResult()
00872     {}
00873     JackInternalClientLoadResult(int32_t result, int status, int int_ref)
00874          : JackResult(result),fStatus(status),fIntRefNum(int_ref)
00875     {}
00876 
00877         int Read(JackChannelTransaction* trans)
00878     {
00879                 CheckRes(JackResult::Read(trans));
00880                 CheckRes(trans->Read(&fStatus, sizeof(int)));
00881                 CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00882                 return 0;
00883     }
00884 
00885     int Write(JackChannelTransaction* trans)
00886     {
00887                 CheckRes(JackResult::Write(trans));
00888                 CheckRes(trans->Write(&fStatus, sizeof(int)));
00889                 CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00890                 return 0;
00891     }
00892 };
00893 
00898 struct JackInternalClientUnloadRequest : public JackRequest
00899 {
00900 
00901         int fRefNum;
00902     int fIntRefNum;
00903 
00904     JackInternalClientUnloadRequest()
00905     {}
00906     JackInternalClientUnloadRequest(int refnum, int int_ref)
00907                 : JackRequest(JackRequest::kInternalClientUnload),fRefNum(refnum),fIntRefNum(int_ref)
00908     {}
00909 
00910     int Read(JackChannelTransaction* trans)
00911     {
00912                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00913                 return trans->Read(&fIntRefNum, sizeof(int));
00914     }
00915 
00916     int Write(JackChannelTransaction* trans)
00917     {
00918                 CheckRes(JackRequest::Write(trans));
00919                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00920                 return trans->Write(&fIntRefNum, sizeof(int));
00921     }
00922 };
00923 
00924 
00929 struct JackInternalClientUnloadResult : public JackResult
00930 {
00931 
00932         int fStatus;
00933 
00934     JackInternalClientUnloadResult():JackResult()
00935     {}
00936     JackInternalClientUnloadResult(int32_t result, int status)
00937          : JackResult(result),fStatus(status)
00938     {}
00939 
00940         int Read(JackChannelTransaction* trans)
00941     {
00942                 CheckRes(JackResult::Read(trans));
00943                 CheckRes(trans->Read(&fStatus, sizeof(int)));
00944                 return 0;
00945     }
00946 
00947     int Write(JackChannelTransaction* trans)
00948     {
00949                 CheckRes(JackResult::Write(trans));
00950                 CheckRes(trans->Write(&fStatus, sizeof(int)));
00951                 return 0;
00952     }
00953 };
00954 
00959 struct JackClientNotificationRequest : public JackRequest
00960 {
00961         
00962     int fRefNum;
00963     int fNotify;
00964     int fValue;
00965 
00966     JackClientNotificationRequest()
00967     {}
00968     JackClientNotificationRequest(int refnum, int notify, int value)
00969             : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
00970     {}
00971 
00972     int Read(JackChannelTransaction* trans)
00973     {
00974                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00975                 CheckRes(trans->Read(&fNotify, sizeof(int)));
00976                 CheckRes(trans->Read(&fValue, sizeof(int)));
00977                 return 0;
00978     }
00979 
00980     int Write(JackChannelTransaction* trans)
00981     {
00982                 CheckRes(JackRequest::Write(trans));
00983                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00984                 CheckRes(trans->Write(&fNotify, sizeof(int)));
00985                 CheckRes(trans->Write(&fValue, sizeof(int)));
00986                 return 0;
00987     }
00988 
00989 };
00990 
00995 struct JackClientNotification
00996 {
00997     char fName[JACK_CLIENT_NAME_SIZE + 1];
00998     int fRefNum;
00999     int fNotify;
01000     int fValue1;
01001         int fValue2;
01002     int fSync;
01003 
01004     JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)
01005     {}
01006     JackClientNotification(const char* name, int refnum, int notify, int sync, int value1, int value2)
01007             : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
01008     {
01009         snprintf(fName, sizeof(fName), "%s", name);
01010     }
01011 
01012     int Read(JackChannelTransaction* trans)
01013     {
01014                 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
01015                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
01016                 CheckRes(trans->Read(&fNotify, sizeof(int)));
01017                 CheckRes(trans->Read(&fValue1, sizeof(int)));
01018                 CheckRes(trans->Read(&fValue2, sizeof(int)));
01019                 CheckRes(trans->Read(&fSync, sizeof(int)));
01020                 return 0;
01021     }
01022 
01023     int Write(JackChannelTransaction* trans)
01024     {
01025                 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
01026                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
01027                 CheckRes(trans->Write(&fNotify, sizeof(int)));
01028                 CheckRes(trans->Write(&fValue1, sizeof(int)));
01029                 CheckRes(trans->Write(&fValue2, sizeof(int)));
01030                 CheckRes(trans->Write(&fSync, sizeof(int)));
01031                 return 0;
01032     }
01033 
01034 };
01035 
01036 } // end of namespace
01037 
01038 #endif

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