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 "JackTime.h"
00027 #include "types.h"
00028 #include <string.h>
00029 #include <stdio.h>
00030 #include <stdlib.h>
00031 #include <list>
00032
00033 namespace Jack
00034 {
00035
00036 #define CheckRes(exp) { if ((exp) < 0) return -1; }
00037
00042 enum JackSessionReply {
00043
00044 kImmediateSessionReply = 1,
00045 kPendingSessionReply = 2
00046
00047 };
00048
00053 struct JackRequest
00054 {
00055
00056 enum RequestType {
00057 kRegisterPort = 1,
00058 kUnRegisterPort = 2,
00059 kConnectPorts = 3,
00060 kDisconnectPorts = 4,
00061 kSetTimeBaseClient = 5,
00062 kActivateClient = 6,
00063 kDeactivateClient = 7,
00064 kDisconnectPort = 8,
00065 kSetClientCapabilities = 9,
00066 kGetPortConnections = 10,
00067 kGetPortNConnections = 11,
00068 kReleaseTimebase = 12,
00069 kSetTimebaseCallback = 13,
00070 kSetBufferSize = 20,
00071 kSetFreeWheel = 21,
00072 kClientCheck = 22,
00073 kClientOpen = 23,
00074 kClientClose = 24,
00075 kConnectNamePorts = 25,
00076 kDisconnectNamePorts = 26,
00077 kGetInternalClientName = 27,
00078 kInternalClientHandle = 28,
00079 kInternalClientLoad = 29,
00080 kInternalClientUnload = 30,
00081 kPortRename = 31,
00082 kNotification = 32,
00083 kSessionNotify = 33,
00084 kSessionReply = 34,
00085 kGetClientByUUID = 35,
00086 kReserveClientName = 36,
00087 kGetUUIDByClient = 37,
00088 kClientHasSessionCallback = 38,
00089 kComputeTotalLatencies = 39
00090 };
00091
00092 RequestType fType;
00093
00094 JackRequest(): fType((RequestType)0)
00095 {}
00096
00097 JackRequest(RequestType type): fType(type)
00098 {}
00099
00100 virtual ~JackRequest()
00101 {}
00102
00103 virtual int Read(JackChannelTransaction* trans)
00104 {
00105 return trans->Read(&fType, sizeof(RequestType));
00106 }
00107
00108 virtual int Write(JackChannelTransaction* trans)
00109 {
00110 return trans->Write(&fType, sizeof(RequestType));
00111 }
00112
00113 };
00114
00119 struct JackResult
00120 {
00121
00122 int fResult;
00123
00124 JackResult(): fResult( -1)
00125 {}
00126 JackResult(int result): fResult(result)
00127 {}
00128 virtual ~JackResult()
00129 {}
00130
00131 virtual int Read(JackChannelTransaction* trans)
00132 {
00133 return trans->Read(&fResult, sizeof(int));
00134 }
00135
00136 virtual int Write(JackChannelTransaction* trans)
00137 {
00138 return trans->Write(&fResult, sizeof(int));
00139 }
00140
00141 };
00142
00147 struct JackClientCheckRequest : public JackRequest
00148 {
00149
00150 char fName[JACK_CLIENT_NAME_SIZE + 1];
00151 int fProtocol;
00152 int fOptions;
00153 int fUUID;
00154 int fOpen;
00155
00156 JackClientCheckRequest()
00157 {}
00158 JackClientCheckRequest(const char* name, int protocol, int options, int uuid, int open = false)
00159 : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options), fUUID(uuid), fOpen(open)
00160 {
00161 snprintf(fName, sizeof(fName), "%s", name);
00162 }
00163
00164 int Read(JackChannelTransaction* trans)
00165 {
00166 CheckRes(trans->Read(&fName, sizeof(fName)));
00167 CheckRes(trans->Read(&fProtocol, sizeof(int)));
00168 CheckRes(trans->Read(&fOptions, sizeof(int)));
00169 CheckRes(trans->Read(&fUUID, sizeof(int)));
00170 return trans->Read(&fOpen, sizeof(int));
00171 }
00172
00173 int Write(JackChannelTransaction* trans)
00174 {
00175 CheckRes(JackRequest::Write(trans));
00176 CheckRes(trans->Write(&fName, sizeof(fName)));
00177 CheckRes(trans->Write(&fProtocol, sizeof(int)));
00178 CheckRes(trans->Write(&fOptions, sizeof(int)));
00179 CheckRes(trans->Write(&fUUID, sizeof(int)));
00180 return trans->Write(&fOpen, sizeof(int));
00181 }
00182
00183 };
00184
00189 struct JackClientCheckResult : public JackResult
00190 {
00191
00192 char fName[JACK_CLIENT_NAME_SIZE + 1];
00193 int fStatus;
00194
00195 JackClientCheckResult(): JackResult(), fStatus(0)
00196 {}
00197 JackClientCheckResult(int32_t result, const char* name, int status)
00198 : JackResult(result), fStatus(status)
00199 {
00200 snprintf(fName, sizeof(fName), "%s", name);
00201 }
00202
00203 int Read(JackChannelTransaction* trans)
00204 {
00205 CheckRes(JackResult::Read(trans));
00206 CheckRes(trans->Read(&fName, sizeof(fName)));
00207 CheckRes(trans->Read(&fStatus, sizeof(int)));
00208 return 0;
00209 }
00210
00211 int Write(JackChannelTransaction* trans)
00212 {
00213 CheckRes(JackResult::Write(trans));
00214 CheckRes(trans->Write(&fName, sizeof(fName)));
00215 CheckRes(trans->Write(&fStatus, sizeof(int)));
00216 return 0;
00217 }
00218
00219 };
00220
00225 struct JackClientOpenRequest : public JackRequest
00226 {
00227
00228 int fPID;
00229 int fUUID;
00230 char fName[JACK_CLIENT_NAME_SIZE + 1];
00231
00232 JackClientOpenRequest()
00233 {}
00234 JackClientOpenRequest(const char* name, int pid, int uuid): JackRequest(JackRequest::kClientOpen)
00235 {
00236 snprintf(fName, sizeof(fName), "%s", name);
00237 fPID = pid;
00238 fUUID = uuid;
00239 }
00240
00241 int Read(JackChannelTransaction* trans)
00242 {
00243 CheckRes(trans->Read(&fPID, sizeof(int)));
00244 CheckRes(trans->Read(&fUUID, sizeof(int)));
00245 return trans->Read(&fName, sizeof(fName));
00246 }
00247
00248 int Write(JackChannelTransaction* trans)
00249 {
00250 CheckRes(JackRequest::Write(trans));
00251 CheckRes(trans->Write(&fPID, sizeof(int)));
00252 CheckRes(trans->Write(&fUUID, sizeof(int)));
00253 return trans->Write(&fName, sizeof(fName));
00254 }
00255
00256 };
00257
00262 struct JackClientOpenResult : public JackResult
00263 {
00264
00265 int fSharedEngine;
00266 int fSharedClient;
00267 int fSharedGraph;
00268
00269 JackClientOpenResult()
00270 : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
00271 {}
00272 JackClientOpenResult(int32_t result, int index1, int index2, int index3)
00273 : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
00274 {}
00275
00276 int Read(JackChannelTransaction* trans)
00277 {
00278 CheckRes(JackResult::Read(trans));
00279 CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
00280 CheckRes(trans->Read(&fSharedClient, sizeof(int)));
00281 CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
00282 return 0;
00283 }
00284
00285 int Write(JackChannelTransaction* trans)
00286 {
00287 CheckRes(JackResult::Write(trans));
00288 CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
00289 CheckRes(trans->Write(&fSharedClient, sizeof(int)));
00290 CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
00291 return 0;
00292 }
00293
00294 };
00295
00300 struct JackClientCloseRequest : public JackRequest
00301 {
00302
00303 int fRefNum;
00304
00305 JackClientCloseRequest()
00306 {}
00307 JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
00308 {}
00309
00310 int Read(JackChannelTransaction* trans)
00311 {
00312 return trans->Read(&fRefNum, sizeof(int));
00313 }
00314
00315 int Write(JackChannelTransaction* trans)
00316 {
00317 CheckRes(JackRequest::Write(trans));
00318 return trans->Write(&fRefNum, sizeof(int));
00319 }
00320
00321 };
00322
00327 struct JackActivateRequest : public JackRequest
00328 {
00329
00330 int fRefNum;
00331 int fIsRealTime;
00332
00333 JackActivateRequest()
00334 {}
00335 JackActivateRequest(int refnum, int is_real_time)
00336 : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fIsRealTime(is_real_time)
00337 {}
00338
00339 int Read(JackChannelTransaction* trans)
00340 {
00341 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00342 return trans->Read(&fIsRealTime, sizeof(int));
00343 }
00344
00345 int Write(JackChannelTransaction* trans)
00346 {
00347 CheckRes(JackRequest::Write(trans));
00348 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00349 return trans->Write(&fIsRealTime, sizeof(int));
00350 }
00351
00352 };
00353
00358 struct JackDeactivateRequest : public JackRequest
00359 {
00360
00361 int fRefNum;
00362
00363 JackDeactivateRequest()
00364 {}
00365 JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
00366 {}
00367
00368 int Read(JackChannelTransaction* trans)
00369 {
00370 return trans->Read(&fRefNum, sizeof(int));
00371 }
00372
00373 int Write(JackChannelTransaction* trans)
00374 {
00375 CheckRes(JackRequest::Write(trans));
00376 return trans->Write(&fRefNum, sizeof(int));
00377 }
00378
00379 };
00380
00385 struct JackPortRegisterRequest : public JackRequest
00386 {
00387
00388 int fRefNum;
00389 char fName[JACK_PORT_NAME_SIZE + 1];
00390 char fPortType[JACK_PORT_TYPE_SIZE + 1];
00391 unsigned int fFlags;
00392 unsigned int fBufferSize;
00393
00394 JackPortRegisterRequest()
00395 {}
00396 JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
00397 : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
00398 {
00399 strcpy(fName, name);
00400 strcpy(fPortType, port_type);
00401 }
00402
00403 int Read(JackChannelTransaction* trans)
00404 {
00405 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00406 CheckRes(trans->Read(&fName, sizeof(fName)));
00407 CheckRes(trans->Read(&fPortType, sizeof(fPortType)));
00408 CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
00409 CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
00410 return 0;
00411 }
00412
00413 int Write(JackChannelTransaction* trans)
00414 {
00415 CheckRes(JackRequest::Write(trans));
00416 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00417 CheckRes(trans->Write(&fName, sizeof(fName)));
00418 CheckRes(trans->Write(&fPortType, sizeof(fPortType)));
00419 CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
00420 CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
00421 return 0;
00422 }
00423
00424 };
00425
00430 struct JackPortRegisterResult : public JackResult
00431 {
00432
00433 jack_port_id_t fPortIndex;
00434
00435 JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
00436 {}
00437
00438 int Read(JackChannelTransaction* trans)
00439 {
00440 CheckRes(JackResult::Read(trans));
00441 return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
00442 }
00443
00444 int Write(JackChannelTransaction* trans)
00445 {
00446 CheckRes(JackResult::Write(trans));
00447 return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
00448 }
00449
00450 };
00451
00456 struct JackPortUnRegisterRequest : public JackRequest
00457 {
00458
00459 int fRefNum;
00460 jack_port_id_t fPortIndex;
00461
00462 JackPortUnRegisterRequest()
00463 {}
00464 JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
00465 : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
00466 {}
00467
00468 int Read(JackChannelTransaction* trans)
00469 {
00470 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00471 CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
00472 return 0;
00473 }
00474
00475 int Write(JackChannelTransaction* trans)
00476 {
00477 CheckRes(JackRequest::Write(trans));
00478 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00479 CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
00480 return 0;
00481 }
00482
00483 };
00484
00489 struct JackPortConnectNameRequest : public JackRequest
00490 {
00491
00492 int fRefNum;
00493 char fSrc[JACK_PORT_NAME_SIZE + 1];
00494 char fDst[JACK_PORT_NAME_SIZE + 1];
00495
00496 JackPortConnectNameRequest()
00497 {}
00498 JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00499 : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
00500 {
00501 strcpy(fSrc, src_name);
00502 strcpy(fDst, dst_name);
00503 }
00504
00505 int Read(JackChannelTransaction* trans)
00506 {
00507 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00508 CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
00509 CheckRes(trans->Read(&fDst, sizeof(fDst)));
00510 return 0;
00511
00512 }
00513
00514 int Write(JackChannelTransaction* trans)
00515 {
00516 CheckRes(JackRequest::Write(trans));
00517 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00518 CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
00519 CheckRes(trans->Write(&fDst, sizeof(fDst)));
00520 return 0;
00521 }
00522
00523 };
00524
00529 struct JackPortDisconnectNameRequest : public JackRequest
00530 {
00531
00532 int fRefNum;
00533 char fSrc[JACK_PORT_NAME_SIZE + 1];
00534 char fDst[JACK_PORT_NAME_SIZE + 1];
00535
00536 JackPortDisconnectNameRequest()
00537 {}
00538 JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00539 : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
00540 {
00541 strcpy(fSrc, src_name);
00542 strcpy(fDst, dst_name);
00543 }
00544
00545 int Read(JackChannelTransaction* trans)
00546 {
00547 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00548 CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
00549 CheckRes(trans->Read(&fDst, sizeof(fDst)));
00550 return 0;
00551 }
00552
00553 int Write(JackChannelTransaction* trans)
00554 {
00555 CheckRes(JackRequest::Write(trans));
00556 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00557 CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
00558 CheckRes(trans->Write(&fDst, sizeof(fDst)));
00559 return 0;
00560 }
00561
00562 };
00563
00568 struct JackPortConnectRequest : public JackRequest
00569 {
00570
00571 int fRefNum;
00572 jack_port_id_t fSrc;
00573 jack_port_id_t fDst;
00574
00575 JackPortConnectRequest()
00576 {}
00577 JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00578 : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00579 {}
00580
00581 int Read(JackChannelTransaction* trans)
00582 {
00583 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00584 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00585 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00586 return 0;
00587 }
00588
00589 int Write(JackChannelTransaction* trans)
00590 {
00591 CheckRes(JackRequest::Write(trans));
00592 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00593 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00594 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00595 return 0;
00596 }
00597
00598 };
00599
00604 struct JackPortDisconnectRequest : public JackRequest
00605 {
00606
00607 int fRefNum;
00608 jack_port_id_t fSrc;
00609 jack_port_id_t fDst;
00610
00611 JackPortDisconnectRequest()
00612 {}
00613 JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00614 : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00615 {}
00616
00617 int Read(JackChannelTransaction* trans)
00618 {
00619 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00620 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00621 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00622 return 0;
00623 }
00624
00625 int Write(JackChannelTransaction* trans)
00626 {
00627 CheckRes(JackRequest::Write(trans));
00628 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00629 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00630 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00631 return 0;
00632 }
00633
00634 };
00635
00640 struct JackPortRenameRequest : public JackRequest
00641 {
00642
00643 int fRefNum;
00644 jack_port_id_t fPort;
00645 char fName[JACK_PORT_NAME_SIZE + 1];
00646
00647 JackPortRenameRequest()
00648 {}
00649 JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
00650 : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
00651 {
00652 strcpy(fName, name);
00653 }
00654
00655 int Read(JackChannelTransaction* trans)
00656 {
00657 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00658 CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
00659 CheckRes(trans->Read(&fName, sizeof(fName)));
00660 return 0;
00661 }
00662
00663 int Write(JackChannelTransaction* trans)
00664 {
00665 CheckRes(JackRequest::Write(trans));
00666 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00667 CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
00668 CheckRes(trans->Write(&fName, sizeof(fName)));
00669 return 0;
00670
00671 }
00672
00673 };
00674
00679 struct JackSetBufferSizeRequest : public JackRequest
00680 {
00681
00682 jack_nframes_t fBufferSize;
00683
00684 JackSetBufferSizeRequest()
00685 {}
00686 JackSetBufferSizeRequest(jack_nframes_t buffer_size)
00687 : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
00688 {}
00689
00690 int Read(JackChannelTransaction* trans)
00691 {
00692 return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
00693 }
00694
00695 int Write(JackChannelTransaction* trans)
00696 {
00697 CheckRes(JackRequest::Write(trans));
00698 return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
00699 }
00700
00701 };
00702
00707 struct JackSetFreeWheelRequest : public JackRequest
00708 {
00709
00710 int fOnOff;
00711
00712 JackSetFreeWheelRequest()
00713 {}
00714 JackSetFreeWheelRequest(int onoff)
00715 : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
00716 {}
00717
00718 int Read(JackChannelTransaction* trans)
00719 {
00720 return trans->Read(&fOnOff, sizeof(int));
00721 }
00722
00723 int Write(JackChannelTransaction* trans)
00724 {
00725 CheckRes(JackRequest::Write(trans));
00726 return trans->Write(&fOnOff, sizeof(int));
00727 }
00728
00729 };
00730
00735 struct JackComputeTotalLatenciesRequest : public JackRequest
00736 {
00737
00738 JackComputeTotalLatenciesRequest()
00739 : JackRequest(JackRequest::kComputeTotalLatencies)
00740 {}
00741
00742 int Read(JackChannelTransaction* trans)
00743 {
00744 return 0;
00745 }
00746
00747 int Write(JackChannelTransaction* trans)
00748 {
00749 CheckRes(JackRequest::Write(trans));
00750 return 0;
00751 }
00752
00753 };
00754
00759 struct JackReleaseTimebaseRequest : public JackRequest
00760 {
00761
00762 int fRefNum;
00763
00764 JackReleaseTimebaseRequest()
00765 {}
00766 JackReleaseTimebaseRequest(int refnum)
00767 : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
00768 {}
00769
00770 int Read(JackChannelTransaction* trans)
00771 {
00772 return trans->Read(&fRefNum, sizeof(int));
00773 }
00774
00775 int Write(JackChannelTransaction* trans)
00776 {
00777 CheckRes(JackRequest::Write(trans));
00778 return trans->Write(&fRefNum, sizeof(int));
00779 }
00780
00781 };
00782
00787 struct JackSetTimebaseCallbackRequest : public JackRequest
00788 {
00789
00790 int fRefNum;
00791 int fConditionnal;
00792
00793 JackSetTimebaseCallbackRequest()
00794 {}
00795 JackSetTimebaseCallbackRequest(int refnum, int conditional)
00796 : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
00797 {}
00798
00799 int Read(JackChannelTransaction* trans)
00800 {
00801 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00802 return trans->Read(&fConditionnal, sizeof(int));
00803 }
00804
00805 int Write(JackChannelTransaction* trans)
00806 {
00807 CheckRes(JackRequest::Write(trans));
00808 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00809 return trans->Write(&fConditionnal, sizeof(int));
00810 }
00811
00812 };
00813
00818 struct JackGetInternalClientNameRequest : public JackRequest
00819 {
00820
00821 int fRefNum;
00822 int fIntRefNum;
00823
00824 JackGetInternalClientNameRequest()
00825 {}
00826 JackGetInternalClientNameRequest(int refnum, int int_ref)
00827 : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
00828 {}
00829
00830 int Read(JackChannelTransaction* trans)
00831 {
00832 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00833 return trans->Read(&fIntRefNum, sizeof(int));
00834 }
00835
00836 int Write(JackChannelTransaction* trans)
00837 {
00838 CheckRes(JackRequest::Write(trans));
00839 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00840 return trans->Write(&fIntRefNum, sizeof(int));
00841 }
00842
00843 };
00844
00849 struct JackGetInternalClientNameResult : public JackResult
00850 {
00851
00852 char fName[JACK_CLIENT_NAME_SIZE + 1];
00853
00854 JackGetInternalClientNameResult(): JackResult()
00855 {}
00856 JackGetInternalClientNameResult(int32_t result, const char* name)
00857 : JackResult(result)
00858 {
00859 snprintf(fName, sizeof(fName), "%s", name);
00860 }
00861
00862 int Read(JackChannelTransaction* trans)
00863 {
00864 CheckRes(JackResult::Read(trans));
00865 CheckRes(trans->Read(&fName, sizeof(fName)));
00866 return 0;
00867 }
00868
00869 int Write(JackChannelTransaction* trans)
00870 {
00871 CheckRes(JackResult::Write(trans));
00872 CheckRes(trans->Write(&fName, sizeof(fName)));
00873 return 0;
00874 }
00875
00876 };
00877
00882 struct JackInternalClientHandleRequest : public JackRequest
00883 {
00884
00885 int fRefNum;
00886 char fName[JACK_CLIENT_NAME_SIZE + 1];
00887
00888 JackInternalClientHandleRequest()
00889 {}
00890 JackInternalClientHandleRequest(int refnum, const char* client_name)
00891 : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
00892 {
00893 snprintf(fName, sizeof(fName), "%s", client_name);
00894 }
00895
00896 int Read(JackChannelTransaction* trans)
00897 {
00898 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00899 return trans->Read(&fName, sizeof(fName));
00900 }
00901
00902 int Write(JackChannelTransaction* trans)
00903 {
00904 CheckRes(JackRequest::Write(trans));
00905 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00906 return trans->Write(&fName, sizeof(fName));
00907 }
00908
00909 };
00910
00915 struct JackInternalClientHandleResult : public JackResult
00916 {
00917
00918 int fStatus;
00919 int fIntRefNum;
00920
00921 JackInternalClientHandleResult(): JackResult()
00922 {}
00923 JackInternalClientHandleResult(int32_t result, int status, int int_ref)
00924 : JackResult(result), fStatus(status), fIntRefNum(int_ref)
00925 {}
00926
00927 int Read(JackChannelTransaction* trans)
00928 {
00929 CheckRes(JackResult::Read(trans));
00930 CheckRes(trans->Read(&fStatus, sizeof(int)));
00931 CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00932 return 0;
00933 }
00934
00935 int Write(JackChannelTransaction* trans)
00936 {
00937 CheckRes(JackResult::Write(trans));
00938 CheckRes(trans->Write(&fStatus, sizeof(int)));
00939 CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00940 return 0;
00941 }
00942
00943 };
00944
00949 struct JackInternalClientLoadRequest : public JackRequest
00950 {
00951
00952 #ifndef MAX_PATH
00953 #define MAX_PATH 256
00954 #endif
00955
00956 int fRefNum;
00957 char fName[JACK_CLIENT_NAME_SIZE + 1];
00958 char fDllName[MAX_PATH + 1];
00959 char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
00960 int fOptions;
00961 int fUUID;
00962
00963 JackInternalClientLoadRequest()
00964 {}
00965 JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int uuid )
00966 : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options), fUUID(uuid)
00967 {
00968 snprintf(fName, sizeof(fName), "%s", client_name);
00969 snprintf(fDllName, sizeof(fDllName), "%s", so_name);
00970 snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
00971 snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
00972 }
00973
00974 int Read(JackChannelTransaction* trans)
00975 {
00976 CheckRes(trans->Read(&fRefNum, sizeof(int)));
00977 CheckRes(trans->Read(&fName, sizeof(fName)));
00978 CheckRes(trans->Read(&fDllName, sizeof(fDllName)));
00979 CheckRes(trans->Read(&fLoadInitName, sizeof(fLoadInitName)));
00980 CheckRes(trans->Read(&fUUID, sizeof(int)));
00981 return trans->Read(&fOptions, sizeof(int));
00982 }
00983
00984 int Write(JackChannelTransaction* trans)
00985 {
00986 CheckRes(JackRequest::Write(trans));
00987 CheckRes(trans->Write(&fRefNum, sizeof(int)));
00988 CheckRes(trans->Write(&fName, sizeof(fName)));
00989 CheckRes(trans->Write(&fDllName, sizeof(fDllName)));
00990 CheckRes(trans->Write(&fLoadInitName, sizeof(fLoadInitName)));
00991 CheckRes(trans->Write(&fUUID, sizeof(int)));
00992 return trans->Write(&fOptions, sizeof(int));
00993 }
00994
00995 };
00996
01001 struct JackInternalClientLoadResult : public JackResult
01002 {
01003
01004 int fStatus;
01005 int fIntRefNum;
01006
01007 JackInternalClientLoadResult(): JackResult()
01008 {}
01009 JackInternalClientLoadResult(int32_t result, int status, int int_ref)
01010 : JackResult(result), fStatus(status), fIntRefNum(int_ref)
01011 {}
01012
01013 int Read(JackChannelTransaction* trans)
01014 {
01015 CheckRes(JackResult::Read(trans));
01016 CheckRes(trans->Read(&fStatus, sizeof(int)));
01017 CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
01018 return 0;
01019 }
01020
01021 int Write(JackChannelTransaction* trans)
01022 {
01023 CheckRes(JackResult::Write(trans));
01024 CheckRes(trans->Write(&fStatus, sizeof(int)));
01025 CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
01026 return 0;
01027 }
01028
01029 };
01030
01035 struct JackInternalClientUnloadRequest : public JackRequest
01036 {
01037
01038 int fRefNum;
01039 int fIntRefNum;
01040
01041 JackInternalClientUnloadRequest()
01042 {}
01043 JackInternalClientUnloadRequest(int refnum, int int_ref)
01044 : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
01045 {}
01046
01047 int Read(JackChannelTransaction* trans)
01048 {
01049 CheckRes(trans->Read(&fRefNum, sizeof(int)));
01050 return trans->Read(&fIntRefNum, sizeof(int));
01051 }
01052
01053 int Write(JackChannelTransaction* trans)
01054 {
01055 CheckRes(JackRequest::Write(trans));
01056 CheckRes(trans->Write(&fRefNum, sizeof(int)));
01057 return trans->Write(&fIntRefNum, sizeof(int));
01058 }
01059 };
01060
01065 struct JackInternalClientUnloadResult : public JackResult
01066 {
01067
01068 int fStatus;
01069
01070 JackInternalClientUnloadResult(): JackResult()
01071 {}
01072 JackInternalClientUnloadResult(int32_t result, int status)
01073 : JackResult(result), fStatus(status)
01074 {}
01075
01076 int Read(JackChannelTransaction* trans)
01077 {
01078 CheckRes(JackResult::Read(trans));
01079 CheckRes(trans->Read(&fStatus, sizeof(int)));
01080 return 0;
01081 }
01082
01083 int Write(JackChannelTransaction* trans)
01084 {
01085 CheckRes(JackResult::Write(trans));
01086 CheckRes(trans->Write(&fStatus, sizeof(int)));
01087 return 0;
01088 }
01089
01090 };
01091
01096 struct JackClientNotificationRequest : public JackRequest
01097 {
01098
01099 int fRefNum;
01100 int fNotify;
01101 int fValue;
01102
01103 JackClientNotificationRequest()
01104 {}
01105 JackClientNotificationRequest(int refnum, int notify, int value)
01106 : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
01107 {}
01108
01109 int Read(JackChannelTransaction* trans)
01110 {
01111 CheckRes(trans->Read(&fRefNum, sizeof(int)));
01112 CheckRes(trans->Read(&fNotify, sizeof(int)));
01113 CheckRes(trans->Read(&fValue, sizeof(int)));
01114 return 0;
01115 }
01116
01117 int Write(JackChannelTransaction* trans)
01118 {
01119 CheckRes(JackRequest::Write(trans));
01120 CheckRes(trans->Write(&fRefNum, sizeof(int)));
01121 CheckRes(trans->Write(&fNotify, sizeof(int)));
01122 CheckRes(trans->Write(&fValue, sizeof(int)));
01123 return 0;
01124 }
01125
01126 };
01127
01128 struct JackSessionCommand
01129 {
01130 char fUUID[JACK_UUID_SIZE];
01131 char fClientName[JACK_CLIENT_NAME_SIZE+1];
01132 char fCommand[JACK_SESSION_COMMAND_SIZE];
01133 jack_session_flags_t fFlags;
01134
01135 JackSessionCommand()
01136 {}
01137
01138 JackSessionCommand(const char *uuid, const char *clientname, const char *command, jack_session_flags_t flags)
01139 {
01140 strncpy(fUUID, uuid, sizeof(fUUID));
01141 strncpy(fClientName, clientname, sizeof(fClientName));
01142 strncpy(fCommand, command, sizeof(fCommand));
01143 fFlags = flags;
01144 }
01145 };
01146
01147 struct JackSessionNotifyResult : public JackResult
01148 {
01149
01150 std::list<JackSessionCommand> fCommandList;
01151 bool fDone;
01152
01153 JackSessionNotifyResult(): JackResult(), fDone(false)
01154 {}
01155 JackSessionNotifyResult(int32_t result)
01156 : JackResult(result), fDone(false)
01157 {}
01158
01159 int Read(JackChannelTransaction* trans)
01160 {
01161 if (trans == NULL)
01162 {
01163 return 0;
01164 }
01165
01166 CheckRes(JackResult::Read(trans));
01167 while (true) {
01168 JackSessionCommand buffer;
01169
01170 CheckRes(trans->Read(buffer.fUUID, sizeof(buffer.fUUID)));
01171 if (buffer.fUUID[0] == '\0')
01172 break;
01173
01174 CheckRes(trans->Read(buffer.fClientName, sizeof(buffer.fClientName)));
01175 CheckRes(trans->Read(buffer.fCommand, sizeof(buffer.fCommand)));
01176 CheckRes(trans->Read(&(buffer.fFlags), sizeof(buffer.fFlags)));
01177
01178 fCommandList.push_back(buffer);
01179 }
01180
01181 fDone = true;
01182
01183 return 0;
01184 }
01185
01186 int Write(JackChannelTransaction* trans)
01187 {
01188 if (trans == NULL)
01189 {
01190 fDone = true;
01191 return 0;
01192 }
01193
01194 char terminator[JACK_UUID_SIZE];
01195 terminator[0] = '\0';
01196
01197 CheckRes(JackResult::Write(trans));
01198 for (std::list<JackSessionCommand>::iterator i = fCommandList.begin(); i != fCommandList.end(); i++) {
01199 CheckRes(trans->Write(i->fUUID, sizeof(i->fUUID)));
01200 CheckRes(trans->Write(i->fClientName, sizeof(i->fClientName)));
01201 CheckRes(trans->Write(i->fCommand, sizeof(i->fCommand)));
01202 CheckRes(trans->Write(&(i->fFlags), sizeof(i->fFlags)));
01203 }
01204 CheckRes(trans->Write(terminator, sizeof(terminator)));
01205 return 0;
01206 }
01207
01208 jack_session_command_t* GetCommands()
01209 {
01210
01211 while (!fDone)
01212 {
01213 JackSleep(50000);
01214 }
01215
01216 jack_session_command_t* session_command = (jack_session_command_t *)malloc(sizeof(jack_session_command_t) * (fCommandList.size() + 1));
01217 int i = 0;
01218
01219 for (std::list<JackSessionCommand>::iterator ci = fCommandList.begin(); ci != fCommandList.end(); ci++) {
01220 session_command[i].uuid = strdup(ci->fUUID);
01221 session_command[i].client_name = strdup(ci->fClientName);
01222 session_command[i].command = strdup(ci->fCommand);
01223 session_command[i].flags = ci->fFlags;
01224 i += 1;
01225 }
01226
01227 session_command[i].uuid = NULL;
01228 session_command[i].client_name = NULL;
01229 session_command[i].command = NULL;
01230 session_command[i].flags = (jack_session_flags_t)0;
01231
01232 return session_command;
01233 }
01234 };
01235
01240 struct JackSessionNotifyRequest : public JackRequest
01241 {
01242 char fPath[JACK_MESSAGE_SIZE + 1];
01243 char fDst[JACK_CLIENT_NAME_SIZE + 1];
01244 jack_session_event_type_t fEventType;
01245 int fRefNum;
01246
01247 JackSessionNotifyRequest()
01248 {}
01249 JackSessionNotifyRequest(int refnum, const char* path, jack_session_event_type_t type, const char* dst)
01250 : JackRequest(JackRequest::kSessionNotify), fEventType(type), fRefNum(refnum)
01251 {
01252 snprintf(fPath, sizeof(fPath), "%s", path);
01253 if (dst) {
01254 snprintf(fDst, sizeof(fDst), "%s", dst);
01255 } else {
01256 fDst[0] = '\0';
01257 }
01258 }
01259
01260 int Read(JackChannelTransaction* trans)
01261 {
01262 CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
01263 CheckRes(trans->Read(&fPath, sizeof(fPath)));
01264 CheckRes(trans->Read(&fDst, sizeof(fDst)));
01265 CheckRes(trans->Read(&fEventType, sizeof(fEventType)));
01266 return 0;
01267 }
01268
01269 int Write(JackChannelTransaction* trans)
01270 {
01271 CheckRes(JackRequest::Write(trans));
01272 CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
01273 CheckRes(trans->Write(&fPath, sizeof(fPath)));
01274 CheckRes(trans->Write(&fDst, sizeof(fDst)));
01275 CheckRes(trans->Write(&fEventType, sizeof(fEventType)));
01276 return 0;
01277 }
01278
01279 };
01280
01281 struct JackSessionReplyRequest : public JackRequest
01282 {
01283 int fRefNum;
01284
01285 JackSessionReplyRequest()
01286 {}
01287
01288 JackSessionReplyRequest(int refnum)
01289 : JackRequest(JackRequest::kSessionReply), fRefNum(refnum)
01290 {}
01291
01292 int Read(JackChannelTransaction* trans)
01293 {
01294 CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
01295 return 0;
01296 }
01297
01298 int Write(JackChannelTransaction* trans)
01299 {
01300 CheckRes(JackRequest::Write(trans));
01301 CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
01302 return 0;
01303 }
01304
01305 };
01306
01307 struct JackClientNameResult : public JackResult
01308 {
01309 char fName[JACK_CLIENT_NAME_SIZE + 1];
01310
01311 JackClientNameResult(): JackResult()
01312 {}
01313 JackClientNameResult(int32_t result, const char* name)
01314 : JackResult(result)
01315 {
01316 snprintf(fName, sizeof(fName), "%s", name);
01317 }
01318
01319 int Read(JackChannelTransaction* trans)
01320 {
01321 CheckRes(JackResult::Read(trans));
01322 CheckRes(trans->Read(&fName, sizeof(fName)));
01323 return 0;
01324 }
01325
01326 int Write(JackChannelTransaction* trans)
01327 {
01328 CheckRes(JackResult::Write(trans));
01329 CheckRes(trans->Write(&fName, sizeof(fName)));
01330 return 0;
01331 }
01332
01333 };
01334
01335 struct JackUUIDResult : public JackResult
01336 {
01337 char fUUID[JACK_UUID_SIZE];
01338
01339 JackUUIDResult(): JackResult()
01340 {}
01341 JackUUIDResult(int32_t result, const char* uuid)
01342 : JackResult(result)
01343 {
01344 snprintf(fUUID, sizeof(fUUID), "%s", uuid);
01345 }
01346
01347 int Read(JackChannelTransaction* trans)
01348 {
01349 CheckRes(JackResult::Read(trans));
01350 CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
01351 return 0;
01352 }
01353
01354 int Write(JackChannelTransaction* trans)
01355 {
01356 CheckRes(JackResult::Write(trans));
01357 CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
01358 return 0;
01359 }
01360
01361 };
01362
01363 struct JackGetUUIDRequest : public JackRequest
01364 {
01365 char fName[JACK_CLIENT_NAME_SIZE + 1];
01366
01367 JackGetUUIDRequest()
01368 {}
01369
01370 JackGetUUIDRequest(const char* client_name)
01371 : JackRequest(JackRequest::kGetUUIDByClient)
01372 {
01373 strncpy(fName, client_name, sizeof(fName));
01374 }
01375
01376 int Read(JackChannelTransaction* trans)
01377 {
01378 CheckRes(trans->Read(&fName, sizeof(fName)));
01379 return 0;
01380 }
01381
01382 int Write(JackChannelTransaction* trans)
01383 {
01384 CheckRes(JackRequest::Write(trans));
01385 CheckRes(trans->Write(&fName, sizeof(fName)));
01386 return 0;
01387 }
01388
01389 };
01390
01391 struct JackGetClientNameRequest : public JackRequest
01392 {
01393 char fUUID[JACK_UUID_SIZE];
01394
01395 JackGetClientNameRequest()
01396 {}
01397
01398 JackGetClientNameRequest(const char* uuid)
01399 : JackRequest(JackRequest::kGetClientByUUID)
01400 {
01401 strncpy(fUUID, uuid, sizeof(fUUID));
01402 }
01403
01404 int Read(JackChannelTransaction* trans)
01405 {
01406 CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
01407 return 0;
01408 }
01409
01410 int Write(JackChannelTransaction* trans)
01411 {
01412 CheckRes(JackRequest::Write(trans));
01413 CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
01414 return 0;
01415 }
01416
01417 };
01418
01419 struct JackReserveNameRequest : public JackRequest
01420 {
01421 int fRefNum;
01422 char fName[JACK_CLIENT_NAME_SIZE + 1];
01423 char fUUID[JACK_UUID_SIZE];
01424
01425 JackReserveNameRequest()
01426 {}
01427
01428 JackReserveNameRequest(int refnum, const char *name, const char* uuid)
01429 : JackRequest(JackRequest::kReserveClientName), fRefNum(refnum)
01430 {
01431 strncpy(fName, name, sizeof(fName));
01432 strncpy(fUUID, uuid, sizeof(fUUID));
01433 }
01434
01435 int Read(JackChannelTransaction* trans)
01436 {
01437 CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
01438 CheckRes(trans->Read(&fName, sizeof(fName)));
01439 CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
01440 return 0;
01441 }
01442
01443 int Write(JackChannelTransaction* trans)
01444 {
01445 CheckRes(JackRequest::Write(trans));
01446 CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
01447 CheckRes(trans->Write(&fName, sizeof(fName)));
01448 CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
01449 return 0;
01450 }
01451
01452 };
01453
01454 struct JackClientHasSessionCallbackRequest : public JackRequest
01455 {
01456 char fName[JACK_CLIENT_NAME_SIZE + 1];
01457
01458 JackClientHasSessionCallbackRequest()
01459 {}
01460
01461 JackClientHasSessionCallbackRequest(const char *name)
01462 : JackRequest(JackRequest::kClientHasSessionCallback)
01463 {
01464 strncpy(fName, name, sizeof(fName));
01465 }
01466
01467 int Read(JackChannelTransaction* trans)
01468 {
01469 CheckRes(trans->Read(&fName, sizeof(fName)));
01470 return 0;
01471 }
01472
01473 int Write(JackChannelTransaction* trans)
01474 {
01475 CheckRes(JackRequest::Write(trans));
01476 CheckRes(trans->Write(&fName, sizeof(fName)));
01477 return 0;
01478 }
01479
01480 };
01481
01486 struct JackClientNotification
01487 {
01488 char fName[JACK_CLIENT_NAME_SIZE + 1];
01489 int fRefNum;
01490 int fNotify;
01491 int fValue1;
01492 int fValue2;
01493 int fSync;
01494 char fMessage[JACK_MESSAGE_SIZE + 1];
01495
01496 JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)
01497 {}
01498 JackClientNotification(const char* name, int refnum, int notify, int sync, const char* message, int value1, int value2)
01499 : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
01500 {
01501 snprintf(fName, sizeof(fName), "%s", name);
01502 snprintf(fMessage, sizeof(fMessage), "%s", message);
01503 }
01504
01505 int Read(JackChannelTransaction* trans)
01506 {
01507 CheckRes(trans->Read(&fName, sizeof(fName)));
01508 CheckRes(trans->Read(&fRefNum, sizeof(int)));
01509 CheckRes(trans->Read(&fNotify, sizeof(int)));
01510 CheckRes(trans->Read(&fValue1, sizeof(int)));
01511 CheckRes(trans->Read(&fValue2, sizeof(int)));
01512 CheckRes(trans->Read(&fSync, sizeof(int)));
01513 CheckRes(trans->Read(&fMessage, sizeof(fMessage)));
01514 return 0;
01515 }
01516
01517 int Write(JackChannelTransaction* trans)
01518 {
01519 CheckRes(trans->Write(&fName, sizeof(fName)));
01520 CheckRes(trans->Write(&fRefNum, sizeof(int)));
01521 CheckRes(trans->Write(&fNotify, sizeof(int)));
01522 CheckRes(trans->Write(&fValue1, sizeof(int)));
01523 CheckRes(trans->Write(&fValue2, sizeof(int)));
01524 CheckRes(trans->Write(&fSync, sizeof(int)));
01525 CheckRes(trans->Write(&fMessage, sizeof(fMessage)));
01526 return 0;
01527 }
01528
01529 };
01530
01531 }
01532
01533 #endif