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 };
00121
00126 struct JackClientCheckRequest : public JackRequest
00127 {
00128
00129 char fName[JACK_CLIENT_NAME_SIZE + 1];
00130 int fProtocol;
00131 int fOptions;
00132
00133 JackClientCheckRequest()
00134 {}
00135 JackClientCheckRequest(const char* name, int protocol, int options)
00136 : 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 } POST_PACKED_STRUCTURE;
00157
00162 struct JackClientCheckResult : public JackResult
00163 {
00164
00165 char fName[JACK_CLIENT_NAME_SIZE + 1];
00166 int fStatus;
00167
00168 JackClientCheckResult(): JackResult(), fStatus(0)
00169 {}
00170 JackClientCheckResult(int32_t result, const char* name, int status)
00171 : JackResult(result), fStatus(status)
00172 {
00173 snprintf(fName, sizeof(fName), "%s", name);
00174 }
00175
00176 int Read(JackChannelTransaction* trans)
00177 {
00178 CheckRes(JackResult::Read(trans));
00179 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00180 CheckRes(trans->Read(&fStatus, sizeof(int)));
00181 return 0;
00182 }
00183
00184 int Write(JackChannelTransaction* trans)
00185 {
00186 CheckRes(JackResult::Write(trans));
00187 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00188 CheckRes(trans->Write(&fStatus, sizeof(int)));
00189 return 0;
00190 }
00191
00192 } POST_PACKED_STRUCTURE;
00193
00198 struct JackClientOpenRequest : public JackRequest
00199 {
00200
00201 int fPID;
00202 char fName[JACK_CLIENT_NAME_SIZE + 1];
00203
00204 JackClientOpenRequest()
00205 {}
00206 JackClientOpenRequest(const char* name, int pid): JackRequest(JackRequest::kClientOpen)
00207 {
00208 snprintf(fName, sizeof(fName), "%s", name);
00209 fPID = pid;
00210 }
00211
00212 int Read(JackChannelTransaction* trans)
00213 {
00214 CheckRes(trans->Read(&fPID, sizeof(int)));
00215 return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
00216 }
00217
00218 int Write(JackChannelTransaction* trans)
00219 {
00220 CheckRes(JackRequest::Write(trans));
00221 CheckRes(trans->Write(&fPID, sizeof(int)));
00222 return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
00223 }
00224
00225 } POST_PACKED_STRUCTURE;
00226
00231 struct JackClientOpenResult : public JackResult
00232 {
00233
00234 int fSharedEngine;
00235 int fSharedClient;
00236 int fSharedGraph;
00237
00238 JackClientOpenResult()
00239 : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
00240 {}
00241 JackClientOpenResult(int32_t result, int index1, int index2, int index3)
00242 : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
00243 {}
00244
00245 int Read(JackChannelTransaction* trans)
00246 {
00247 CheckRes(JackResult::Read(trans));
00248 CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
00249 CheckRes(trans->Read(&fSharedClient, sizeof(int)));
00250 CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
00251 return 0;
00252 }
00253
00254 int Write(JackChannelTransaction* trans)
00255 {
00256 CheckRes(JackResult::Write(trans));
00257 CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
00258 CheckRes(trans->Write(&fSharedClient, sizeof(int)));
00259 CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
00260 return 0;
00261 }
00262
00263 } POST_PACKED_STRUCTURE;
00264
00269 struct JackClientCloseRequest : public JackRequest
00270 {
00271
00272 int fRefNum;
00273
00274 JackClientCloseRequest()
00275 {}
00276 JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
00277 {}
00278
00279 int Read(JackChannelTransaction* trans)
00280 {
00281 return trans->Read(&fRefNum, sizeof(int));
00282 }
00283
00284 int Write(JackChannelTransaction* trans)
00285 {
00286 CheckRes(JackRequest::Write(trans));
00287 return trans->Write(&fRefNum, sizeof(int));
00288 }
00289
00290 } POST_PACKED_STRUCTURE;
00291
00296 struct JackActivateRequest : public JackRequest
00297 {
00298
00299 int fRefNum;
00300 int fState;
00301
00302 JackActivateRequest()
00303 {}
00304 JackActivateRequest(int refnum, int state)
00305 : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fState(state)
00306 {}
00307
00308 int Read(JackChannelTransaction* trans)
00309 {
00310 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00311 return trans->Read(&fState, sizeof(int));
00312 }
00313
00314 int Write(JackChannelTransaction* trans)
00315 {
00316 CheckRes(JackRequest::Write(trans));
00317 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00318 return trans->Write(&fState, sizeof(int));
00319 }
00320
00321 } POST_PACKED_STRUCTURE;
00322
00327 struct JackDeactivateRequest : public JackRequest
00328 {
00329
00330 int fRefNum;
00331
00332 JackDeactivateRequest()
00333 {}
00334 JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
00335 {}
00336
00337 int Read(JackChannelTransaction* trans)
00338 {
00339 return trans->Read(&fRefNum, sizeof(int));
00340 }
00341
00342 int Write(JackChannelTransaction* trans)
00343 {
00344 CheckRes(JackRequest::Write(trans));
00345 return trans->Write(&fRefNum, sizeof(int));
00346 }
00347
00348 } POST_PACKED_STRUCTURE;
00349
00354 struct JackPortRegisterRequest : public JackRequest
00355 {
00356
00357 int fRefNum;
00358 char fName[JACK_PORT_NAME_SIZE + 1];
00359 char fPortType[JACK_PORT_TYPE_SIZE + 1];
00360 unsigned int fFlags;
00361 unsigned int fBufferSize;
00362
00363 JackPortRegisterRequest()
00364 {}
00365 JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
00366 : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
00367 {
00368 strcpy(fName, name);
00369 strcpy(fPortType, port_type);
00370 }
00371
00372 int Read(JackChannelTransaction* trans)
00373 {
00374 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00375 CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
00376 CheckRes(trans->Read(&fPortType, JACK_PORT_TYPE_SIZE + 1));
00377 CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
00378 CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
00379 return 0;
00380 }
00381
00382 int Write(JackChannelTransaction* trans)
00383 {
00384 CheckRes(JackRequest::Write(trans));
00385 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00386 CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
00387 CheckRes(trans->Write(&fPortType, JACK_PORT_TYPE_SIZE + 1));
00388 CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
00389 CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
00390 return 0;
00391 }
00392
00393 } POST_PACKED_STRUCTURE;
00394
00399 struct JackPortRegisterResult : public JackResult
00400 {
00401
00402 jack_port_id_t fPortIndex;
00403
00404 JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
00405 {}
00406
00407 int Read(JackChannelTransaction* trans)
00408 {
00409 CheckRes(JackResult::Read(trans));
00410 return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
00411 }
00412
00413 int Write(JackChannelTransaction* trans)
00414 {
00415 CheckRes(JackResult::Write(trans));
00416 return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
00417 }
00418
00419 } POST_PACKED_STRUCTURE;
00420
00425 struct JackPortUnRegisterRequest : public JackRequest
00426 {
00427
00428 int fRefNum;
00429 jack_port_id_t fPortIndex;
00430
00431 JackPortUnRegisterRequest()
00432 {}
00433 JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
00434 : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
00435 {}
00436
00437 int Read(JackChannelTransaction* trans)
00438 {
00439 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00440 CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
00441 return 0;
00442 }
00443
00444 int Write(JackChannelTransaction* trans)
00445 {
00446 CheckRes(JackRequest::Write(trans));
00447 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00448 CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
00449 return 0;
00450 }
00451
00452 } POST_PACKED_STRUCTURE;
00453
00458 struct JackPortConnectNameRequest : public JackRequest
00459 {
00460
00461 int fRefNum;
00462 char fSrc[JACK_PORT_NAME_SIZE + 1];
00463 char fDst[JACK_PORT_NAME_SIZE + 1];
00464
00465 JackPortConnectNameRequest()
00466 {}
00467 JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00468 : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
00469 {
00470 strcpy(fSrc, src_name);
00471 strcpy(fDst, dst_name);
00472 }
00473
00474 int Read(JackChannelTransaction* trans)
00475 {
00476 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00477 CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
00478 CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
00479 return 0;
00480
00481 }
00482
00483 int Write(JackChannelTransaction* trans)
00484 {
00485 CheckRes(JackRequest::Write(trans));
00486 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00487 CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
00488 CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
00489 return 0;
00490 }
00491
00492 } POST_PACKED_STRUCTURE;
00493
00498 struct JackPortDisconnectNameRequest : public JackRequest
00499 {
00500
00501 int fRefNum;
00502 char fSrc[JACK_PORT_NAME_SIZE + 1];
00503 char fDst[JACK_PORT_NAME_SIZE + 1];
00504
00505 JackPortDisconnectNameRequest()
00506 {}
00507 JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00508 : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
00509 {
00510 strcpy(fSrc, src_name);
00511 strcpy(fDst, dst_name);
00512 }
00513
00514 int Read(JackChannelTransaction* trans)
00515 {
00516 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00517 CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
00518 CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
00519 return 0;
00520 }
00521
00522 int Write(JackChannelTransaction* trans)
00523 {
00524 CheckRes(JackRequest::Write(trans));
00525 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00526 CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
00527 CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
00528 return 0;
00529 }
00530
00531 } POST_PACKED_STRUCTURE;
00532
00537 struct JackPortConnectRequest : public JackRequest
00538 {
00539
00540 int fRefNum;
00541 jack_port_id_t fSrc;
00542 jack_port_id_t fDst;
00543
00544 JackPortConnectRequest()
00545 {}
00546 JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00547 : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00548 {}
00549
00550 int Read(JackChannelTransaction* trans)
00551 {
00552 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00553 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00554 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00555 return 0;
00556 }
00557
00558 int Write(JackChannelTransaction* trans)
00559 {
00560 CheckRes(JackRequest::Write(trans));
00561 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00562 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00563 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00564 return 0;
00565 }
00566
00567 } POST_PACKED_STRUCTURE;
00568
00573 struct JackPortDisconnectRequest : public JackRequest
00574 {
00575
00576 int fRefNum;
00577 jack_port_id_t fSrc;
00578 jack_port_id_t fDst;
00579
00580 JackPortDisconnectRequest()
00581 {}
00582 JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00583 : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00584 {}
00585
00586 int Read(JackChannelTransaction* trans)
00587 {
00588 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00589 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00590 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00591 return 0;
00592 }
00593
00594 int Write(JackChannelTransaction* trans)
00595 {
00596 CheckRes(JackRequest::Write(trans));
00597 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00598 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00599 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00600 return 0;
00601
00602 }
00603
00604 } POST_PACKED_STRUCTURE;
00605
00610 struct JackPortRenameRequest : public JackRequest
00611 {
00612
00613 int fRefNum;
00614 jack_port_id_t fPort;
00615 char fName[JACK_PORT_NAME_SIZE + 1];
00616
00617 JackPortRenameRequest()
00618 {}
00619 JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
00620 : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
00621 {
00622 strcpy(fName, name);
00623 }
00624
00625 int Read(JackChannelTransaction* trans)
00626 {
00627 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00628 CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
00629 CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
00630 return 0;
00631 }
00632
00633 int Write(JackChannelTransaction* trans)
00634 {
00635 CheckRes(JackRequest::Write(trans));
00636 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00637 CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
00638 CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
00639 return 0;
00640
00641 }
00642
00643 } POST_PACKED_STRUCTURE;
00644
00649 struct JackSetBufferSizeRequest : public JackRequest
00650 {
00651
00652 jack_nframes_t fBufferSize;
00653
00654 JackSetBufferSizeRequest()
00655 {}
00656 JackSetBufferSizeRequest(jack_nframes_t buffer_size)
00657 : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
00658 {}
00659
00660 int Read(JackChannelTransaction* trans)
00661 {
00662 return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
00663 }
00664
00665 int Write(JackChannelTransaction* trans)
00666 {
00667 CheckRes(JackRequest::Write(trans));
00668 return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
00669 }
00670
00671 } POST_PACKED_STRUCTURE;
00672
00677 struct JackSetFreeWheelRequest : public JackRequest
00678 {
00679
00680 int fOnOff;
00681
00682 JackSetFreeWheelRequest()
00683 {}
00684 JackSetFreeWheelRequest(int onoff)
00685 : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
00686 {}
00687
00688 int Read(JackChannelTransaction* trans)
00689 {
00690 return trans->Read(&fOnOff, sizeof(int));
00691 }
00692
00693 int Write(JackChannelTransaction* trans)
00694 {
00695 CheckRes(JackRequest::Write(trans));
00696 return trans->Write(&fOnOff, sizeof(int));
00697 }
00698
00699 } POST_PACKED_STRUCTURE;
00700
00705 struct JackReleaseTimebaseRequest : public JackRequest
00706 {
00707
00708 int fRefNum;
00709
00710 JackReleaseTimebaseRequest()
00711 {}
00712 JackReleaseTimebaseRequest(int refnum)
00713 : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
00714 {}
00715
00716 int Read(JackChannelTransaction* trans)
00717 {
00718 return trans->Read(&fRefNum, sizeof(int));
00719 }
00720
00721 int Write(JackChannelTransaction* trans)
00722 {
00723 CheckRes(JackRequest::Write(trans));
00724 return trans->Write(&fRefNum, sizeof(int));
00725 }
00726
00727 } POST_PACKED_STRUCTURE;
00728
00733 struct JackSetTimebaseCallbackRequest : public JackRequest
00734 {
00735
00736 int fRefNum;
00737 int fConditionnal;
00738
00739 JackSetTimebaseCallbackRequest()
00740 {}
00741 JackSetTimebaseCallbackRequest(int refnum, int conditional)
00742 : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
00743 {}
00744
00745 int Read(JackChannelTransaction* trans)
00746 {
00747 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00748 return trans->Read(&fConditionnal, sizeof(int));
00749 }
00750
00751 int Write(JackChannelTransaction* trans)
00752 {
00753 CheckRes(JackRequest::Write(trans));
00754 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00755 return trans->Write(&fConditionnal, sizeof(int));
00756 }
00757
00758 } POST_PACKED_STRUCTURE;
00759
00764 struct JackGetInternalClientNameRequest : public JackRequest
00765 {
00766
00767 int fRefNum;
00768 int fIntRefNum;
00769
00770 JackGetInternalClientNameRequest()
00771 {}
00772 JackGetInternalClientNameRequest(int refnum, int int_ref)
00773 : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
00774 {}
00775
00776 int Read(JackChannelTransaction* trans)
00777 {
00778 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00779 return trans->Read(&fIntRefNum, sizeof(int));
00780 }
00781
00782 int Write(JackChannelTransaction* trans)
00783 {
00784 CheckRes(JackRequest::Write(trans));
00785 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00786 return trans->Write(&fIntRefNum, sizeof(int));
00787 }
00788
00789 } POST_PACKED_STRUCTURE;
00790
00795 struct JackGetInternalClientNameResult : public JackResult
00796 {
00797
00798 char fName[JACK_CLIENT_NAME_SIZE + 1];
00799
00800 JackGetInternalClientNameResult(): JackResult()
00801 {}
00802 JackGetInternalClientNameResult(int32_t result, const char* name)
00803 : JackResult(result)
00804 {
00805 snprintf(fName, sizeof(fName), "%s", name);
00806 }
00807
00808 int Read(JackChannelTransaction* trans)
00809 {
00810 CheckRes(JackResult::Read(trans));
00811 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00812 return 0;
00813 }
00814
00815 int Write(JackChannelTransaction* trans)
00816 {
00817 CheckRes(JackResult::Write(trans));
00818 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00819 return 0;
00820 }
00821
00822 } POST_PACKED_STRUCTURE;
00823
00828 struct JackInternalClientHandleRequest : public JackRequest
00829 {
00830
00831 int fRefNum;
00832 char fName[JACK_CLIENT_NAME_SIZE + 1];
00833
00834 JackInternalClientHandleRequest()
00835 {}
00836 JackInternalClientHandleRequest(int refnum, const char* client_name)
00837 : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
00838 {
00839 snprintf(fName, sizeof(fName), "%s", client_name);
00840 }
00841
00842 int Read(JackChannelTransaction* trans)
00843 {
00844 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00845 return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
00846 }
00847
00848 int Write(JackChannelTransaction* trans)
00849 {
00850 CheckRes(JackRequest::Write(trans));
00851 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00852 return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
00853 }
00854
00855 } POST_PACKED_STRUCTURE;
00856
00861 struct JackInternalClientHandleResult : public JackResult
00862 {
00863
00864 int fStatus;
00865 int fIntRefNum;
00866
00867 JackInternalClientHandleResult(): JackResult()
00868 {}
00869 JackInternalClientHandleResult(int32_t result, int status, int int_ref)
00870 : JackResult(result), fStatus(status), fIntRefNum(int_ref)
00871 {}
00872
00873 int Read(JackChannelTransaction* trans)
00874 {
00875 CheckRes(JackResult::Read(trans));
00876 CheckRes(trans->Read(&fStatus, sizeof(int)));
00877 CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00878 return 0;
00879 }
00880
00881 int Write(JackChannelTransaction* trans)
00882 {
00883 CheckRes(JackResult::Write(trans));
00884 CheckRes(trans->Write(&fStatus, sizeof(int)));
00885 CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00886 return 0;
00887 }
00888
00889 } POST_PACKED_STRUCTURE;
00890
00895 struct JackInternalClientLoadRequest : public JackRequest
00896 {
00897
00898 #ifndef MAX_PATH
00899 #define MAX_PATH 256
00900 #endif
00901
00902 int fRefNum;
00903 char fName[JACK_CLIENT_NAME_SIZE + 1];
00904 char fDllName[MAX_PATH + 1];
00905 char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
00906 int fOptions;
00907
00908 JackInternalClientLoadRequest()
00909 {}
00910 JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options)
00911 : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options)
00912 {
00913 snprintf(fName, sizeof(fName), "%s", client_name);
00914 snprintf(fDllName, sizeof(fDllName), "%s", so_name);
00915 snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
00916 }
00917
00918 int Read(JackChannelTransaction* trans)
00919 {
00920 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00921 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
00922 CheckRes(trans->Read(&fDllName, MAX_PATH + 1));
00923 CheckRes(trans->Read(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
00924 return trans->Read(&fOptions, sizeof(int));
00925 }
00926
00927 int Write(JackChannelTransaction* trans)
00928 {
00929 CheckRes(JackRequest::Write(trans));
00930 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00931 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
00932 CheckRes(trans->Write(&fDllName, MAX_PATH + 1));
00933 CheckRes(trans->Write(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
00934 return trans->Write(&fOptions, sizeof(int));
00935 }
00936
00937 } POST_PACKED_STRUCTURE;
00938
00943 struct JackInternalClientLoadResult : public JackResult
00944 {
00945
00946 int fStatus;
00947 int fIntRefNum;
00948
00949 JackInternalClientLoadResult(): JackResult()
00950 {}
00951 JackInternalClientLoadResult(int32_t result, int status, int int_ref)
00952 : JackResult(result), fStatus(status), fIntRefNum(int_ref)
00953 {}
00954
00955 int Read(JackChannelTransaction* trans)
00956 {
00957 CheckRes(JackResult::Read(trans));
00958 CheckRes(trans->Read(&fStatus, sizeof(int)));
00959 CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00960 return 0;
00961 }
00962
00963 int Write(JackChannelTransaction* trans)
00964 {
00965 CheckRes(JackResult::Write(trans));
00966 CheckRes(trans->Write(&fStatus, sizeof(int)));
00967 CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00968 return 0;
00969 }
00970
00971 } POST_PACKED_STRUCTURE;
00972
00977 struct JackInternalClientUnloadRequest : public JackRequest
00978 {
00979
00980 int fRefNum;
00981 int fIntRefNum;
00982
00983 JackInternalClientUnloadRequest()
00984 {}
00985 JackInternalClientUnloadRequest(int refnum, int int_ref)
00986 : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
00987 {}
00988
00989 int Read(JackChannelTransaction* trans)
00990 {
00991 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00992 return trans->Read(&fIntRefNum, sizeof(int));
00993 }
00994
00995 int Write(JackChannelTransaction* trans)
00996 {
00997 CheckRes(JackRequest::Write(trans));
00998 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00999 return trans->Write(&fIntRefNum, sizeof(int));
01000 }
01001 } POST_PACKED_STRUCTURE;
01002
01007 struct JackInternalClientUnloadResult : public JackResult
01008 {
01009
01010 int fStatus;
01011
01012 JackInternalClientUnloadResult(): JackResult()
01013 {}
01014 JackInternalClientUnloadResult(int32_t result, int status)
01015 : JackResult(result), fStatus(status)
01016 {}
01017
01018 int Read(JackChannelTransaction* trans)
01019 {
01020 CheckRes(JackResult::Read(trans));
01021 CheckRes(trans->Read(&fStatus, sizeof(int)));
01022 return 0;
01023 }
01024
01025 int Write(JackChannelTransaction* trans)
01026 {
01027 CheckRes(JackResult::Write(trans));
01028 CheckRes(trans->Write(&fStatus, sizeof(int)));
01029 return 0;
01030 }
01031
01032 } POST_PACKED_STRUCTURE;
01033
01038 struct JackClientNotificationRequest : public JackRequest
01039 {
01040
01041 int fRefNum;
01042 int fNotify;
01043 int fValue;
01044
01045 JackClientNotificationRequest()
01046 {}
01047 JackClientNotificationRequest(int refnum, int notify, int value)
01048 : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
01049 {}
01050
01051 int Read(JackChannelTransaction* trans)
01052 {
01053 CheckRes(trans->Read(&fRefNum, sizeof(int)));
01054 CheckRes(trans->Read(&fNotify, sizeof(int)));
01055 CheckRes(trans->Read(&fValue, sizeof(int)));
01056 return 0;
01057 }
01058
01059 int Write(JackChannelTransaction* trans)
01060 {
01061 CheckRes(JackRequest::Write(trans));
01062 CheckRes(trans->Write(&fRefNum, sizeof(int)));
01063 CheckRes(trans->Write(&fNotify, sizeof(int)));
01064 CheckRes(trans->Write(&fValue, sizeof(int)));
01065 return 0;
01066 }
01067
01068 } POST_PACKED_STRUCTURE;
01069
01074 struct JackClientNotification
01075 {
01076 char fName[JACK_CLIENT_NAME_SIZE + 1];
01077 int fRefNum;
01078 int fNotify;
01079 int fValue1;
01080 int fValue2;
01081 int fSync;
01082
01083 JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)
01084 {}
01085 JackClientNotification(const char* name, int refnum, int notify, int sync, int value1, int value2)
01086 : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
01087 {
01088 snprintf(fName, sizeof(fName), "%s", name);
01089 }
01090
01091 int Read(JackChannelTransaction* trans)
01092 {
01093 CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
01094 CheckRes(trans->Read(&fRefNum, sizeof(int)));
01095 CheckRes(trans->Read(&fNotify, sizeof(int)));
01096 CheckRes(trans->Read(&fValue1, sizeof(int)));
01097 CheckRes(trans->Read(&fValue2, sizeof(int)));
01098 CheckRes(trans->Read(&fSync, sizeof(int)));
01099 return 0;
01100 }
01101
01102 int Write(JackChannelTransaction* trans)
01103 {
01104 CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
01105 CheckRes(trans->Write(&fRefNum, sizeof(int)));
01106 CheckRes(trans->Write(&fNotify, sizeof(int)));
01107 CheckRes(trans->Write(&fValue1, sizeof(int)));
01108 CheckRes(trans->Write(&fValue2, sizeof(int)));
01109 CheckRes(trans->Write(&fSync, sizeof(int)));
01110 return 0;
01111 }
01112
01113 } POST_PACKED_STRUCTURE;
01114
01115 }
01116
01117 #endif