Jack2
1.9.7
|
00001 /* 00002 Copyright (C) 2001 Paul Davis 00003 Copyright (C) 2004-2008 Grame 00004 00005 This program is free software; you can redistribute it and/or modify 00006 it under the terms of the GNU Lesser General Public License as published by 00007 the Free Software Foundation; either version 2.1 of the License, or 00008 (at your option) any later version. 00009 00010 This program is distributed in the hope that it will be useful, 00011 but WITHOUT ANY WARRANTY; without even the implied warranty of 00012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00013 GNU Lesser General Public License for more details. 00014 00015 You should have received a copy of the GNU Lesser General Public License 00016 along with this program; if not, write to the Free Software 00017 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 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 } // end of namespace 01475 01476 #endif