00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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
00125 struct JackClientCheckRequest : public JackRequest
00126 {
00127
00128 char fName[JACK_CLIENT_NAME_SIZE + 1];
00129 int fProtocol;
00130 int fOptions;
00131
00132 JackClientCheckRequest()
00133 {}
00134 JackClientCheckRequest(const char* name, int protocol, int options)
00135 : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options)
00136 {
00137 snprintf(fName, sizeof(fName), "%s", name);
00138 }
00139
00140 int Read(JackChannelTransaction* trans)
00141 {
00142 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00143 CheckRes(trans->Read(&fProtocol, sizeof(int)));
00144 return trans->Read(&fOptions, sizeof(int));
00145 }
00146
00147 int Write(JackChannelTransaction* trans)
00148 {
00149 CheckRes(JackRequest::Write(trans));
00150 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00151 CheckRes(trans->Write(&fProtocol, sizeof(int)));
00152 return trans->Write(&fOptions, sizeof(int));
00153 }
00154 };
00155
00160 struct JackClientCheckResult : public JackResult
00161 {
00162
00163 char fName[JACK_CLIENT_NAME_SIZE + 1];
00164 int fStatus;
00165
00166 JackClientCheckResult(): JackResult(), fStatus(0)
00167 {}
00168 JackClientCheckResult(int32_t result, const char* name, int status)
00169 : JackResult(result), fStatus(status)
00170 {
00171 snprintf(fName, sizeof(fName), "%s", name);
00172 }
00173
00174 int Read(JackChannelTransaction* trans)
00175 {
00176 CheckRes(JackResult::Read(trans));
00177 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00178 CheckRes(trans->Read(&fStatus, sizeof(int)));
00179 return 0;
00180 }
00181
00182 int Write(JackChannelTransaction* trans)
00183 {
00184 CheckRes(JackResult::Write(trans));
00185 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00186 CheckRes(trans->Write(&fStatus, sizeof(int)));
00187 return 0;
00188 }
00189 };
00190
00195 struct JackClientOpenRequest : public JackRequest
00196 {
00197
00198 int fPID;
00199 char fName[JACK_CLIENT_NAME_SIZE + 1];
00200
00201 JackClientOpenRequest()
00202 {}
00203 JackClientOpenRequest(const char* name, int pid): JackRequest(JackRequest::kClientOpen)
00204 {
00205 snprintf(fName, sizeof(fName), "%s", name);
00206 fPID = pid;
00207 }
00208
00209 int Read(JackChannelTransaction* trans)
00210 {
00211 CheckRes(trans->Read(&fPID, sizeof(int)));
00212 return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
00213 }
00214
00215 int Write(JackChannelTransaction* trans)
00216 {
00217 CheckRes(JackRequest::Write(trans));
00218 CheckRes(trans->Write(&fPID, sizeof(int)));
00219 return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
00220 }
00221 };
00222
00227 struct JackClientOpenResult : public JackResult
00228 {
00229
00230 int fSharedEngine;
00231 int fSharedClient;
00232 int fSharedGraph;
00233
00234 JackClientOpenResult()
00235 : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
00236 {}
00237 JackClientOpenResult(int32_t result, int index1, int index2, int index3)
00238 : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
00239 {}
00240
00241 int Read(JackChannelTransaction* trans)
00242 {
00243 CheckRes(JackResult::Read(trans));
00244 CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
00245 CheckRes(trans->Read(&fSharedClient, sizeof(int)));
00246 CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
00247 return 0;
00248 }
00249
00250 int Write(JackChannelTransaction* trans)
00251 {
00252 CheckRes(JackResult::Write(trans));
00253 CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
00254 CheckRes(trans->Write(&fSharedClient, sizeof(int)));
00255 CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
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 int fState;
00295
00296 JackActivateRequest()
00297 {}
00298 JackActivateRequest(int refnum, int state)
00299 : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fState(state)
00300 {}
00301
00302 int Read(JackChannelTransaction* trans)
00303 {
00304 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00305 return trans->Read(&fState, sizeof(int));
00306 }
00307
00308 int Write(JackChannelTransaction* trans)
00309 {
00310 CheckRes(JackRequest::Write(trans));
00311 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00312 return trans->Write(&fState, sizeof(int));
00313 }
00314
00315 };
00316
00321 struct JackDeactivateRequest : public JackRequest
00322 {
00323
00324 int fRefNum;
00325
00326 JackDeactivateRequest()
00327 {}
00328 JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
00329 {}
00330
00331 int Read(JackChannelTransaction* trans)
00332 {
00333 return trans->Read(&fRefNum, sizeof(int));
00334 }
00335
00336 int Write(JackChannelTransaction* trans)
00337 {
00338 CheckRes(JackRequest::Write(trans));
00339 return trans->Write(&fRefNum, sizeof(int));
00340 }
00341
00342 };
00343
00348 struct JackPortRegisterRequest : public JackRequest
00349 {
00350
00351 int fRefNum;
00352 char fName[JACK_PORT_NAME_SIZE + 1];
00353 char fPortType[JACK_PORT_TYPE_SIZE + 1];
00354 unsigned int fFlags;
00355 unsigned int fBufferSize;
00356
00357 JackPortRegisterRequest()
00358 {}
00359 JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
00360 : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
00361 {
00362 strcpy(fName, name);
00363 strcpy(fPortType, port_type);
00364 }
00365
00366 int Read(JackChannelTransaction* trans)
00367 {
00368 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00369 CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
00370 CheckRes(trans->Read(&fPortType, JACK_PORT_TYPE_SIZE + 1));
00371 CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
00372 CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
00373 return 0;
00374 }
00375
00376 int Write(JackChannelTransaction* trans)
00377 {
00378 CheckRes(JackRequest::Write(trans));
00379 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00380 CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
00381 CheckRes(trans->Write(&fPortType, JACK_PORT_TYPE_SIZE + 1));
00382 CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
00383 CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
00384 return 0;
00385 }
00386 };
00387
00392 struct JackPortRegisterResult : public JackResult
00393 {
00394
00395 jack_port_id_t fPortIndex;
00396
00397 JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
00398 {}
00399
00400 int Read(JackChannelTransaction* trans)
00401 {
00402 CheckRes(JackResult::Read(trans));
00403 return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
00404 }
00405
00406 int Write(JackChannelTransaction* trans)
00407 {
00408 CheckRes(JackResult::Write(trans));
00409 return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
00410 }
00411 };
00412
00417 struct JackPortUnRegisterRequest : public JackRequest
00418 {
00419
00420 int fRefNum;
00421 jack_port_id_t fPortIndex;
00422
00423 JackPortUnRegisterRequest()
00424 {}
00425 JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
00426 : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
00427 {}
00428
00429 int Read(JackChannelTransaction* trans)
00430 {
00431 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00432 CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
00433 return 0;
00434 }
00435
00436 int Write(JackChannelTransaction* trans)
00437 {
00438 CheckRes(JackRequest::Write(trans));
00439 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00440 CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
00441 return 0;
00442 }
00443 };
00444
00449 struct JackPortConnectNameRequest : public JackRequest
00450 {
00451
00452 int fRefNum;
00453 char fSrc[JACK_PORT_NAME_SIZE + 1];
00454 char fDst[JACK_PORT_NAME_SIZE + 1];
00455
00456 JackPortConnectNameRequest()
00457 {}
00458 JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00459 : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
00460 {
00461 strcpy(fSrc, src_name);
00462 strcpy(fDst, dst_name);
00463 }
00464
00465 int Read(JackChannelTransaction* trans)
00466 {
00467 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00468 CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
00469 CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
00470 return 0;
00471
00472 }
00473
00474 int Write(JackChannelTransaction* trans)
00475 {
00476 CheckRes(JackRequest::Write(trans));
00477 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00478 CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
00479 CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
00480 return 0;
00481 }
00482 };
00483
00488 struct JackPortDisconnectNameRequest : public JackRequest
00489 {
00490
00491 int fRefNum;
00492 char fSrc[JACK_PORT_NAME_SIZE + 1];
00493 char fDst[JACK_PORT_NAME_SIZE + 1];
00494
00495 JackPortDisconnectNameRequest()
00496 {}
00497 JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00498 : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
00499 {
00500 strcpy(fSrc, src_name);
00501 strcpy(fDst, dst_name);
00502 }
00503
00504 int Read(JackChannelTransaction* trans)
00505 {
00506 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00507 CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
00508 CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
00509 return 0;
00510 }
00511
00512 int Write(JackChannelTransaction* trans)
00513 {
00514 CheckRes(JackRequest::Write(trans));
00515 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00516 CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
00517 CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
00518 return 0;
00519 }
00520 };
00521
00526 struct JackPortConnectRequest : public JackRequest
00527 {
00528
00529 int fRefNum;
00530 jack_port_id_t fSrc;
00531 jack_port_id_t fDst;
00532
00533 JackPortConnectRequest()
00534 {}
00535 JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00536 : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00537 {}
00538
00539 int Read(JackChannelTransaction* trans)
00540 {
00541 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00542 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00543 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00544 return 0;
00545 }
00546
00547 int Write(JackChannelTransaction* trans)
00548 {
00549 CheckRes(JackRequest::Write(trans));
00550 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00551 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00552 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00553 return 0;
00554 }
00555 };
00556
00557
00562 struct JackPortDisconnectRequest : public JackRequest
00563 {
00564
00565 int fRefNum;
00566 jack_port_id_t fSrc;
00567 jack_port_id_t fDst;
00568
00569 JackPortDisconnectRequest()
00570 {}
00571 JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00572 : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00573 {}
00574
00575 int Read(JackChannelTransaction* trans)
00576 {
00577 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00578 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00579 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00580 return 0;
00581 }
00582
00583 int Write(JackChannelTransaction* trans)
00584 {
00585 CheckRes(JackRequest::Write(trans));
00586 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00587 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00588 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00589 return 0;
00590
00591 }
00592 };
00593
00598 struct JackPortRenameRequest : public JackRequest
00599 {
00600
00601 int fRefNum;
00602 jack_port_id_t fPort;
00603 char fName[JACK_PORT_NAME_SIZE + 1];
00604
00605 JackPortRenameRequest()
00606 {}
00607 JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
00608 : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
00609 {
00610 strcpy(fName, name);
00611 }
00612
00613 int Read(JackChannelTransaction* trans)
00614 {
00615 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00616 CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
00617 CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
00618 return 0;
00619 }
00620
00621 int Write(JackChannelTransaction* trans)
00622 {
00623 CheckRes(JackRequest::Write(trans));
00624 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00625 CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
00626 CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
00627 return 0;
00628
00629 }
00630 };
00631
00636 struct JackSetBufferSizeRequest : public JackRequest
00637 {
00638
00639 jack_nframes_t fBufferSize;
00640
00641 JackSetBufferSizeRequest()
00642 {}
00643 JackSetBufferSizeRequest(jack_nframes_t buffer_size)
00644 : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
00645 {}
00646
00647 int Read(JackChannelTransaction* trans)
00648 {
00649 return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
00650 }
00651
00652 int Write(JackChannelTransaction* trans)
00653 {
00654 CheckRes(JackRequest::Write(trans));
00655 return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
00656 }
00657 };
00658
00663 struct JackSetFreeWheelRequest : public JackRequest
00664 {
00665
00666 int fOnOff;
00667
00668 JackSetFreeWheelRequest()
00669 {}
00670 JackSetFreeWheelRequest(int onoff)
00671 : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
00672 {}
00673
00674 int Read(JackChannelTransaction* trans)
00675 {
00676 return trans->Read(&fOnOff, sizeof(int));
00677 }
00678
00679 int Write(JackChannelTransaction* trans)
00680 {
00681 CheckRes(JackRequest::Write(trans));
00682 return trans->Write(&fOnOff, sizeof(int));
00683 }
00684 };
00685
00690 struct JackReleaseTimebaseRequest : public JackRequest
00691 {
00692
00693 int fRefNum;
00694
00695 JackReleaseTimebaseRequest()
00696 {}
00697 JackReleaseTimebaseRequest(int refnum)
00698 : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
00699 {}
00700
00701 int Read(JackChannelTransaction* trans)
00702 {
00703 return trans->Read(&fRefNum, sizeof(int));
00704 }
00705
00706 int Write(JackChannelTransaction* trans)
00707 {
00708 CheckRes(JackRequest::Write(trans));
00709 return trans->Write(&fRefNum, sizeof(int));
00710 }
00711 };
00712
00717 struct JackSetTimebaseCallbackRequest : public JackRequest
00718 {
00719
00720 int fRefNum;
00721 int fConditionnal;
00722
00723 JackSetTimebaseCallbackRequest()
00724 {}
00725 JackSetTimebaseCallbackRequest(int refnum, int conditional)
00726 : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
00727 {}
00728
00729 int Read(JackChannelTransaction* trans)
00730 {
00731 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00732 return trans->Read(&fConditionnal, sizeof(int));
00733 }
00734
00735 int Write(JackChannelTransaction* trans)
00736 {
00737 CheckRes(JackRequest::Write(trans));
00738 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00739 return trans->Write(&fConditionnal, sizeof(int));
00740 }
00741 };
00742
00747 struct JackGetInternalClientNameRequest : public JackRequest
00748 {
00749
00750 int fRefNum;
00751 int fIntRefNum;
00752
00753 JackGetInternalClientNameRequest()
00754 {}
00755 JackGetInternalClientNameRequest(int refnum, int int_ref)
00756 : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
00757 {}
00758
00759 int Read(JackChannelTransaction* trans)
00760 {
00761 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00762 return trans->Read(&fIntRefNum, sizeof(int));
00763 }
00764
00765 int Write(JackChannelTransaction* trans)
00766 {
00767 CheckRes(JackRequest::Write(trans));
00768 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00769 return trans->Write(&fIntRefNum, sizeof(int));
00770 }
00771 };
00772
00777 struct JackGetInternalClientNameResult : public JackResult
00778 {
00779
00780 char fName[JACK_CLIENT_NAME_SIZE + 1];
00781
00782 JackGetInternalClientNameResult(): JackResult()
00783 {}
00784 JackGetInternalClientNameResult(int32_t result, const char* name)
00785 : JackResult(result)
00786 {
00787 snprintf(fName, sizeof(fName), "%s", name);
00788 }
00789
00790 int Read(JackChannelTransaction* trans)
00791 {
00792 CheckRes(JackResult::Read(trans));
00793 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00794 return 0;
00795 }
00796
00797 int Write(JackChannelTransaction* trans)
00798 {
00799 CheckRes(JackResult::Write(trans));
00800 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00801 return 0;
00802 }
00803 };
00804
00809 struct JackInternalClientHandleRequest : public JackRequest
00810 {
00811
00812 int fRefNum;
00813 char fName[JACK_CLIENT_NAME_SIZE + 1];
00814
00815 JackInternalClientHandleRequest()
00816 {}
00817 JackInternalClientHandleRequest(int refnum, const char* client_name)
00818 : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
00819 {
00820 snprintf(fName, sizeof(fName), "%s", client_name);
00821 }
00822
00823 int Read(JackChannelTransaction* trans)
00824 {
00825 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00826 return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
00827 }
00828
00829 int Write(JackChannelTransaction* trans)
00830 {
00831 CheckRes(JackRequest::Write(trans));
00832 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00833 return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
00834 }
00835 };
00836
00841 struct JackInternalClientHandleResult : public JackResult
00842 {
00843
00844 int fStatus;
00845 int fIntRefNum;
00846
00847 JackInternalClientHandleResult(): JackResult()
00848 {}
00849 JackInternalClientHandleResult(int32_t result, int status, int int_ref)
00850 : JackResult(result), fStatus(status), fIntRefNum(int_ref)
00851 {}
00852
00853 int Read(JackChannelTransaction* trans)
00854 {
00855 CheckRes(JackResult::Read(trans));
00856 CheckRes(trans->Read(&fStatus, sizeof(int)));
00857 CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00858 return 0;
00859 }
00860
00861 int Write(JackChannelTransaction* trans)
00862 {
00863 CheckRes(JackResult::Write(trans));
00864 CheckRes(trans->Write(&fStatus, sizeof(int)));
00865 CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00866 return 0;
00867 }
00868 };
00869
00874 struct JackInternalClientLoadRequest : public JackRequest
00875 {
00876
00877 #ifndef MAX_PATH
00878 #define MAX_PATH 256
00879 #endif
00880
00881 int fRefNum;
00882 char fName[JACK_CLIENT_NAME_SIZE + 1];
00883 char fDllName[MAX_PATH + 1];
00884 char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
00885 int fOptions;
00886
00887 JackInternalClientLoadRequest()
00888 {}
00889 JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options)
00890 : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options)
00891 {
00892 snprintf(fName, sizeof(fName), "%s", client_name);
00893 snprintf(fDllName, sizeof(fDllName), "%s", so_name);
00894 snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
00895 }
00896
00897 int Read(JackChannelTransaction* trans)
00898 {
00899 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00900 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00901 CheckRes(trans->Read(&fDllName, MAX_PATH + 1));
00902 CheckRes(trans->Read(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
00903 return trans->Read(&fOptions, sizeof(int));
00904 }
00905
00906 int Write(JackChannelTransaction* trans)
00907 {
00908 CheckRes(JackRequest::Write(trans));
00909 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00910 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00911 CheckRes(trans->Write(&fDllName, MAX_PATH + 1));
00912 CheckRes(trans->Write(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
00913 return trans->Write(&fOptions, sizeof(int));
00914 }
00915 };
00916
00921 struct JackInternalClientLoadResult : public JackResult
00922 {
00923
00924 int fStatus;
00925 int fIntRefNum;
00926
00927 JackInternalClientLoadResult(): JackResult()
00928 {}
00929 JackInternalClientLoadResult(int32_t result, int status, int int_ref)
00930 : JackResult(result), fStatus(status), fIntRefNum(int_ref)
00931 {}
00932
00933 int Read(JackChannelTransaction* trans)
00934 {
00935 CheckRes(JackResult::Read(trans));
00936 CheckRes(trans->Read(&fStatus, sizeof(int)));
00937 CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00938 return 0;
00939 }
00940
00941 int Write(JackChannelTransaction* trans)
00942 {
00943 CheckRes(JackResult::Write(trans));
00944 CheckRes(trans->Write(&fStatus, sizeof(int)));
00945 CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00946 return 0;
00947 }
00948 };
00949
00954 struct JackInternalClientUnloadRequest : public JackRequest
00955 {
00956
00957 int fRefNum;
00958 int fIntRefNum;
00959
00960 JackInternalClientUnloadRequest()
00961 {}
00962 JackInternalClientUnloadRequest(int refnum, int int_ref)
00963 : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
00964 {}
00965
00966 int Read(JackChannelTransaction* trans)
00967 {
00968 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00969 return trans->Read(&fIntRefNum, sizeof(int));
00970 }
00971
00972 int Write(JackChannelTransaction* trans)
00973 {
00974 CheckRes(JackRequest::Write(trans));
00975 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00976 return trans->Write(&fIntRefNum, sizeof(int));
00977 }
00978 };
00979
00980
00985 struct JackInternalClientUnloadResult : public JackResult
00986 {
00987
00988 int fStatus;
00989
00990 JackInternalClientUnloadResult(): JackResult()
00991 {}
00992 JackInternalClientUnloadResult(int32_t result, int status)
00993 : JackResult(result), fStatus(status)
00994 {}
00995
00996 int Read(JackChannelTransaction* trans)
00997 {
00998 CheckRes(JackResult::Read(trans));
00999 CheckRes(trans->Read(&fStatus, sizeof(int)));
01000 return 0;
01001 }
01002
01003 int Write(JackChannelTransaction* trans)
01004 {
01005 CheckRes(JackResult::Write(trans));
01006 CheckRes(trans->Write(&fStatus, sizeof(int)));
01007 return 0;
01008 }
01009 };
01010
01015 struct JackClientNotificationRequest : public JackRequest
01016 {
01017
01018 int fRefNum;
01019 int fNotify;
01020 int fValue;
01021
01022 JackClientNotificationRequest()
01023 {}
01024 JackClientNotificationRequest(int refnum, int notify, int value)
01025 : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
01026 {}
01027
01028 int Read(JackChannelTransaction* trans)
01029 {
01030 CheckRes(trans->Read(&fRefNum, sizeof(int)));
01031 CheckRes(trans->Read(&fNotify, sizeof(int)));
01032 CheckRes(trans->Read(&fValue, sizeof(int)));
01033 return 0;
01034 }
01035
01036 int Write(JackChannelTransaction* trans)
01037 {
01038 CheckRes(JackRequest::Write(trans));
01039 CheckRes(trans->Write(&fRefNum, sizeof(int)));
01040 CheckRes(trans->Write(&fNotify, sizeof(int)));
01041 CheckRes(trans->Write(&fValue, sizeof(int)));
01042 return 0;
01043 }
01044
01045 };
01046
01051 struct JackClientNotification
01052 {
01053 char fName[JACK_CLIENT_NAME_SIZE + 1];
01054 int fRefNum;
01055 int fNotify;
01056 int fValue1;
01057 int fValue2;
01058 int fSync;
01059
01060 JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)
01061 {}
01062 JackClientNotification(const char* name, int refnum, int notify, int sync, int value1, int value2)
01063 : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
01064 {
01065 snprintf(fName, sizeof(fName), "%s", name);
01066 }
01067
01068 int Read(JackChannelTransaction* trans)
01069 {
01070 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
01071 CheckRes(trans->Read(&fRefNum, sizeof(int)));
01072 CheckRes(trans->Read(&fNotify, sizeof(int)));
01073 CheckRes(trans->Read(&fValue1, sizeof(int)));
01074 CheckRes(trans->Read(&fValue2, sizeof(int)));
01075 CheckRes(trans->Read(&fSync, sizeof(int)));
01076 return 0;
01077 }
01078
01079 int Write(JackChannelTransaction* trans)
01080 {
01081 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
01082 CheckRes(trans->Write(&fRefNum, sizeof(int)));
01083 CheckRes(trans->Write(&fNotify, sizeof(int)));
01084 CheckRes(trans->Write(&fValue1, sizeof(int)));
01085 CheckRes(trans->Write(&fValue2, sizeof(int)));
01086 CheckRes(trans->Write(&fSync, sizeof(int)));
01087 return 0;
01088 }
01089
01090 };
01091
01092 }
01093
01094 #endif