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