00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
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 }
01037
01038 #endif