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