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