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 "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 }
01037
01038 #endif