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