Merge branch 'master' into develop
[jack2.git] / common / JackRequest.h
bloba1ede642c43229888fba280f23271cc3014b20cc
1 /*
2 Copyright (C) 2001 Paul Davis
3 Copyright (C) 2004-2008 Grame
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published by
7 the Free Software Foundation; either version 2.1 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 #ifndef __JackRequest__
22 #define __JackRequest__
24 #include "JackConstants.h"
25 #include "JackError.h"
26 #include "JackPlatformPlug.h"
27 #include "JackChannel.h"
28 #include "JackTime.h"
29 #include "types.h"
30 #include <string.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <list>
35 namespace Jack
38 #define CheckRes(exp) { if ((exp) < 0) { jack_error("CheckRes error"); return -1; } }
39 #define CheckSize() { CheckRes(trans->Read(&fSize, sizeof(int))); if (fSize != Size()) { jack_error("CheckSize error size = %d Size() = %d", fSize, Size()); return -1; } }
41 /*!
42 \brief Session API constants.
45 enum JackSessionReply {
47 kImmediateSessionReply = 1,
48 kPendingSessionReply = 2
52 /*!
53 \brief Request from client to server.
56 struct JackRequest
59 enum RequestType {
60 kRegisterPort = 1,
61 kUnRegisterPort = 2,
62 kConnectPorts = 3,
63 kDisconnectPorts = 4,
64 kSetTimeBaseClient = 5,
65 kActivateClient = 6,
66 kDeactivateClient = 7,
67 kDisconnectPort = 8,
68 kSetClientCapabilities = 9,
69 kGetPortConnections = 10,
70 kGetPortNConnections = 11,
71 kReleaseTimebase = 12,
72 kSetTimebaseCallback = 13,
73 kSetBufferSize = 20,
74 kSetFreeWheel = 21,
75 kClientCheck = 22,
76 kClientOpen = 23,
77 kClientClose = 24,
78 kConnectNamePorts = 25,
79 kDisconnectNamePorts = 26,
80 kGetInternalClientName = 27,
81 kInternalClientHandle = 28,
82 kInternalClientLoad = 29,
83 kInternalClientUnload = 30,
84 kPortRename = 31,
85 kNotification = 32,
86 kSessionNotify = 33,
87 kSessionReply = 34,
88 kGetClientByUUID = 35,
89 kReserveClientName = 36,
90 kGetUUIDByClient = 37,
91 kClientHasSessionCallback = 38,
92 kComputeTotalLatencies = 39,
93 kPropertyChangeNotify = 40
96 RequestType fType;
97 int fSize;
99 JackRequest(): fType((RequestType)0), fSize(0)
102 JackRequest(RequestType type): fType(type), fSize(0)
105 virtual ~JackRequest()
108 virtual int Read(detail::JackChannelTransactionInterface* trans)
110 return trans->Read(&fType, sizeof(RequestType));
113 virtual int Write(detail::JackChannelTransactionInterface* trans) { return -1; }
115 virtual int Write(detail::JackChannelTransactionInterface* trans, int size)
117 fSize = size;
118 CheckRes(trans->Write(&fType, sizeof(RequestType)));
119 return trans->Write(&fSize, sizeof(int));
122 virtual int Size() { return 0; }
127 \brief Result from the server.
130 struct JackResult
133 int fResult;
135 JackResult(): fResult( -1)
137 JackResult(int result): fResult(result)
139 virtual ~JackResult()
142 virtual int Read(detail::JackChannelTransactionInterface* trans)
144 return trans->Read(&fResult, sizeof(int));
147 virtual int Write(detail::JackChannelTransactionInterface* trans)
149 return trans->Write(&fResult, sizeof(int));
155 \brief CheckClient request.
158 struct JackClientCheckRequest : public JackRequest
161 char fName[JACK_CLIENT_NAME_SIZE+1];
162 int fProtocol;
163 int fOptions;
164 int fOpen;
165 jack_uuid_t fUUID;
167 JackClientCheckRequest() : fProtocol(0), fOptions(0), fOpen(0), fUUID(JACK_UUID_EMPTY_INITIALIZER)
169 memset(fName, 0, sizeof(fName));
171 JackClientCheckRequest(const char* name, int protocol, int options, jack_uuid_t uuid, int open = false)
172 : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options), fOpen(open), fUUID(uuid)
174 memset(fName, 0, sizeof(fName));
175 snprintf(fName, sizeof(fName), "%s", name);
178 int Read(detail::JackChannelTransactionInterface* trans)
180 CheckSize();
181 CheckRes(trans->Read(&fName, sizeof(fName)));
182 CheckRes(trans->Read(&fProtocol, sizeof(int)));
183 CheckRes(trans->Read(&fOptions, sizeof(int)));
184 CheckRes(trans->Read(&fUUID, sizeof(jack_uuid_t)));
185 return trans->Read(&fOpen, sizeof(int));
188 int Write(detail::JackChannelTransactionInterface* trans)
190 CheckRes(JackRequest::Write(trans, Size()));
191 CheckRes(trans->Write(&fName, sizeof(fName)));
192 CheckRes(trans->Write(&fProtocol, sizeof(int)));
193 CheckRes(trans->Write(&fOptions, sizeof(int)));
194 CheckRes(trans->Write(&fUUID, sizeof(jack_uuid_t)));
195 return trans->Write(&fOpen, sizeof(int));
198 int Size() { return sizeof(fName) + 3 * sizeof(int) + sizeof(jack_uuid_t); }
203 \brief CheckClient result.
206 struct JackClientCheckResult : public JackResult
209 char fName[JACK_CLIENT_NAME_SIZE+1];
210 int fStatus;
212 JackClientCheckResult(): JackResult(), fStatus(0)
214 memset(fName, 0, sizeof(fName));
216 JackClientCheckResult(int32_t result, const char* name, int status)
217 : JackResult(result), fStatus(status)
219 memset(fName, 0, sizeof(fName));
220 snprintf(fName, sizeof(fName), "%s", name);
223 int Read(detail::JackChannelTransactionInterface* trans)
225 CheckRes(JackResult::Read(trans));
226 CheckRes(trans->Read(&fName, sizeof(fName)));
227 CheckRes(trans->Read(&fStatus, sizeof(int)));
228 return 0;
231 int Write(detail::JackChannelTransactionInterface* trans)
233 CheckRes(JackResult::Write(trans));
234 CheckRes(trans->Write(&fName, sizeof(fName)));
235 CheckRes(trans->Write(&fStatus, sizeof(int)));
236 return 0;
242 \brief NewClient request.
245 struct JackClientOpenRequest : public JackRequest
248 int fPID;
249 jack_uuid_t fUUID;
250 char fName[JACK_CLIENT_NAME_SIZE+1];
252 JackClientOpenRequest() : fPID(0), fUUID(JACK_UUID_EMPTY_INITIALIZER)
254 memset(fName, 0, sizeof(fName));
256 JackClientOpenRequest(const char* name, int pid, jack_uuid_t uuid): JackRequest(JackRequest::kClientOpen)
258 memset(fName, 0, sizeof(fName));
259 snprintf(fName, sizeof(fName), "%s", name);
260 fPID = pid;
261 fUUID = uuid;
264 int Read(detail::JackChannelTransactionInterface* trans)
266 CheckSize();
267 CheckRes(trans->Read(&fPID, sizeof(int)));
268 CheckRes(trans->Read(&fUUID, sizeof(jack_uuid_t)));
269 return trans->Read(&fName, sizeof(fName));
272 int Write(detail::JackChannelTransactionInterface* trans)
274 CheckRes(JackRequest::Write(trans, Size()));
275 CheckRes(trans->Write(&fPID, sizeof(int)));
276 CheckRes(trans->Write(&fUUID, sizeof(jack_uuid_t)));
277 return trans->Write(&fName, sizeof(fName));
280 int Size() { return sizeof(int) + sizeof(jack_uuid_t) + sizeof(fName); }
285 \brief NewClient result.
288 struct JackClientOpenResult : public JackResult
291 int fSharedEngine;
292 int fSharedClient;
293 int fSharedGraph;
295 JackClientOpenResult()
296 : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
298 JackClientOpenResult(int32_t result, int index1, int index2, int index3)
299 : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
302 int Read(detail::JackChannelTransactionInterface* trans)
304 CheckRes(JackResult::Read(trans));
305 CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
306 CheckRes(trans->Read(&fSharedClient, sizeof(int)));
307 CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
308 return 0;
311 int Write(detail::JackChannelTransactionInterface* trans)
313 CheckRes(JackResult::Write(trans));
314 CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
315 CheckRes(trans->Write(&fSharedClient, sizeof(int)));
316 CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
317 return 0;
323 \brief CloseClient request.
326 struct JackClientCloseRequest : public JackRequest
329 int fRefNum;
331 JackClientCloseRequest() : fRefNum(0)
333 JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
336 int Read(detail::JackChannelTransactionInterface* trans)
338 CheckSize();
339 return trans->Read(&fRefNum, sizeof(int));
342 int Write(detail::JackChannelTransactionInterface* trans)
344 CheckRes(JackRequest::Write(trans, Size()));
345 return trans->Write(&fRefNum, sizeof(int));
348 int Size() { return sizeof(int); }
352 \brief Activate request.
355 struct JackActivateRequest : public JackRequest
358 int fRefNum;
359 int fIsRealTime;
361 JackActivateRequest() : fRefNum(0), fIsRealTime(0)
363 JackActivateRequest(int refnum, int is_real_time)
364 : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fIsRealTime(is_real_time)
367 int Read(detail::JackChannelTransactionInterface* trans)
369 CheckSize();
370 CheckRes(trans->Read(&fRefNum, sizeof(int)));
371 return trans->Read(&fIsRealTime, sizeof(int));
374 int Write(detail::JackChannelTransactionInterface* trans)
376 CheckRes(JackRequest::Write(trans, Size()));
377 CheckRes(trans->Write(&fRefNum, sizeof(int)));
378 return trans->Write(&fIsRealTime, sizeof(int));
381 int Size() { return 2 * sizeof(int); }
385 \brief Deactivate request.
388 struct JackDeactivateRequest : public JackRequest
391 int fRefNum;
393 JackDeactivateRequest() : fRefNum(0)
395 JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
398 int Read(detail::JackChannelTransactionInterface* trans)
400 CheckSize();
401 return trans->Read(&fRefNum, sizeof(int));
404 int Write(detail::JackChannelTransactionInterface* trans)
406 CheckRes(JackRequest::Write(trans, Size()));
407 return trans->Write(&fRefNum, sizeof(int));
410 int Size() { return sizeof(int); }
414 \brief PortRegister request.
417 struct JackPortRegisterRequest : public JackRequest
420 int fRefNum;
421 char fName[JACK_PORT_NAME_SIZE + 1]; // port short name
422 char fPortType[JACK_PORT_TYPE_SIZE + 1];
423 unsigned int fFlags;
424 unsigned int fBufferSize;
426 JackPortRegisterRequest() : fRefNum(0), fFlags(0), fBufferSize(0)
428 memset(fName, 0, sizeof(fName));
429 memset(fPortType, 0, sizeof(fPortType));
431 JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
432 : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
434 memset(fName, 0, sizeof(fName));
435 memset(fPortType, 0, sizeof(fPortType));
436 strncpy(fName, name, sizeof(fName)-1);
437 strncpy(fPortType, port_type, sizeof(fPortType)-1);
440 int Read(detail::JackChannelTransactionInterface* trans)
442 CheckSize();
443 CheckRes(trans->Read(&fRefNum, sizeof(int)));
444 CheckRes(trans->Read(&fName, sizeof(fName)));
445 CheckRes(trans->Read(&fPortType, sizeof(fPortType)));
446 CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
447 CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
448 return 0;
451 int Write(detail::JackChannelTransactionInterface* trans)
453 CheckRes(JackRequest::Write(trans, Size()));
454 CheckRes(trans->Write(&fRefNum, sizeof(int)));
455 CheckRes(trans->Write(&fName, sizeof(fName)));
456 CheckRes(trans->Write(&fPortType, sizeof(fPortType)));
457 CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
458 CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
459 return 0;
462 int Size() { return sizeof(int) + sizeof(fName) + sizeof(fPortType) + 2 * sizeof(unsigned int); }
467 \brief PortRegister result.
470 struct JackPortRegisterResult : public JackResult
473 jack_port_id_t fPortIndex;
475 JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
478 int Read(detail::JackChannelTransactionInterface* trans)
480 CheckRes(JackResult::Read(trans));
481 return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
484 int Write(detail::JackChannelTransactionInterface* trans)
486 CheckRes(JackResult::Write(trans));
487 return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
493 \brief PortUnregister request.
496 struct JackPortUnRegisterRequest : public JackRequest
499 int fRefNum;
500 jack_port_id_t fPortIndex;
502 JackPortUnRegisterRequest() : fRefNum(0), fPortIndex(0)
504 JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
505 : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
508 int Read(detail::JackChannelTransactionInterface* trans)
510 CheckSize();
511 CheckRes(trans->Read(&fRefNum, sizeof(int)));
512 CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
513 return 0;
516 int Write(detail::JackChannelTransactionInterface* trans)
518 CheckRes(JackRequest::Write(trans, Size()));
519 CheckRes(trans->Write(&fRefNum, sizeof(int)));
520 CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
521 return 0;
524 int Size() { return sizeof(int) + sizeof(jack_port_id_t); }
528 \brief PortConnectName request.
531 struct JackPortConnectNameRequest : public JackRequest
534 int fRefNum;
535 char fSrc[REAL_JACK_PORT_NAME_SIZE+1]; // port full name
536 char fDst[REAL_JACK_PORT_NAME_SIZE+1]; // port full name
538 JackPortConnectNameRequest() : fRefNum(0)
540 memset(fSrc, 0, sizeof(fSrc));
541 memset(fDst, 0, sizeof(fDst));
543 JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
544 : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
546 memset(fSrc, 0, sizeof(fSrc));
547 memset(fDst, 0, sizeof(fDst));
548 strncpy(fSrc, src_name, sizeof(fSrc)-1);
549 strncpy(fDst, dst_name, sizeof(fDst)-1);
552 int Read(detail::JackChannelTransactionInterface* trans)
554 CheckSize();
555 CheckRes(trans->Read(&fRefNum, sizeof(int)));
556 CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
557 CheckRes(trans->Read(&fDst, sizeof(fDst)));
558 return 0;
561 int Write(detail::JackChannelTransactionInterface* trans)
563 CheckRes(JackRequest::Write(trans, Size()));
564 CheckRes(trans->Write(&fRefNum, sizeof(int)));
565 CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
566 CheckRes(trans->Write(&fDst, sizeof(fDst)));
567 return 0;
570 int Size() { return sizeof(int) + sizeof(fSrc) + sizeof(fDst); }
575 \brief PortDisconnectName request.
578 struct JackPortDisconnectNameRequest : public JackRequest
581 int fRefNum;
582 char fSrc[REAL_JACK_PORT_NAME_SIZE+1]; // port full name
583 char fDst[REAL_JACK_PORT_NAME_SIZE+1]; // port full name
585 JackPortDisconnectNameRequest() : fRefNum(0)
587 memset(fSrc, 0, sizeof(fSrc));
588 memset(fDst, 0, sizeof(fDst));
590 JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
591 : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
593 memset(fSrc, 0, sizeof(fSrc));
594 memset(fDst, 0, sizeof(fDst));
595 strncpy(fSrc, src_name, sizeof(fSrc)-1);
596 strncpy(fDst, dst_name, sizeof(fDst)-1);
599 int Read(detail::JackChannelTransactionInterface* trans)
601 CheckSize();
602 CheckRes(trans->Read(&fRefNum, sizeof(int)));
603 CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
604 CheckRes(trans->Read(&fDst, sizeof(fDst)));
605 return 0;
608 int Write(detail::JackChannelTransactionInterface* trans)
610 CheckRes(JackRequest::Write(trans, Size()));
611 CheckRes(trans->Write(&fRefNum, sizeof(int)));
612 CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
613 CheckRes(trans->Write(&fDst, sizeof(fDst)));
614 return 0;
617 int Size() { return sizeof(int) + sizeof(fSrc) + sizeof(fDst); }
622 \brief PortConnect request.
625 struct JackPortConnectRequest : public JackRequest
628 int fRefNum;
629 jack_port_id_t fSrc;
630 jack_port_id_t fDst;
632 JackPortConnectRequest() : fRefNum(0), fSrc(0), fDst(0)
634 JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
635 : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
638 int Read(detail::JackChannelTransactionInterface* trans)
640 CheckSize();
641 CheckRes(trans->Read(&fRefNum, sizeof(int)));
642 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
643 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
644 return 0;
647 int Write(detail::JackChannelTransactionInterface* trans)
649 CheckRes(JackRequest::Write(trans, Size()));
650 CheckRes(trans->Write(&fRefNum, sizeof(int)));
651 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
652 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
653 return 0;
656 int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(jack_port_id_t); }
660 \brief PortDisconnect request.
663 struct JackPortDisconnectRequest : public JackRequest
666 int fRefNum;
667 jack_port_id_t fSrc;
668 jack_port_id_t fDst;
670 JackPortDisconnectRequest() : fRefNum(0), fSrc(0), fDst(0)
672 JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
673 : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
676 int Read(detail::JackChannelTransactionInterface* trans)
678 CheckSize();
679 CheckRes(trans->Read(&fRefNum, sizeof(int)));
680 CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
681 CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
682 return 0;
685 int Write(detail::JackChannelTransactionInterface* trans)
687 CheckRes(JackRequest::Write(trans, Size()));
688 CheckRes(trans->Write(&fRefNum, sizeof(int)));
689 CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
690 CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
691 return 0;
694 int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(jack_port_id_t); }
698 \brief PortRename request.
701 struct JackPortRenameRequest : public JackRequest
704 int fRefNum;
705 jack_port_id_t fPort;
706 char fName[JACK_PORT_NAME_SIZE + 1]; // port short name
708 JackPortRenameRequest() : fRefNum(0), fPort(0)
710 memset(fName, 0, sizeof(fName));
712 JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
713 : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
715 memset(fName, 0, sizeof(fName));
716 strncpy(fName, name, sizeof(fName)-1);
719 int Read(detail::JackChannelTransactionInterface* trans)
721 CheckSize();
722 CheckRes(trans->Read(&fRefNum, sizeof(int)));
723 CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
724 CheckRes(trans->Read(&fName, sizeof(fName)));
725 return 0;
728 int Write(detail::JackChannelTransactionInterface* trans)
730 CheckRes(JackRequest::Write(trans, Size()));
731 CheckRes(trans->Write(&fRefNum, sizeof(int)));
732 CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
733 CheckRes(trans->Write(&fName, sizeof(fName)));
734 return 0;
737 int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(fName); }
742 \brief SetBufferSize request.
745 struct JackSetBufferSizeRequest : public JackRequest
748 jack_nframes_t fBufferSize;
750 JackSetBufferSizeRequest() : fBufferSize(0)
752 JackSetBufferSizeRequest(jack_nframes_t buffer_size)
753 : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
756 int Read(detail::JackChannelTransactionInterface* trans)
758 CheckSize();
759 return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
762 int Write(detail::JackChannelTransactionInterface* trans)
764 CheckRes(JackRequest::Write(trans, Size()));
765 return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
768 int Size() { return sizeof(jack_nframes_t); }
772 \brief SetFreeWheel request.
775 struct JackSetFreeWheelRequest : public JackRequest
778 int fOnOff;
780 JackSetFreeWheelRequest() : fOnOff(0)
782 JackSetFreeWheelRequest(int onoff)
783 : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
786 int Read(detail::JackChannelTransactionInterface* trans)
788 CheckSize();
789 return trans->Read(&fOnOff, sizeof(int));
792 int Write(detail::JackChannelTransactionInterface* trans)
794 CheckRes(JackRequest::Write(trans, Size()));
795 return trans->Write(&fOnOff, sizeof(int));
798 int Size() { return sizeof(int); }
803 \brief ComputeTotalLatencies request.
806 struct JackComputeTotalLatenciesRequest : public JackRequest
809 JackComputeTotalLatenciesRequest()
810 : JackRequest(JackRequest::kComputeTotalLatencies)
813 int Read(detail::JackChannelTransactionInterface* trans)
815 CheckSize();
816 return 0;
819 int Write(detail::JackChannelTransactionInterface* trans)
821 CheckRes(JackRequest::Write(trans, Size()));
822 return 0;
825 int Size() { return 0; }
829 \brief ReleaseTimebase request.
832 struct JackReleaseTimebaseRequest : public JackRequest
835 int fRefNum;
837 JackReleaseTimebaseRequest() : fRefNum(0)
839 JackReleaseTimebaseRequest(int refnum)
840 : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
843 int Read(detail::JackChannelTransactionInterface* trans)
845 CheckSize();
846 return trans->Read(&fRefNum, sizeof(int));
849 int Write(detail::JackChannelTransactionInterface* trans)
851 CheckRes(JackRequest::Write(trans, Size()));
852 return trans->Write(&fRefNum, sizeof(int));
855 int Size() { return sizeof(int); }
860 \brief SetTimebaseCallback request.
863 struct JackSetTimebaseCallbackRequest : public JackRequest
866 int fRefNum;
867 int fConditionnal;
869 JackSetTimebaseCallbackRequest() : fRefNum(0), fConditionnal(0)
871 JackSetTimebaseCallbackRequest(int refnum, int conditional)
872 : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
875 int Read(detail::JackChannelTransactionInterface* trans)
877 CheckSize();
878 CheckRes(trans->Read(&fRefNum, sizeof(int)));
879 return trans->Read(&fConditionnal, sizeof(int));
882 int Write(detail::JackChannelTransactionInterface* trans)
884 CheckRes(JackRequest::Write(trans, Size()));
885 CheckRes(trans->Write(&fRefNum, sizeof(int)));
886 return trans->Write(&fConditionnal, sizeof(int));
889 int Size() { return sizeof(int) + sizeof(int); }
893 \brief GetInternalClientName request.
896 struct JackGetInternalClientNameRequest : public JackRequest
899 int fRefNum;
900 int fIntRefNum;
902 JackGetInternalClientNameRequest() : fRefNum(0), fIntRefNum(0)
904 JackGetInternalClientNameRequest(int refnum, int int_ref)
905 : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
908 int Read(detail::JackChannelTransactionInterface* trans)
910 CheckSize();
911 CheckRes(trans->Read(&fRefNum, sizeof(int)));
912 return trans->Read(&fIntRefNum, sizeof(int));
915 int Write(detail::JackChannelTransactionInterface* trans)
917 CheckRes(JackRequest::Write(trans, Size()));
918 CheckRes(trans->Write(&fRefNum, sizeof(int)));
919 return trans->Write(&fIntRefNum, sizeof(int));
922 int Size() { return sizeof(int) + sizeof(int); }
926 \brief GetInternalClient result.
929 struct JackGetInternalClientNameResult : public JackResult
932 char fName[JACK_CLIENT_NAME_SIZE+1];
934 JackGetInternalClientNameResult(): JackResult()
936 memset(fName, 0, sizeof(fName));
938 JackGetInternalClientNameResult(int32_t result, const char* name)
939 : JackResult(result)
941 memset(fName, 0, sizeof(fName));
942 snprintf(fName, sizeof(fName), "%s", name);
945 int Read(detail::JackChannelTransactionInterface* trans)
947 CheckRes(JackResult::Read(trans));
948 CheckRes(trans->Read(&fName, sizeof(fName)));
949 return 0;
952 int Write(detail::JackChannelTransactionInterface* trans)
954 CheckRes(JackResult::Write(trans));
955 CheckRes(trans->Write(&fName, sizeof(fName)));
956 return 0;
959 int Size() { return sizeof(fName); }
963 \brief InternalClientHandle request.
966 struct JackInternalClientHandleRequest : public JackRequest
969 int fRefNum;
970 char fName[JACK_CLIENT_NAME_SIZE+1];
972 JackInternalClientHandleRequest() : fRefNum(0)
974 memset(fName, 0, sizeof(fName));
976 JackInternalClientHandleRequest(int refnum, const char* client_name)
977 : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
979 memset(fName, 0, sizeof(fName));
980 snprintf(fName, sizeof(fName), "%s", client_name);
983 int Read(detail::JackChannelTransactionInterface* trans)
985 CheckSize();
986 CheckRes(trans->Read(&fRefNum, sizeof(int)));
987 return trans->Read(&fName, sizeof(fName));
990 int Write(detail::JackChannelTransactionInterface* trans)
992 CheckRes(JackRequest::Write(trans, Size()));
993 CheckRes(trans->Write(&fRefNum, sizeof(int)));
994 return trans->Write(&fName, sizeof(fName));
997 int Size() { return sizeof(int) + sizeof(fName); }
1001 \brief InternalClientHandle result.
1004 struct JackInternalClientHandleResult : public JackResult
1007 int fStatus;
1008 int fIntRefNum;
1010 JackInternalClientHandleResult(): JackResult(), fStatus(0), fIntRefNum(0)
1012 JackInternalClientHandleResult(int32_t result, int status, int int_ref)
1013 : JackResult(result), fStatus(status), fIntRefNum(int_ref)
1016 int Read(detail::JackChannelTransactionInterface* trans)
1018 CheckRes(JackResult::Read(trans));
1019 CheckRes(trans->Read(&fStatus, sizeof(int)));
1020 CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
1021 return 0;
1024 int Write(detail::JackChannelTransactionInterface* trans)
1026 CheckRes(JackResult::Write(trans));
1027 CheckRes(trans->Write(&fStatus, sizeof(int)));
1028 CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
1029 return 0;
1032 int Size() { return sizeof(int) + sizeof(int); }
1036 \brief InternalClientLoad request.
1039 struct JackInternalClientLoadRequest : public JackRequest
1042 #ifndef MAX_PATH
1043 #define MAX_PATH 256
1044 #endif
1046 int fRefNum;
1047 char fName[JACK_CLIENT_NAME_SIZE+1];
1048 char fDllName[MAX_PATH+1];
1049 char fLoadInitName[JACK_LOAD_INIT_LIMIT+1];
1050 int fOptions;
1051 jack_uuid_t fUUID;
1053 JackInternalClientLoadRequest() : fRefNum(0), fOptions(0), fUUID(JACK_UUID_EMPTY_INITIALIZER)
1055 memset(fName, 0, sizeof(fName));
1056 memset(fDllName, 0, sizeof(fDllName));
1057 memset(fLoadInitName, 0, sizeof(fLoadInitName));
1059 JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, jack_uuid_t uuid )
1060 : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options), fUUID(uuid)
1062 memset(fName, 0, sizeof(fName));
1063 memset(fDllName, 0, sizeof(fDllName));
1064 memset(fLoadInitName, 0, sizeof(fLoadInitName));
1065 strncpy(fName, client_name, sizeof(fName)-1);
1066 if (so_name) {
1067 strncpy(fDllName, so_name, sizeof(fDllName)-1);
1069 if (objet_data) {
1070 strncpy(fLoadInitName, objet_data, sizeof(fLoadInitName)-1);
1074 int Read(detail::JackChannelTransactionInterface* trans)
1076 CheckSize();
1077 CheckRes(trans->Read(&fRefNum, sizeof(int)));
1078 CheckRes(trans->Read(&fName, sizeof(fName)));
1079 CheckRes(trans->Read(&fDllName, sizeof(fDllName)));
1080 CheckRes(trans->Read(&fLoadInitName, sizeof(fLoadInitName)));
1081 CheckRes(trans->Read(&fUUID, sizeof(jack_uuid_t)));
1082 return trans->Read(&fOptions, sizeof(int));
1085 int Write(detail::JackChannelTransactionInterface* trans)
1087 CheckRes(JackRequest::Write(trans, Size()));
1088 CheckRes(trans->Write(&fRefNum, sizeof(int)));
1089 CheckRes(trans->Write(&fName, sizeof(fName)));
1090 CheckRes(trans->Write(&fDllName, sizeof(fDllName)));
1091 CheckRes(trans->Write(&fLoadInitName, sizeof(fLoadInitName)));
1092 CheckRes(trans->Write(&fUUID, sizeof(jack_uuid_t)));
1093 return trans->Write(&fOptions, sizeof(int));
1096 int Size() { return sizeof(int) + sizeof(fName) + sizeof(fDllName) + sizeof(fLoadInitName) + sizeof(int) + sizeof(jack_uuid_t); }
1100 \brief InternalClientLoad result.
1103 struct JackInternalClientLoadResult : public JackResult
1106 int fStatus;
1107 int fIntRefNum;
1109 JackInternalClientLoadResult(): JackResult(), fStatus(0), fIntRefNum(0)
1111 JackInternalClientLoadResult(int32_t result, int status, int int_ref)
1112 : JackResult(result), fStatus(status), fIntRefNum(int_ref)
1115 int Read(detail::JackChannelTransactionInterface* trans)
1117 CheckRes(JackResult::Read(trans));
1118 CheckRes(trans->Read(&fStatus, sizeof(int)));
1119 CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
1120 return 0;
1123 int Write(detail::JackChannelTransactionInterface* trans)
1125 CheckRes(JackResult::Write(trans));
1126 CheckRes(trans->Write(&fStatus, sizeof(int)));
1127 CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
1128 return 0;
1131 int Size() { return sizeof(int) + sizeof(int); }
1135 \brief InternalClientUnload request.
1138 struct JackInternalClientUnloadRequest : public JackRequest
1141 int fRefNum;
1142 int fIntRefNum;
1144 JackInternalClientUnloadRequest() : fRefNum(0), fIntRefNum(0)
1146 JackInternalClientUnloadRequest(int refnum, int int_ref)
1147 : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
1150 int Read(detail::JackChannelTransactionInterface* trans)
1152 CheckSize();
1153 CheckRes(trans->Read(&fRefNum, sizeof(int)));
1154 return trans->Read(&fIntRefNum, sizeof(int));
1157 int Write(detail::JackChannelTransactionInterface* trans)
1159 CheckRes(JackRequest::Write(trans, Size()));
1160 CheckRes(trans->Write(&fRefNum, sizeof(int)));
1161 return trans->Write(&fIntRefNum, sizeof(int));
1164 int Size() { return sizeof(int) + sizeof(int); }
1168 \brief InternalClientLoad result.
1171 struct JackInternalClientUnloadResult : public JackResult
1174 int fStatus;
1176 JackInternalClientUnloadResult(): JackResult(), fStatus(0)
1178 JackInternalClientUnloadResult(int32_t result, int status)
1179 : JackResult(result), fStatus(status)
1182 int Read(detail::JackChannelTransactionInterface* trans)
1184 CheckRes(JackResult::Read(trans));
1185 CheckRes(trans->Read(&fStatus, sizeof(int)));
1186 return 0;
1189 int Write(detail::JackChannelTransactionInterface* trans)
1191 CheckRes(JackResult::Write(trans));
1192 CheckRes(trans->Write(&fStatus, sizeof(int)));
1193 return 0;
1196 int Size() { return sizeof(int); }
1200 \brief ClientNotification request.
1203 struct JackClientNotificationRequest : public JackRequest
1206 int fRefNum;
1207 int fNotify;
1208 int fValue;
1210 JackClientNotificationRequest() : fRefNum(0), fNotify(0), fValue(0)
1212 JackClientNotificationRequest(int refnum, int notify, int value)
1213 : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
1216 int Read(detail::JackChannelTransactionInterface* trans)
1218 CheckSize();
1219 CheckRes(trans->Read(&fRefNum, sizeof(int)));
1220 CheckRes(trans->Read(&fNotify, sizeof(int)));
1221 CheckRes(trans->Read(&fValue, sizeof(int)));
1222 return 0;
1225 int Write(detail::JackChannelTransactionInterface* trans)
1227 CheckRes(JackRequest::Write(trans, Size()));
1228 CheckRes(trans->Write(&fRefNum, sizeof(int)));
1229 CheckRes(trans->Write(&fNotify, sizeof(int)));
1230 CheckRes(trans->Write(&fValue, sizeof(int)));
1231 return 0;
1234 int Size() { return 3 * sizeof(int); }
1238 struct JackSessionCommand
1240 char fUUID[JACK_UUID_STRING_SIZE];
1241 char fClientName[JACK_CLIENT_NAME_SIZE+1];
1242 char fCommand[JACK_SESSION_COMMAND_SIZE+1];
1243 jack_session_flags_t fFlags;
1245 JackSessionCommand() : fFlags(JackSessionSaveError)
1247 memset(fUUID, 0, sizeof(fUUID));
1248 memset(fClientName, 0, sizeof(fClientName));
1249 memset(fCommand, 0, sizeof(fCommand));
1251 JackSessionCommand(const char *uuid, const char *clientname, const char *command, jack_session_flags_t flags)
1253 memset(fUUID, 0, sizeof(fUUID));
1254 memset(fClientName, 0, sizeof(fClientName));
1255 memset(fCommand, 0, sizeof(fCommand));
1256 strncpy(fUUID, uuid, sizeof(fUUID)-1);
1257 strncpy(fClientName, clientname, sizeof(fClientName)-1);
1258 strncpy(fCommand, command, sizeof(fCommand)-1);
1259 fFlags = flags;
1263 struct JackSessionNotifyResult : public JackResult
1266 std::list<JackSessionCommand> fCommandList;
1267 bool fDone;
1269 JackSessionNotifyResult(): JackResult(), fDone(false)
1271 JackSessionNotifyResult(int32_t result)
1272 : JackResult(result), fDone(false)
1275 int Read(detail::JackChannelTransactionInterface* trans)
1277 if (trans == NULL)
1279 return 0;
1282 CheckRes(JackResult::Read(trans));
1283 while (true) {
1284 JackSessionCommand buffer;
1286 CheckRes(trans->Read(buffer.fUUID, sizeof(buffer.fUUID)));
1287 if (buffer.fUUID[0] == '\0')
1288 break;
1290 CheckRes(trans->Read(buffer.fClientName, sizeof(buffer.fClientName)));
1291 CheckRes(trans->Read(buffer.fCommand, sizeof(buffer.fCommand)));
1292 CheckRes(trans->Read(&(buffer.fFlags), sizeof(buffer.fFlags)));
1294 fCommandList.push_back(buffer);
1297 fDone = true;
1299 return 0;
1302 int Write(detail::JackChannelTransactionInterface* trans)
1304 if (trans == NULL)
1306 fDone = true;
1307 return 0;
1310 char terminator[JACK_UUID_STRING_SIZE];
1311 memset(terminator, 0, sizeof(terminator));
1313 CheckRes(JackResult::Write(trans));
1314 for (std::list<JackSessionCommand>::iterator i = fCommandList.begin(); i != fCommandList.end(); i++) {
1315 CheckRes(trans->Write(i->fUUID, sizeof(i->fUUID)));
1316 CheckRes(trans->Write(i->fClientName, sizeof(i->fClientName)));
1317 CheckRes(trans->Write(i->fCommand, sizeof(i->fCommand)));
1318 CheckRes(trans->Write(&(i->fFlags), sizeof(i->fFlags)));
1320 CheckRes(trans->Write(terminator, sizeof(terminator)));
1321 return 0;
1324 jack_session_command_t* GetCommands()
1326 /* TODO: some kind of signal should be used instead */
1327 while (!fDone)
1329 JackSleep(50000); /* 50 ms */
1332 jack_session_command_t* session_command = (jack_session_command_t *)malloc(sizeof(jack_session_command_t) * (fCommandList.size() + 1));
1333 int i = 0;
1335 for (std::list<JackSessionCommand>::iterator ci = fCommandList.begin(); ci != fCommandList.end(); ci++) {
1336 session_command[i].uuid = strdup(ci->fUUID);
1337 session_command[i].client_name = strdup(ci->fClientName);
1338 session_command[i].command = strdup(ci->fCommand);
1339 session_command[i].flags = ci->fFlags;
1340 i += 1;
1343 session_command[i].uuid = NULL;
1344 session_command[i].client_name = NULL;
1345 session_command[i].command = NULL;
1346 session_command[i].flags = (jack_session_flags_t)0;
1348 return session_command;
1353 \brief SessionNotify request.
1356 struct JackSessionNotifyRequest : public JackRequest
1358 char fPath[JACK_MESSAGE_SIZE+1];
1359 char fDst[JACK_CLIENT_NAME_SIZE+1];
1360 jack_session_event_type_t fEventType;
1361 int fRefNum;
1363 JackSessionNotifyRequest() : fEventType(JackSessionSave), fRefNum(0)
1365 JackSessionNotifyRequest(int refnum, const char* path, jack_session_event_type_t type, const char* dst)
1366 : JackRequest(JackRequest::kSessionNotify), fEventType(type), fRefNum(refnum)
1368 memset(fPath, 0, sizeof(fPath));
1369 memset(fDst, 0, sizeof(fDst));
1370 strncpy(fPath, path, sizeof(fPath)-1);
1371 if (dst) {
1372 strncpy(fDst, dst, sizeof(fDst)-1);
1376 int Read(detail::JackChannelTransactionInterface* trans)
1378 CheckSize();
1379 CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
1380 CheckRes(trans->Read(&fPath, sizeof(fPath)));
1381 CheckRes(trans->Read(&fDst, sizeof(fDst)));
1382 CheckRes(trans->Read(&fEventType, sizeof(fEventType)));
1383 return 0;
1386 int Write(detail::JackChannelTransactionInterface* trans)
1388 CheckRes(JackRequest::Write(trans, Size()));
1389 CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
1390 CheckRes(trans->Write(&fPath, sizeof(fPath)));
1391 CheckRes(trans->Write(&fDst, sizeof(fDst)));
1392 CheckRes(trans->Write(&fEventType, sizeof(fEventType)));
1393 return 0;
1396 int Size() { return sizeof(fRefNum) + sizeof(fPath) + sizeof(fDst) + sizeof(fEventType); }
1399 struct JackSessionReplyRequest : public JackRequest
1401 int fRefNum;
1403 JackSessionReplyRequest() : fRefNum(0)
1406 JackSessionReplyRequest(int refnum)
1407 : JackRequest(JackRequest::kSessionReply), fRefNum(refnum)
1410 int Read(detail::JackChannelTransactionInterface* trans)
1412 CheckSize();
1413 CheckRes(trans->Read(&fRefNum, sizeof(int)));
1414 return 0;
1417 int Write(detail::JackChannelTransactionInterface* trans)
1419 CheckRes(JackRequest::Write(trans, Size()));
1420 CheckRes(trans->Write(&fRefNum, sizeof(int)));
1421 return 0;
1424 int Size() { return sizeof(int); }
1428 struct JackClientNameResult : public JackResult
1430 char fName[JACK_CLIENT_NAME_SIZE+1];
1432 JackClientNameResult(): JackResult()
1434 memset(fName, 0, sizeof(fName));
1436 JackClientNameResult(int32_t result, const char* name)
1437 : JackResult(result)
1439 memset(fName, 0, sizeof(fName));
1440 strncpy(fName, name, sizeof(fName)-1);
1443 int Read(detail::JackChannelTransactionInterface* trans)
1445 CheckRes(JackResult::Read(trans));
1446 CheckRes(trans->Read(&fName, sizeof(fName)));
1447 return 0;
1450 int Write(detail::JackChannelTransactionInterface* trans)
1452 CheckRes(JackResult::Write(trans));
1453 CheckRes(trans->Write(&fName, sizeof(fName)));
1454 return 0;
1459 struct JackUUIDResult : public JackResult
1461 char fUUID[JACK_UUID_STRING_SIZE];
1463 JackUUIDResult(): JackResult()
1465 memset(fUUID, 0, sizeof(fUUID));
1467 JackUUIDResult(int32_t result, const char* uuid)
1468 : JackResult(result)
1470 memset(fUUID, 0, sizeof(fUUID));
1471 strncpy(fUUID, uuid, sizeof(fUUID)-1);
1474 int Read(detail::JackChannelTransactionInterface* trans)
1476 CheckRes(JackResult::Read(trans));
1477 CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1478 return 0;
1481 int Write(detail::JackChannelTransactionInterface* trans)
1483 CheckRes(JackResult::Write(trans));
1484 CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1485 return 0;
1490 struct JackGetUUIDRequest : public JackRequest
1492 char fName[JACK_CLIENT_NAME_SIZE+1];
1494 JackGetUUIDRequest()
1496 memset(fName, 0, sizeof(fName));
1499 JackGetUUIDRequest(const char* client_name)
1500 : JackRequest(JackRequest::kGetUUIDByClient)
1502 memset(fName, 0, sizeof(fName));
1503 strncpy(fName, client_name, sizeof(fName)-1);
1506 int Read(detail::JackChannelTransactionInterface* trans)
1508 CheckSize();
1509 CheckRes(trans->Read(&fName, sizeof(fName)));
1510 return 0;
1513 int Write(detail::JackChannelTransactionInterface* trans)
1515 CheckRes(JackRequest::Write(trans, Size()));
1516 CheckRes(trans->Write(&fName, sizeof(fName)));
1517 return 0;
1520 int Size() { return sizeof(fName); }
1524 struct JackGetClientNameRequest : public JackRequest
1526 char fUUID[JACK_UUID_STRING_SIZE];
1528 JackGetClientNameRequest()
1530 memset(fUUID, 0, sizeof(fUUID));
1533 JackGetClientNameRequest(const char* uuid)
1534 : JackRequest(JackRequest::kGetClientByUUID)
1536 memset(fUUID, 0, sizeof(fUUID));
1537 strncpy(fUUID, uuid, sizeof(fUUID)-1);
1540 int Read(detail::JackChannelTransactionInterface* trans)
1542 CheckSize();
1543 CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1544 return 0;
1547 int Write(detail::JackChannelTransactionInterface* trans)
1549 CheckRes(JackRequest::Write(trans, Size()));
1550 CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1551 return 0;
1554 int Size() { return sizeof(fUUID); }
1558 struct JackReserveNameRequest : public JackRequest
1560 int fRefNum;
1561 char fName[JACK_CLIENT_NAME_SIZE+1];
1562 char fUUID[JACK_UUID_STRING_SIZE];
1564 JackReserveNameRequest() : fRefNum(0)
1566 memset(fName, 0, sizeof(fName));
1567 memset(fUUID, 0, sizeof(fUUID));
1570 JackReserveNameRequest(int refnum, const char *name, const char* uuid)
1571 : JackRequest(JackRequest::kReserveClientName), fRefNum(refnum)
1573 memset(fName, 0, sizeof(fName));
1574 memset(fUUID, 0, sizeof(fUUID));
1575 strncpy(fName, name, sizeof(fName)-1);
1576 strncpy(fUUID, uuid, sizeof(fUUID)-1);
1579 int Read(detail::JackChannelTransactionInterface* trans)
1581 CheckSize();
1582 CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1583 CheckRes(trans->Read(&fName, sizeof(fName)));
1584 CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
1585 return 0;
1588 int Write(detail::JackChannelTransactionInterface* trans)
1590 CheckRes(JackRequest::Write(trans, Size()));
1591 CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1592 CheckRes(trans->Write(&fName, sizeof(fName)));
1593 CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
1594 return 0;
1597 int Size() { return sizeof(fUUID) + sizeof(fName) + sizeof(fRefNum); }
1601 struct JackClientHasSessionCallbackRequest : public JackRequest
1603 char fName[JACK_CLIENT_NAME_SIZE+1];
1605 JackClientHasSessionCallbackRequest()
1607 memset(fName, 0, sizeof(fName));
1610 JackClientHasSessionCallbackRequest(const char *name)
1611 : JackRequest(JackRequest::kClientHasSessionCallback)
1613 memset(fName, 0, sizeof(fName));
1614 strncpy(fName, name, sizeof(fName)-1);
1617 int Read(detail::JackChannelTransactionInterface* trans)
1619 CheckSize();
1620 CheckRes(trans->Read(&fName, sizeof(fName)));
1621 return 0;
1624 int Write(detail::JackChannelTransactionInterface* trans)
1626 CheckRes(JackRequest::Write(trans, Size()));
1627 CheckRes(trans->Write(&fName, sizeof(fName)));
1628 return 0;
1631 int Size() { return sizeof(fName); }
1636 struct JackPropertyChangeNotifyRequest : public JackRequest
1638 jack_uuid_t fSubject;
1639 char fKey[MAX_PATH+1];
1640 jack_property_change_t fChange;
1642 JackPropertyChangeNotifyRequest() : fChange((jack_property_change_t)0)
1644 jack_uuid_clear(&fSubject);
1645 memset(fKey, 0, sizeof(fKey));
1647 JackPropertyChangeNotifyRequest(jack_uuid_t subject, const char* key, jack_property_change_t change)
1648 : JackRequest(JackRequest::kPropertyChangeNotify), fChange(change)
1650 jack_uuid_copy(&fSubject, subject);
1651 memset(fKey, 0, sizeof(fKey));
1652 if (key)
1653 strncpy(fKey, key, sizeof(fKey)-1);
1656 int Read(detail::JackChannelTransactionInterface* trans)
1658 CheckSize();
1659 CheckRes(trans->Read(&fSubject, sizeof(fSubject)));
1660 CheckRes(trans->Read(&fKey, sizeof(fKey)));
1661 CheckRes(trans->Read(&fChange, sizeof(fChange)));
1662 return 0;
1665 int Write(detail::JackChannelTransactionInterface* trans)
1667 CheckRes(JackRequest::Write(trans, Size()));
1668 CheckRes(trans->Write(&fSubject, sizeof(fSubject)));
1669 CheckRes(trans->Write(&fKey, sizeof(fKey)));
1670 CheckRes(trans->Write(&fChange, sizeof(fChange)));
1671 return 0;
1674 int Size() { return sizeof(fSubject) + sizeof(fKey) + sizeof(fChange); }
1678 \brief ClientNotification.
1681 struct JackClientNotification
1683 int fSize;
1684 char fName[JACK_CLIENT_NAME_SIZE+1];
1685 int fRefNum;
1686 int fNotify;
1687 int fValue1;
1688 int fValue2;
1689 int fSync;
1690 char fMessage[JACK_MESSAGE_SIZE+1];
1692 JackClientNotification(): fSize(0), fRefNum(0), fNotify(-1), fValue1(-1), fValue2(-1), fSync(0)
1694 memset(fName, 0, sizeof(fName));
1695 memset(fMessage, 0, sizeof(fMessage));
1697 JackClientNotification(const char* name, int refnum, int notify, int sync, const char* message, int value1, int value2)
1698 : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
1700 memset(fName, 0, sizeof(fName));
1701 memset(fMessage, 0, sizeof(fMessage));
1702 strncpy(fName, name, sizeof(fName)-1);
1703 if (message) {
1704 strncpy(fMessage, message, sizeof(fMessage)-1);
1706 fSize = Size();
1709 int Read(detail::JackChannelTransactionInterface* trans)
1711 CheckSize();
1712 CheckRes(trans->Read(&fName, sizeof(fName)));
1713 CheckRes(trans->Read(&fRefNum, sizeof(int)));
1714 CheckRes(trans->Read(&fNotify, sizeof(int)));
1715 CheckRes(trans->Read(&fValue1, sizeof(int)));
1716 CheckRes(trans->Read(&fValue2, sizeof(int)));
1717 CheckRes(trans->Read(&fSync, sizeof(int)));
1718 CheckRes(trans->Read(&fMessage, sizeof(fMessage)));
1719 return 0;
1722 int Write(detail::JackChannelTransactionInterface* trans)
1724 CheckRes(trans->Write(&fSize, sizeof(int)));
1725 CheckRes(trans->Write(&fName, sizeof(fName)));
1726 CheckRes(trans->Write(&fRefNum, sizeof(int)));
1727 CheckRes(trans->Write(&fNotify, sizeof(int)));
1728 CheckRes(trans->Write(&fValue1, sizeof(int)));
1729 CheckRes(trans->Write(&fValue2, sizeof(int)));
1730 CheckRes(trans->Write(&fSync, sizeof(int)));
1731 CheckRes(trans->Write(&fMessage, sizeof(fMessage)));
1732 return 0;
1735 int Size() { return sizeof(int) + sizeof(fName) + 5 * sizeof(int) + sizeof(fMessage); }
1739 } // end of namespace
1741 #endif