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 "JackPort.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 
00055         kReleaseTimebase = 12,
00056         kSetTimebaseCallback = 13,
00057 
00058         kSetBufferSize = 20,
00059         kSetFreeWheel = 21,
00060                 kClientCheck = 22,
00061         kClientOpen = 23,
00062         kClientClose = 24,
00063         kConnectNamePorts = 25,
00064         kDisconnectNamePorts = 26,
00065                 kGetInternalClientName = 27,
00066                 kInternalClientHandle = 28,
00067                 kInternalClientLoad = 29,
00068                 kInternalClientUnload = 30,
00069 
00070         kNotification = 31
00071     };
00072 
00073     RequestType fType;
00074 
00075     JackRequest()
00076     {}
00077 
00078     JackRequest(RequestType type): fType(type)
00079     {}
00080 
00081         virtual ~JackRequest()
00082     {}
00083 
00084         virtual int Read(JackChannelTransaction* trans)
00085     {
00086                 return trans->Read(&fType, sizeof(RequestType));
00087     }
00088 
00089         virtual int Write(JackChannelTransaction* trans)
00090     {
00091                 return trans->Write(&fType, sizeof(RequestType));
00092     }
00093 
00094 };
00095 
00100 struct JackResult
00101 {
00102 
00103     int fResult;
00104 
00105     JackResult(): fResult( -1)
00106     {}
00107     JackResult(int result): fResult(result)
00108     {}
00109     virtual ~JackResult()
00110     {}
00111 
00112     virtual int Read(JackChannelTransaction* trans)
00113     {
00114                 return trans->Read(&fResult, sizeof(int));
00115     }
00116 
00117     virtual int Write(JackChannelTransaction* trans)
00118     {
00119                 return trans->Write(&fResult, sizeof(int));
00120     }
00121 };
00122 
00127 struct JackClientCheckRequest : public JackRequest
00128 {
00129 
00130     char fName[JACK_CLIENT_NAME_SIZE + 1];
00131         int fProtocol;
00132     int fOptions;
00133 
00134     JackClientCheckRequest()
00135     {}
00136     JackClientCheckRequest(const char* name, int protocol, int options): 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 
00161 struct JackClientCheckResult : public JackResult
00162 {
00163 
00164         char fName[JACK_CLIENT_NAME_SIZE + 1];
00165         int fStatus;
00166 
00167     JackClientCheckResult():JackResult(),fStatus(0)
00168     {}
00169     JackClientCheckResult(int32_t result, const char* name, int status)
00170          : JackResult(result), fStatus(status)
00171     {
00172                   snprintf(fName, sizeof(fName), "%s", name);
00173         }
00174 
00175         int Read(JackChannelTransaction* trans)
00176     {
00177                 CheckRes(JackResult::Read(trans));
00178                 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00179                 CheckRes(trans->Read(&fStatus, sizeof(int)));
00180                 return 0;
00181     }
00182 
00183     int Write(JackChannelTransaction* trans)
00184     {
00185                 CheckRes(JackResult::Write(trans));
00186                 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00187                 CheckRes(trans->Write(&fStatus, sizeof(int)));
00188                 return 0;
00189     }
00190 };
00191 
00196 struct JackClientOpenRequest : public JackRequest
00197 {
00198 
00199     char fName[JACK_CLIENT_NAME_SIZE + 1];
00200 
00201     JackClientOpenRequest()
00202     {}
00203     JackClientOpenRequest(const char* name): JackRequest(JackRequest::kClientOpen)
00204     {
00205         snprintf(fName, sizeof(fName), "%s", name);
00206     }
00207 
00208     int Read(JackChannelTransaction* trans)
00209     {
00210                 return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
00211     }
00212 
00213     int Write(JackChannelTransaction* trans)
00214     {
00215                 CheckRes(JackRequest::Write(trans));
00216                 return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
00217     }
00218 };
00219 
00224 struct JackClientOpenResult : public JackResult
00225 {
00226 
00227     int fSharedEngine;
00228     int fSharedClient;
00229     int fSharedGraph;
00230     uint32_t fProtocolVersion;
00231 
00232     JackClientOpenResult()
00233                 :JackResult(),fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1), fProtocolVersion(0)
00234     {}
00235     JackClientOpenResult(int32_t result, int index1, int index2, int index3)
00236          : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3), fProtocolVersion(0)
00237     {}
00238 
00239    int Read(JackChannelTransaction* trans)
00240     {
00241                 CheckRes(JackResult::Read(trans));
00242                 CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
00243                 CheckRes(trans->Read(&fSharedClient, sizeof(int)));
00244                 CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
00245                 CheckRes(trans->Read(&fProtocolVersion, sizeof(uint32_t)));
00246                 return 0;
00247     }
00248 
00249     int Write(JackChannelTransaction* trans)
00250     {
00251                 CheckRes(JackResult::Write(trans));
00252                 CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
00253                 CheckRes(trans->Write(&fSharedClient, sizeof(int)));
00254                 CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
00255                 CheckRes(trans->Write(&fProtocolVersion, sizeof(uint32_t)));
00256                 return 0;
00257     }
00258 };
00259 
00264 struct JackClientCloseRequest : public JackRequest
00265 {
00266 
00267     int fRefNum;
00268 
00269     JackClientCloseRequest()
00270     {}
00271     JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
00272     {}
00273 
00274     int Read(JackChannelTransaction* trans)
00275     {
00276                 return trans->Read(&fRefNum, sizeof(int));
00277     }
00278 
00279     int Write(JackChannelTransaction* trans)
00280     {
00281                 CheckRes(JackRequest::Write(trans));
00282                 return trans->Write(&fRefNum, sizeof(int));
00283     }
00284 };
00285 
00290 struct JackActivateRequest : public JackRequest
00291 {
00292 
00293     int fRefNum;
00294 
00295     JackActivateRequest()
00296     {}
00297     JackActivateRequest(int refnum): JackRequest(JackRequest::kActivateClient), fRefNum(refnum)
00298     {}
00299 
00300     int Read(JackChannelTransaction* trans)
00301     {
00302                 return trans->Read(&fRefNum, sizeof(int));
00303     }
00304 
00305     int Write(JackChannelTransaction* trans)
00306     {
00307                 CheckRes(JackRequest::Write(trans));
00308                 return trans->Write(&fRefNum, sizeof(int));
00309     }
00310 
00311 };
00312 
00317 struct JackDeactivateRequest : public JackRequest
00318 {
00319 
00320     int fRefNum;
00321 
00322     JackDeactivateRequest()
00323     {}
00324     JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
00325     {}
00326 
00327     int Read(JackChannelTransaction* trans)
00328     {
00329                 return trans->Read(&fRefNum, sizeof(int));
00330     }
00331 
00332     int Write(JackChannelTransaction* trans)
00333     {
00334                 CheckRes(JackRequest::Write(trans));
00335                 return trans->Write(&fRefNum, sizeof(int));
00336     }
00337 
00338 };
00339 
00344 struct JackPortRegisterRequest : public JackRequest
00345 {
00346 
00347     int fRefNum;
00348     char fName[JACK_PORT_NAME_SIZE + 1];
00349     char fPortType[JACK_PORT_TYPE_SIZE + 1];
00350     unsigned int fFlags;
00351     unsigned int fBufferSize;
00352 
00353     JackPortRegisterRequest()
00354     {}
00355     JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
00356             : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
00357     {
00358         strcpy(fName, name);
00359         strcpy(fPortType, port_type);
00360     }
00361 
00362     int Read(JackChannelTransaction* trans)
00363     {
00364                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00365                 CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
00366                 CheckRes(trans->Read(&fPortType, JACK_PORT_TYPE_SIZE + 1));
00367                 CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
00368                 CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
00369                 return 0;
00370     }
00371 
00372     int Write(JackChannelTransaction* trans)
00373     {
00374                 CheckRes(JackRequest::Write(trans));
00375                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00376                 CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
00377                 CheckRes(trans->Write(&fPortType, JACK_PORT_TYPE_SIZE + 1));
00378                 CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
00379                 CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
00380                 return 0;
00381     }
00382 };
00383 
00388 struct JackPortRegisterResult : public JackResult
00389 {
00390 
00391     jack_port_id_t fPortIndex;
00392 
00393     JackPortRegisterResult():JackResult(),fPortIndex(NO_PORT)
00394     {}
00395 
00396     int Read(JackChannelTransaction* trans)
00397     {
00398                 CheckRes(JackResult::Read(trans));
00399                 return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
00400     }
00401 
00402     int Write(JackChannelTransaction* trans)
00403     {
00404                 CheckRes(JackResult::Write(trans));
00405                 return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
00406     }
00407 };
00408 
00413 struct JackPortUnRegisterRequest : public JackRequest
00414 {
00415 
00416     int fRefNum;
00417     int fPortIndex;
00418 
00419     JackPortUnRegisterRequest()
00420     {}
00421     JackPortUnRegisterRequest(int refnum, int index): JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
00422     {}
00423 
00424     int Read(JackChannelTransaction* trans)
00425     {
00426                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00427                 CheckRes(trans->Read(&fPortIndex, sizeof(int)));
00428                 return 0;
00429     }
00430 
00431     int Write(JackChannelTransaction* trans)
00432     {
00433                 CheckRes(JackRequest::Write(trans));
00434                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00435                 CheckRes(trans->Write(&fPortIndex, sizeof(int)));
00436                 return 0;
00437     }
00438 };
00439 
00444 struct JackPortConnectNameRequest : public JackRequest
00445 {
00446         
00447     int fRefNum;
00448     char fSrc[JACK_PORT_NAME_SIZE + 1];
00449     char fDst[JACK_PORT_NAME_SIZE + 1];
00450 
00451     JackPortConnectNameRequest()
00452     {}
00453     JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
00454     {
00455         strcpy(fSrc, src_name);
00456         strcpy(fDst, dst_name);
00457     }
00458 
00459     int Read(JackChannelTransaction* trans)
00460     {
00461                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00462                 CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
00463                 CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
00464                 return 0;
00465 
00466     }
00467 
00468     int Write(JackChannelTransaction* trans)
00469     {
00470                 CheckRes(JackRequest::Write(trans));
00471                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00472                 CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
00473                 CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
00474                 return 0;
00475     }
00476 };
00477 
00482 struct JackPortDisconnectNameRequest : public JackRequest
00483 {
00484 
00485     int fRefNum;
00486     char fSrc[JACK_PORT_NAME_SIZE + 1];
00487     char fDst[JACK_PORT_NAME_SIZE + 1];
00488 
00489     JackPortDisconnectNameRequest()
00490     {}
00491     JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
00492     {
00493         strcpy(fSrc, src_name);
00494         strcpy(fDst, dst_name);
00495     }
00496 
00497     int Read(JackChannelTransaction* trans)
00498     {
00499                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00500                 CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
00501                 CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
00502                 return 0;
00503     }
00504 
00505     int Write(JackChannelTransaction* trans)
00506     {
00507                 CheckRes(JackRequest::Write(trans));
00508                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00509                 CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
00510                 CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
00511                 return 0;
00512     }
00513 };
00514 
00519 struct JackPortConnectRequest : public JackRequest
00520 {
00521 
00522     int fRefNum;
00523     jack_port_id_t fSrc;
00524     jack_port_id_t fDst;
00525 
00526     JackPortConnectRequest()
00527     {}
00528     JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00529     {}
00530 
00531     int Read(JackChannelTransaction* trans)
00532     {
00533                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00534                 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00535                 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00536                 return 0;
00537     }
00538 
00539     int Write(JackChannelTransaction* trans)
00540     {
00541                 CheckRes(JackRequest::Write(trans));
00542                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00543                 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00544                 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00545                 return 0;
00546     }
00547 };
00548 
00549 
00554 struct JackPortDisconnectRequest : public JackRequest
00555 {
00556 
00557     int fRefNum;
00558     jack_port_id_t fSrc;
00559     jack_port_id_t fDst;
00560 
00561     JackPortDisconnectRequest()
00562     {}
00563     JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00564     {}
00565 
00566     int Read(JackChannelTransaction* trans)
00567     {
00568                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00569                 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00570                 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00571                 return 0;
00572     }
00573 
00574     int Write(JackChannelTransaction* trans)
00575     {
00576                 CheckRes(JackRequest::Write(trans));
00577                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00578                 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00579                 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00580                 return 0;
00581 
00582     }
00583 };
00584 
00589 struct JackSetBufferSizeRequest : public JackRequest
00590 {
00591 
00592     jack_nframes_t fBufferSize;
00593 
00594     JackSetBufferSizeRequest()
00595     {}
00596     JackSetBufferSizeRequest(jack_nframes_t buffer_size): JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
00597     {}
00598 
00599     int Read(JackChannelTransaction* trans)
00600     {
00601                 return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
00602     }
00603 
00604     int Write(JackChannelTransaction* trans)
00605     {
00606                 CheckRes(JackRequest::Write(trans));
00607                 return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
00608     }
00609 };
00610 
00615 struct JackSetFreeWheelRequest : public JackRequest
00616 {
00617 
00618     int fOnOff;
00619 
00620     JackSetFreeWheelRequest()
00621     {}
00622     JackSetFreeWheelRequest(int onoff): JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
00623     {}
00624 
00625     int Read(JackChannelTransaction* trans)
00626     {
00627                 return trans->Read(&fOnOff, sizeof(int));
00628     }
00629 
00630     int Write(JackChannelTransaction* trans)
00631     {
00632                 CheckRes(JackRequest::Write(trans));
00633                 return trans->Write(&fOnOff, sizeof(int));
00634     }
00635 };
00636 
00641 struct JackReleaseTimebaseRequest : public JackRequest
00642 {
00643 
00644     int fRefNum;
00645 
00646     JackReleaseTimebaseRequest()
00647     {}
00648     JackReleaseTimebaseRequest(int refnum): JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
00649     {}
00650 
00651     int Read(JackChannelTransaction* trans)
00652     {
00653                 return trans->Read(&fRefNum, sizeof(int));
00654     }
00655 
00656     int Write(JackChannelTransaction* trans)
00657     {
00658                 CheckRes(JackRequest::Write(trans));
00659                 return trans->Write(&fRefNum, sizeof(int));
00660     }
00661 };
00662 
00667 struct JackSetTimebaseCallbackRequest : public JackRequest
00668 {
00669 
00670     int fRefNum;
00671     int fConditionnal;
00672 
00673     JackSetTimebaseCallbackRequest()
00674     {}
00675     JackSetTimebaseCallbackRequest(int refnum, int conditional): JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
00676     {}
00677 
00678     int Read(JackChannelTransaction* trans)
00679     {
00680                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00681                 return trans->Read(&fConditionnal, sizeof(int));
00682     }
00683 
00684     int Write(JackChannelTransaction* trans)
00685     {
00686                 CheckRes(JackRequest::Write(trans));
00687                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00688                 return trans->Write(&fConditionnal, sizeof(int));
00689     }
00690 };
00691 
00696 struct JackGetInternalClientNameRequest : public JackRequest
00697 {
00698 
00699         int fRefNum;
00700     int fIntRefNum;
00701 
00702     JackGetInternalClientNameRequest()
00703     {}
00704     JackGetInternalClientNameRequest(int refnum, int int_ref)
00705                 : JackRequest(JackRequest::kGetInternalClientName),fRefNum(refnum),fIntRefNum(int_ref)
00706     {}
00707 
00708     int Read(JackChannelTransaction* trans)
00709     {
00710                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00711                 return trans->Read(&fIntRefNum, sizeof(int));
00712     }
00713 
00714     int Write(JackChannelTransaction* trans)
00715     {
00716                 CheckRes(JackRequest::Write(trans));
00717                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00718                 return trans->Write(&fIntRefNum, sizeof(int));
00719     }
00720 };
00721 
00726 struct JackGetInternalClientNameResult : public JackResult
00727 {
00728 
00729         char fName[JACK_CLIENT_NAME_SIZE + 1];
00730 
00731     JackGetInternalClientNameResult():JackResult()
00732     {}
00733     JackGetInternalClientNameResult(int32_t result, const char* name)
00734          : JackResult(result)
00735     {
00736                   snprintf(fName, sizeof(fName), "%s", name);
00737         }
00738 
00739         int Read(JackChannelTransaction* trans)
00740     {
00741                 CheckRes(JackResult::Read(trans));
00742                 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00743                 return 0;
00744     }
00745 
00746     int Write(JackChannelTransaction* trans)
00747     {
00748                 CheckRes(JackResult::Write(trans));
00749                 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00750                 return 0;
00751     }
00752 };
00753 
00758 struct JackInternalClientHandleRequest : public JackRequest
00759 {
00760 
00761         int fRefNum;
00762     char fName[JACK_CLIENT_NAME_SIZE + 1];
00763 
00764     JackInternalClientHandleRequest()
00765     {}
00766     JackInternalClientHandleRequest(int refnum, const char* client_name)
00767                 : JackRequest(JackRequest::kInternalClientHandle),fRefNum(refnum)
00768     {
00769                 snprintf(fName, sizeof(fName), "%s", client_name);
00770         }
00771 
00772     int Read(JackChannelTransaction* trans)
00773     {
00774                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00775                 return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
00776     }
00777 
00778     int Write(JackChannelTransaction* trans)
00779     {
00780                 CheckRes(JackRequest::Write(trans));
00781                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00782                 return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
00783     }
00784 };
00785 
00790 struct JackInternalClientHandleResult : public JackResult
00791 {
00792 
00793         int fStatus;
00794         int fIntRefNum;
00795 
00796     JackInternalClientHandleResult():JackResult()
00797     {}
00798     JackInternalClientHandleResult(int32_t result, int status, int int_ref)
00799          : JackResult(result),fStatus(status),fIntRefNum(int_ref)
00800     {}
00801 
00802         int Read(JackChannelTransaction* trans)
00803     {
00804                 CheckRes(JackResult::Read(trans));
00805                 CheckRes(trans->Read(&fStatus, sizeof(int)));
00806                 CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00807                 return 0;
00808     }
00809 
00810     int Write(JackChannelTransaction* trans)
00811     {
00812                 CheckRes(JackResult::Write(trans));
00813                 CheckRes(trans->Write(&fStatus, sizeof(int)));
00814                 CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00815                 return 0;
00816     }
00817 };
00818 
00823 struct JackInternalClientLoadRequest : public JackRequest
00824 {
00825 
00826         #define MAX_PATH 256
00827         
00828         int fRefNum;
00829     char fName[JACK_CLIENT_NAME_SIZE + 1];
00830         char fDllName[MAX_PATH + 1];
00831         char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
00832         int fOptions;
00833 
00834     JackInternalClientLoadRequest()
00835     {}
00836     JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options)
00837                 : JackRequest(JackRequest::kInternalClientLoad),fRefNum(refnum),fOptions(options)
00838     {
00839                 snprintf(fName, sizeof(fName), "%s", client_name);
00840                 snprintf(fDllName, sizeof(fDllName), "%s", so_name);
00841                 snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
00842         }
00843 
00844     int Read(JackChannelTransaction* trans)
00845     {
00846                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00847                 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00848                 CheckRes(trans->Read(&fDllName, MAX_PATH + 1));
00849                 CheckRes(trans->Read(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
00850                 return trans->Read(&fOptions, sizeof(int));
00851     }
00852 
00853     int Write(JackChannelTransaction* trans)
00854     {
00855                 CheckRes(JackRequest::Write(trans));
00856                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00857                 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00858                 CheckRes(trans->Write(&fDllName, MAX_PATH + 1));
00859                 CheckRes(trans->Write(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
00860                 return trans->Write(&fOptions, sizeof(int));
00861     }
00862 };
00863 
00868 struct JackInternalClientLoadResult : public JackResult
00869 {
00870 
00871         int fStatus;
00872         int fIntRefNum;
00873 
00874     JackInternalClientLoadResult():JackResult()
00875     {}
00876     JackInternalClientLoadResult(int32_t result, int status, int int_ref)
00877          : JackResult(result),fStatus(status),fIntRefNum(int_ref)
00878     {}
00879 
00880         int Read(JackChannelTransaction* trans)
00881     {
00882                 CheckRes(JackResult::Read(trans));
00883                 CheckRes(trans->Read(&fStatus, sizeof(int)));
00884                 CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00885                 return 0;
00886     }
00887 
00888     int Write(JackChannelTransaction* trans)
00889     {
00890                 CheckRes(JackResult::Write(trans));
00891                 CheckRes(trans->Write(&fStatus, sizeof(int)));
00892                 CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00893                 return 0;
00894     }
00895 };
00896 
00901 struct JackInternalClientUnloadRequest : public JackRequest
00902 {
00903 
00904         int fRefNum;
00905     int fIntRefNum;
00906 
00907     JackInternalClientUnloadRequest()
00908     {}
00909     JackInternalClientUnloadRequest(int refnum, int int_ref)
00910                 : JackRequest(JackRequest::kInternalClientUnload),fRefNum(refnum),fIntRefNum(int_ref)
00911     {}
00912 
00913     int Read(JackChannelTransaction* trans)
00914     {
00915                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00916                 return trans->Read(&fIntRefNum, sizeof(int));
00917     }
00918 
00919     int Write(JackChannelTransaction* trans)
00920     {
00921                 CheckRes(JackRequest::Write(trans));
00922                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00923                 return trans->Write(&fIntRefNum, sizeof(int));
00924     }
00925 };
00926 
00927 
00932 struct JackInternalClientUnloadResult : public JackResult
00933 {
00934 
00935         int fStatus;
00936 
00937     JackInternalClientUnloadResult():JackResult()
00938     {}
00939     JackInternalClientUnloadResult(int32_t result, int status)
00940          : JackResult(result),fStatus(status)
00941     {}
00942 
00943         int Read(JackChannelTransaction* trans)
00944     {
00945                 CheckRes(JackResult::Read(trans));
00946                 CheckRes(trans->Read(&fStatus, sizeof(int)));
00947                 return 0;
00948     }
00949 
00950     int Write(JackChannelTransaction* trans)
00951     {
00952                 CheckRes(JackResult::Write(trans));
00953                 CheckRes(trans->Write(&fStatus, sizeof(int)));
00954                 return 0;
00955     }
00956 };
00957 
00962 struct JackClientNotificationRequest : public JackRequest
00963 {
00964         
00965     int fRefNum;
00966     int fNotify;
00967     int fValue;
00968 
00969     JackClientNotificationRequest()
00970     {}
00971     JackClientNotificationRequest(int refnum, int notify, int value)
00972             : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
00973     {}
00974 
00975     int Read(JackChannelTransaction* trans)
00976     {
00977                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00978                 CheckRes(trans->Read(&fNotify, sizeof(int)));
00979                 CheckRes(trans->Read(&fValue, sizeof(int)));
00980                 return 0;
00981     }
00982 
00983     int Write(JackChannelTransaction* trans)
00984     {
00985                 CheckRes(JackRequest::Write(trans));
00986                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00987                 CheckRes(trans->Write(&fNotify, sizeof(int)));
00988                 CheckRes(trans->Write(&fValue, sizeof(int)));
00989                 return 0;
00990     }
00991 
00992 };
00993 
00998 struct JackClientNotification
00999 {
01000     char fName[JACK_CLIENT_NAME_SIZE + 1];
01001     int fRefNum;
01002     int fNotify;
01003     int fValue;
01004     int fSync;
01005 
01006     JackClientNotification(): fNotify( -1), fValue( -1)
01007     {}
01008     JackClientNotification(const char* name, int refnum, int notify, int sync, int value)
01009             : fRefNum(refnum), fNotify(notify), fValue(value), fSync(sync)
01010     {
01011         snprintf(fName, sizeof(fName), "%s", name);
01012     }
01013 
01014     int Read(JackChannelTransaction* trans)
01015     {
01016                 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
01017                 CheckRes(trans->Read(&fRefNum, sizeof(int)));
01018                 CheckRes(trans->Read(&fNotify, sizeof(int)));
01019                 CheckRes(trans->Read(&fValue, sizeof(int)));
01020                 CheckRes(trans->Read(&fSync, sizeof(int)));
01021                 return 0;
01022     }
01023 
01024     int Write(JackChannelTransaction* trans)
01025     {
01026                 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
01027                 CheckRes(trans->Write(&fRefNum, sizeof(int)));
01028                 CheckRes(trans->Write(&fNotify, sizeof(int)));
01029                 CheckRes(trans->Write(&fValue, 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 Mon Oct 15 17:11:14 2007 for Jackdmp by  doxygen 1.5.1