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"
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; } }
42 \brief Session API constants.
45 enum JackSessionReply
{
47 kImmediateSessionReply
= 1,
48 kPendingSessionReply
= 2
53 \brief Request from client to server.
64 kSetTimeBaseClient
= 5,
66 kDeactivateClient
= 7,
68 kSetClientCapabilities
= 9,
69 kGetPortConnections
= 10,
70 kGetPortNConnections
= 11,
71 kReleaseTimebase
= 12,
72 kSetTimebaseCallback
= 13,
78 kConnectNamePorts
= 25,
79 kDisconnectNamePorts
= 26,
80 kGetInternalClientName
= 27,
81 kInternalClientHandle
= 28,
82 kInternalClientLoad
= 29,
83 kInternalClientUnload
= 30,
88 kGetClientByUUID
= 35,
89 kReserveClientName
= 36,
90 kGetUUIDByClient
= 37,
91 kClientHasSessionCallback
= 38,
92 kComputeTotalLatencies
= 39
98 JackRequest(): fType((RequestType
)0), fSize(0)
101 JackRequest(RequestType type
): fType(type
), fSize(0)
104 virtual ~JackRequest()
107 virtual int Read(detail::JackChannelTransactionInterface
* trans
)
109 return trans
->Read(&fType
, sizeof(RequestType
));
112 virtual int Write(detail::JackChannelTransactionInterface
* trans
) { return -1; }
114 virtual int Write(detail::JackChannelTransactionInterface
* trans
, int size
)
117 CheckRes(trans
->Write(&fType
, sizeof(RequestType
)));
118 return trans
->Write(&fSize
, sizeof(int));
121 virtual int Size() { return 0; }
126 \brief Result from the server.
134 JackResult(): fResult( -1)
136 JackResult(int result
): fResult(result
)
138 virtual ~JackResult()
141 virtual int Read(detail::JackChannelTransactionInterface
* trans
)
143 return trans
->Read(&fResult
, sizeof(int));
146 virtual int Write(detail::JackChannelTransactionInterface
* trans
)
148 return trans
->Write(&fResult
, sizeof(int));
154 \brief CheckClient request.
157 struct JackClientCheckRequest
: public JackRequest
160 char fName
[JACK_CLIENT_NAME_SIZE
+1];
166 JackClientCheckRequest()
168 JackClientCheckRequest(const char* name
, int protocol
, int options
, int uuid
, int open
= false)
169 : JackRequest(JackRequest::kClientCheck
), fProtocol(protocol
), fOptions(options
), fUUID(uuid
), fOpen(open
)
171 snprintf(fName
, sizeof(fName
), "%s", name
);
174 int Read(detail::JackChannelTransactionInterface
* trans
)
177 CheckRes(trans
->Read(&fName
, sizeof(fName
)));
178 CheckRes(trans
->Read(&fProtocol
, sizeof(int)));
179 CheckRes(trans
->Read(&fOptions
, sizeof(int)));
180 CheckRes(trans
->Read(&fUUID
, sizeof(int)));
181 return trans
->Read(&fOpen
, sizeof(int));
184 int Write(detail::JackChannelTransactionInterface
* trans
)
186 CheckRes(JackRequest::Write(trans
, Size()));
187 CheckRes(trans
->Write(&fName
, sizeof(fName
)));
188 CheckRes(trans
->Write(&fProtocol
, sizeof(int)));
189 CheckRes(trans
->Write(&fOptions
, sizeof(int)));
190 CheckRes(trans
->Write(&fUUID
, sizeof(int)));
191 return trans
->Write(&fOpen
, sizeof(int));
194 int Size() { return sizeof(fName
) + 4 * sizeof(int); }
199 \brief CheckClient result.
202 struct JackClientCheckResult
: public JackResult
205 char fName
[JACK_CLIENT_NAME_SIZE
+1];
208 JackClientCheckResult(): JackResult(), fStatus(0)
210 JackClientCheckResult(int32_t result
, const char* name
, int status
)
211 : JackResult(result
), fStatus(status
)
213 snprintf(fName
, sizeof(fName
), "%s", name
);
216 int Read(detail::JackChannelTransactionInterface
* trans
)
218 CheckRes(JackResult::Read(trans
));
219 CheckRes(trans
->Read(&fName
, sizeof(fName
)));
220 CheckRes(trans
->Read(&fStatus
, sizeof(int)));
224 int Write(detail::JackChannelTransactionInterface
* trans
)
226 CheckRes(JackResult::Write(trans
));
227 CheckRes(trans
->Write(&fName
, sizeof(fName
)));
228 CheckRes(trans
->Write(&fStatus
, sizeof(int)));
235 \brief NewClient request.
238 struct JackClientOpenRequest
: public JackRequest
243 char fName
[JACK_CLIENT_NAME_SIZE
+1];
245 JackClientOpenRequest()
247 JackClientOpenRequest(const char* name
, int pid
, int uuid
): JackRequest(JackRequest::kClientOpen
)
249 snprintf(fName
, sizeof(fName
), "%s", name
);
254 int Read(detail::JackChannelTransactionInterface
* trans
)
257 CheckRes(trans
->Read(&fPID
, sizeof(int)));
258 CheckRes(trans
->Read(&fUUID
, sizeof(int)));
259 return trans
->Read(&fName
, sizeof(fName
));
262 int Write(detail::JackChannelTransactionInterface
* trans
)
264 CheckRes(JackRequest::Write(trans
, Size()));
265 CheckRes(trans
->Write(&fPID
, sizeof(int)));
266 CheckRes(trans
->Write(&fUUID
, sizeof(int)));
267 return trans
->Write(&fName
, sizeof(fName
));
270 int Size() { return 2 * sizeof(int) + sizeof(fName
); }
275 \brief NewClient result.
278 struct JackClientOpenResult
: public JackResult
285 JackClientOpenResult()
286 : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
288 JackClientOpenResult(int32_t result
, int index1
, int index2
, int index3
)
289 : JackResult(result
), fSharedEngine(index1
), fSharedClient(index2
), fSharedGraph(index3
)
292 int Read(detail::JackChannelTransactionInterface
* trans
)
294 CheckRes(JackResult::Read(trans
));
295 CheckRes(trans
->Read(&fSharedEngine
, sizeof(int)));
296 CheckRes(trans
->Read(&fSharedClient
, sizeof(int)));
297 CheckRes(trans
->Read(&fSharedGraph
, sizeof(int)));
301 int Write(detail::JackChannelTransactionInterface
* trans
)
303 CheckRes(JackResult::Write(trans
));
304 CheckRes(trans
->Write(&fSharedEngine
, sizeof(int)));
305 CheckRes(trans
->Write(&fSharedClient
, sizeof(int)));
306 CheckRes(trans
->Write(&fSharedGraph
, sizeof(int)));
313 \brief CloseClient request.
316 struct JackClientCloseRequest
: public JackRequest
321 JackClientCloseRequest()
323 JackClientCloseRequest(int refnum
): JackRequest(JackRequest::kClientClose
), fRefNum(refnum
)
326 int Read(detail::JackChannelTransactionInterface
* trans
)
329 return trans
->Read(&fRefNum
, sizeof(int));
332 int Write(detail::JackChannelTransactionInterface
* trans
)
334 CheckRes(JackRequest::Write(trans
, Size()));
335 return trans
->Write(&fRefNum
, sizeof(int));
338 int Size() { return sizeof(int); }
342 \brief Activate request.
345 struct JackActivateRequest
: public JackRequest
351 JackActivateRequest()
353 JackActivateRequest(int refnum
, int is_real_time
)
354 : JackRequest(JackRequest::kActivateClient
), fRefNum(refnum
), fIsRealTime(is_real_time
)
357 int Read(detail::JackChannelTransactionInterface
* trans
)
360 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
361 return trans
->Read(&fIsRealTime
, sizeof(int));
364 int Write(detail::JackChannelTransactionInterface
* trans
)
366 CheckRes(JackRequest::Write(trans
, Size()));
367 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
368 return trans
->Write(&fIsRealTime
, sizeof(int));
371 int Size() { return 2 * sizeof(int); }
375 \brief Deactivate request.
378 struct JackDeactivateRequest
: public JackRequest
383 JackDeactivateRequest()
385 JackDeactivateRequest(int refnum
): JackRequest(JackRequest::kDeactivateClient
), fRefNum(refnum
)
388 int Read(detail::JackChannelTransactionInterface
* trans
)
391 return trans
->Read(&fRefNum
, sizeof(int));
394 int Write(detail::JackChannelTransactionInterface
* trans
)
396 CheckRes(JackRequest::Write(trans
, Size()));
397 return trans
->Write(&fRefNum
, sizeof(int));
400 int Size() { return sizeof(int); }
404 \brief PortRegister request.
407 struct JackPortRegisterRequest
: public JackRequest
411 char fName
[JACK_PORT_NAME_SIZE
+ 1]; // port short name
412 char fPortType
[JACK_PORT_TYPE_SIZE
+ 1];
414 unsigned int fBufferSize
;
416 JackPortRegisterRequest()
418 JackPortRegisterRequest(int refnum
, const char* name
, const char* port_type
, unsigned int flags
, unsigned int buffer_size
)
419 : JackRequest(JackRequest::kRegisterPort
), fRefNum(refnum
), fFlags(flags
), fBufferSize(buffer_size
)
422 strcpy(fPortType
, port_type
);
425 int Read(detail::JackChannelTransactionInterface
* trans
)
428 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
429 CheckRes(trans
->Read(&fName
, sizeof(fName
)));
430 CheckRes(trans
->Read(&fPortType
, sizeof(fPortType
)));
431 CheckRes(trans
->Read(&fFlags
, sizeof(unsigned int)));
432 CheckRes(trans
->Read(&fBufferSize
, sizeof(unsigned int)));
436 int Write(detail::JackChannelTransactionInterface
* trans
)
438 CheckRes(JackRequest::Write(trans
, Size()));
439 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
440 CheckRes(trans
->Write(&fName
, sizeof(fName
)));
441 CheckRes(trans
->Write(&fPortType
, sizeof(fPortType
)));
442 CheckRes(trans
->Write(&fFlags
, sizeof(unsigned int)));
443 CheckRes(trans
->Write(&fBufferSize
, sizeof(unsigned int)));
447 int Size() { return sizeof(int) + sizeof(fName
) + sizeof(fPortType
) + 2 * sizeof(unsigned int); }
452 \brief PortRegister result.
455 struct JackPortRegisterResult
: public JackResult
458 jack_port_id_t fPortIndex
;
460 JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT
)
463 int Read(detail::JackChannelTransactionInterface
* trans
)
465 CheckRes(JackResult::Read(trans
));
466 return trans
->Read(&fPortIndex
, sizeof(jack_port_id_t
));
469 int Write(detail::JackChannelTransactionInterface
* trans
)
471 CheckRes(JackResult::Write(trans
));
472 return trans
->Write(&fPortIndex
, sizeof(jack_port_id_t
));
478 \brief PortUnregister request.
481 struct JackPortUnRegisterRequest
: public JackRequest
485 jack_port_id_t fPortIndex
;
487 JackPortUnRegisterRequest()
489 JackPortUnRegisterRequest(int refnum
, jack_port_id_t index
)
490 : JackRequest(JackRequest::kUnRegisterPort
), fRefNum(refnum
), fPortIndex(index
)
493 int Read(detail::JackChannelTransactionInterface
* trans
)
496 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
497 CheckRes(trans
->Read(&fPortIndex
, sizeof(jack_port_id_t
)));
501 int Write(detail::JackChannelTransactionInterface
* trans
)
503 CheckRes(JackRequest::Write(trans
, Size()));
504 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
505 CheckRes(trans
->Write(&fPortIndex
, sizeof(jack_port_id_t
)));
509 int Size() { return sizeof(int) + sizeof(jack_port_id_t
); }
513 \brief PortConnectName request.
516 struct JackPortConnectNameRequest
: public JackRequest
520 char fSrc
[REAL_JACK_PORT_NAME_SIZE
+1]; // port full name
521 char fDst
[REAL_JACK_PORT_NAME_SIZE
+1]; // port full name
523 JackPortConnectNameRequest()
525 JackPortConnectNameRequest(int refnum
, const char* src_name
, const char* dst_name
)
526 : JackRequest(JackRequest::kConnectNamePorts
), fRefNum(refnum
)
528 strcpy(fSrc
, src_name
);
529 strcpy(fDst
, dst_name
);
532 int Read(detail::JackChannelTransactionInterface
* trans
)
535 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
536 CheckRes(trans
->Read(&fSrc
, sizeof(fSrc
)));
537 CheckRes(trans
->Read(&fDst
, sizeof(fDst
)));
541 int Write(detail::JackChannelTransactionInterface
* trans
)
543 CheckRes(JackRequest::Write(trans
, Size()));
544 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
545 CheckRes(trans
->Write(&fSrc
, sizeof(fSrc
)));
546 CheckRes(trans
->Write(&fDst
, sizeof(fDst
)));
550 int Size() { return sizeof(int) + sizeof(fSrc
) + sizeof(fDst
); }
555 \brief PortDisconnectName request.
558 struct JackPortDisconnectNameRequest
: public JackRequest
562 char fSrc
[REAL_JACK_PORT_NAME_SIZE
+1]; // port full name
563 char fDst
[REAL_JACK_PORT_NAME_SIZE
+1]; // port full name
565 JackPortDisconnectNameRequest()
567 JackPortDisconnectNameRequest(int refnum
, const char* src_name
, const char* dst_name
)
568 : JackRequest(JackRequest::kDisconnectNamePorts
), fRefNum(refnum
)
570 strcpy(fSrc
, src_name
);
571 strcpy(fDst
, dst_name
);
574 int Read(detail::JackChannelTransactionInterface
* trans
)
577 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
578 CheckRes(trans
->Read(&fSrc
, sizeof(fSrc
)));
579 CheckRes(trans
->Read(&fDst
, sizeof(fDst
)));
583 int Write(detail::JackChannelTransactionInterface
* trans
)
585 CheckRes(JackRequest::Write(trans
, Size()));
586 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
587 CheckRes(trans
->Write(&fSrc
, sizeof(fSrc
)));
588 CheckRes(trans
->Write(&fDst
, sizeof(fDst
)));
592 int Size() { return sizeof(int) + sizeof(fSrc
) + sizeof(fDst
); }
597 \brief PortConnect request.
600 struct JackPortConnectRequest
: public JackRequest
607 JackPortConnectRequest()
609 JackPortConnectRequest(int refnum
, jack_port_id_t src
, jack_port_id_t dst
)
610 : JackRequest(JackRequest::kConnectPorts
), fRefNum(refnum
), fSrc(src
), fDst(dst
)
613 int Read(detail::JackChannelTransactionInterface
* trans
)
616 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
617 CheckRes(trans
->Read(&fSrc
, sizeof(jack_port_id_t
)));
618 CheckRes(trans
->Read(&fDst
, sizeof(jack_port_id_t
)));
622 int Write(detail::JackChannelTransactionInterface
* trans
)
624 CheckRes(JackRequest::Write(trans
, Size()));
625 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
626 CheckRes(trans
->Write(&fSrc
, sizeof(jack_port_id_t
)));
627 CheckRes(trans
->Write(&fDst
, sizeof(jack_port_id_t
)));
631 int Size() { return sizeof(int) + sizeof(jack_port_id_t
) + sizeof(jack_port_id_t
); }
635 \brief PortDisconnect request.
638 struct JackPortDisconnectRequest
: public JackRequest
645 JackPortDisconnectRequest()
647 JackPortDisconnectRequest(int refnum
, jack_port_id_t src
, jack_port_id_t dst
)
648 : JackRequest(JackRequest::kDisconnectPorts
), fRefNum(refnum
), fSrc(src
), fDst(dst
)
651 int Read(detail::JackChannelTransactionInterface
* trans
)
654 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
655 CheckRes(trans
->Read(&fSrc
, sizeof(jack_port_id_t
)));
656 CheckRes(trans
->Read(&fDst
, sizeof(jack_port_id_t
)));
660 int Write(detail::JackChannelTransactionInterface
* trans
)
662 CheckRes(JackRequest::Write(trans
, Size()));
663 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
664 CheckRes(trans
->Write(&fSrc
, sizeof(jack_port_id_t
)));
665 CheckRes(trans
->Write(&fDst
, sizeof(jack_port_id_t
)));
669 int Size() { return sizeof(int) + sizeof(jack_port_id_t
) + sizeof(jack_port_id_t
); }
673 \brief PortRename request.
676 struct JackPortRenameRequest
: public JackRequest
680 jack_port_id_t fPort
;
681 char fName
[JACK_PORT_NAME_SIZE
+ 1]; // port short name
683 JackPortRenameRequest()
685 JackPortRenameRequest(int refnum
, jack_port_id_t port
, const char* name
)
686 : JackRequest(JackRequest::kPortRename
), fRefNum(refnum
), fPort(port
)
691 int Read(detail::JackChannelTransactionInterface
* trans
)
694 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
695 CheckRes(trans
->Read(&fPort
, sizeof(jack_port_id_t
)));
696 CheckRes(trans
->Read(&fName
, sizeof(fName
)));
700 int Write(detail::JackChannelTransactionInterface
* trans
)
702 CheckRes(JackRequest::Write(trans
, Size()));
703 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
704 CheckRes(trans
->Write(&fPort
, sizeof(jack_port_id_t
)));
705 CheckRes(trans
->Write(&fName
, sizeof(fName
)));
709 int Size() { return sizeof(int) + sizeof(jack_port_id_t
) + sizeof(fName
); }
714 \brief SetBufferSize request.
717 struct JackSetBufferSizeRequest
: public JackRequest
720 jack_nframes_t fBufferSize
;
722 JackSetBufferSizeRequest()
724 JackSetBufferSizeRequest(jack_nframes_t buffer_size
)
725 : JackRequest(JackRequest::kSetBufferSize
), fBufferSize(buffer_size
)
728 int Read(detail::JackChannelTransactionInterface
* trans
)
731 return trans
->Read(&fBufferSize
, sizeof(jack_nframes_t
));
734 int Write(detail::JackChannelTransactionInterface
* trans
)
736 CheckRes(JackRequest::Write(trans
, Size()));
737 return trans
->Write(&fBufferSize
, sizeof(jack_nframes_t
));
740 int Size() { return sizeof(jack_nframes_t
); }
744 \brief SetFreeWheel request.
747 struct JackSetFreeWheelRequest
: public JackRequest
752 JackSetFreeWheelRequest()
754 JackSetFreeWheelRequest(int onoff
)
755 : JackRequest(JackRequest::kSetFreeWheel
), fOnOff(onoff
)
758 int Read(detail::JackChannelTransactionInterface
* trans
)
761 return trans
->Read(&fOnOff
, sizeof(int));
764 int Write(detail::JackChannelTransactionInterface
* trans
)
766 CheckRes(JackRequest::Write(trans
, Size()));
767 return trans
->Write(&fOnOff
, sizeof(int));
770 int Size() { return sizeof(int); }
775 \brief ComputeTotalLatencies request.
778 struct JackComputeTotalLatenciesRequest
: public JackRequest
781 JackComputeTotalLatenciesRequest()
782 : JackRequest(JackRequest::kComputeTotalLatencies
)
785 int Read(detail::JackChannelTransactionInterface
* trans
)
791 int Write(detail::JackChannelTransactionInterface
* trans
)
793 CheckRes(JackRequest::Write(trans
, Size()));
797 int Size() { return 0; }
801 \brief ReleaseTimebase request.
804 struct JackReleaseTimebaseRequest
: public JackRequest
809 JackReleaseTimebaseRequest()
811 JackReleaseTimebaseRequest(int refnum
)
812 : JackRequest(JackRequest::kReleaseTimebase
), fRefNum(refnum
)
815 int Read(detail::JackChannelTransactionInterface
* trans
)
818 return trans
->Read(&fRefNum
, sizeof(int));
821 int Write(detail::JackChannelTransactionInterface
* trans
)
823 CheckRes(JackRequest::Write(trans
, Size()));
824 return trans
->Write(&fRefNum
, sizeof(int));
827 int Size() { return sizeof(int); }
832 \brief SetTimebaseCallback request.
835 struct JackSetTimebaseCallbackRequest
: public JackRequest
841 JackSetTimebaseCallbackRequest()
843 JackSetTimebaseCallbackRequest(int refnum
, int conditional
)
844 : JackRequest(JackRequest::kSetTimebaseCallback
), fRefNum(refnum
), fConditionnal(conditional
)
847 int Read(detail::JackChannelTransactionInterface
* trans
)
850 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
851 return trans
->Read(&fConditionnal
, sizeof(int));
854 int Write(detail::JackChannelTransactionInterface
* trans
)
856 CheckRes(JackRequest::Write(trans
, Size()));
857 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
858 return trans
->Write(&fConditionnal
, sizeof(int));
861 int Size() { return sizeof(int) + sizeof(int); }
865 \brief GetInternalClientName request.
868 struct JackGetInternalClientNameRequest
: public JackRequest
874 JackGetInternalClientNameRequest()
876 JackGetInternalClientNameRequest(int refnum
, int int_ref
)
877 : JackRequest(JackRequest::kGetInternalClientName
), fRefNum(refnum
), fIntRefNum(int_ref
)
880 int Read(detail::JackChannelTransactionInterface
* trans
)
883 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
884 return trans
->Read(&fIntRefNum
, sizeof(int));
887 int Write(detail::JackChannelTransactionInterface
* trans
)
889 CheckRes(JackRequest::Write(trans
, Size()));
890 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
891 return trans
->Write(&fIntRefNum
, sizeof(int));
894 int Size() { return sizeof(int) + sizeof(int); }
898 \brief GetInternalClient result.
901 struct JackGetInternalClientNameResult
: public JackResult
904 char fName
[JACK_CLIENT_NAME_SIZE
+1];
906 JackGetInternalClientNameResult(): JackResult()
908 JackGetInternalClientNameResult(int32_t result
, const char* name
)
911 snprintf(fName
, sizeof(fName
), "%s", name
);
914 int Read(detail::JackChannelTransactionInterface
* trans
)
916 CheckRes(JackResult::Read(trans
));
917 CheckRes(trans
->Read(&fName
, sizeof(fName
)));
921 int Write(detail::JackChannelTransactionInterface
* trans
)
923 CheckRes(JackResult::Write(trans
));
924 CheckRes(trans
->Write(&fName
, sizeof(fName
)));
928 int Size() { return sizeof(fName
); }
932 \brief InternalClientHandle request.
935 struct JackInternalClientHandleRequest
: public JackRequest
939 char fName
[JACK_CLIENT_NAME_SIZE
+1];
941 JackInternalClientHandleRequest()
943 JackInternalClientHandleRequest(int refnum
, const char* client_name
)
944 : JackRequest(JackRequest::kInternalClientHandle
), fRefNum(refnum
)
946 snprintf(fName
, sizeof(fName
), "%s", client_name
);
949 int Read(detail::JackChannelTransactionInterface
* trans
)
952 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
953 return trans
->Read(&fName
, sizeof(fName
));
956 int Write(detail::JackChannelTransactionInterface
* trans
)
958 CheckRes(JackRequest::Write(trans
, Size()));
959 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
960 return trans
->Write(&fName
, sizeof(fName
));
963 int Size() { return sizeof(int) + sizeof(fName
); }
967 \brief InternalClientHandle result.
970 struct JackInternalClientHandleResult
: public JackResult
976 JackInternalClientHandleResult(): JackResult()
978 JackInternalClientHandleResult(int32_t result
, int status
, int int_ref
)
979 : JackResult(result
), fStatus(status
), fIntRefNum(int_ref
)
982 int Read(detail::JackChannelTransactionInterface
* trans
)
984 CheckRes(JackResult::Read(trans
));
985 CheckRes(trans
->Read(&fStatus
, sizeof(int)));
986 CheckRes(trans
->Read(&fIntRefNum
, sizeof(int)));
990 int Write(detail::JackChannelTransactionInterface
* trans
)
992 CheckRes(JackResult::Write(trans
));
993 CheckRes(trans
->Write(&fStatus
, sizeof(int)));
994 CheckRes(trans
->Write(&fIntRefNum
, sizeof(int)));
998 int Size() { return sizeof(int) + sizeof(int); }
1002 \brief InternalClientLoad request.
1005 struct JackInternalClientLoadRequest
: public JackRequest
1009 #define MAX_PATH 256
1013 char fName
[JACK_CLIENT_NAME_SIZE
+1];
1014 char fDllName
[MAX_PATH
+1];
1015 char fLoadInitName
[JACK_LOAD_INIT_LIMIT
+1];
1019 JackInternalClientLoadRequest()
1021 JackInternalClientLoadRequest(int refnum
, const char* client_name
, const char* so_name
, const char* objet_data
, int options
, int uuid
)
1022 : JackRequest(JackRequest::kInternalClientLoad
), fRefNum(refnum
), fOptions(options
), fUUID(uuid
)
1024 snprintf(fName
, sizeof(fName
), "%s", client_name
);
1025 snprintf(fDllName
, sizeof(fDllName
), "%s", so_name
);
1026 snprintf(fLoadInitName
, sizeof(fLoadInitName
), "%s", objet_data
);
1027 snprintf(fLoadInitName
, sizeof(fLoadInitName
), "%s", objet_data
);
1030 int Read(detail::JackChannelTransactionInterface
* trans
)
1033 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
1034 CheckRes(trans
->Read(&fName
, sizeof(fName
)));
1035 CheckRes(trans
->Read(&fDllName
, sizeof(fDllName
)));
1036 CheckRes(trans
->Read(&fLoadInitName
, sizeof(fLoadInitName
)));
1037 CheckRes(trans
->Read(&fUUID
, sizeof(int)));
1038 return trans
->Read(&fOptions
, sizeof(int));
1041 int Write(detail::JackChannelTransactionInterface
* trans
)
1043 CheckRes(JackRequest::Write(trans
, Size()));
1044 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
1045 CheckRes(trans
->Write(&fName
, sizeof(fName
)));
1046 CheckRes(trans
->Write(&fDllName
, sizeof(fDllName
)));
1047 CheckRes(trans
->Write(&fLoadInitName
, sizeof(fLoadInitName
)));
1048 CheckRes(trans
->Write(&fUUID
, sizeof(int)));
1049 return trans
->Write(&fOptions
, sizeof(int));
1052 int Size() { return sizeof(int) + sizeof(fName
) + sizeof(fDllName
) + sizeof(fLoadInitName
) + 2 * sizeof(int); }
1056 \brief InternalClientLoad result.
1059 struct JackInternalClientLoadResult
: public JackResult
1065 JackInternalClientLoadResult(): JackResult()
1067 JackInternalClientLoadResult(int32_t result
, int status
, int int_ref
)
1068 : JackResult(result
), fStatus(status
), fIntRefNum(int_ref
)
1071 int Read(detail::JackChannelTransactionInterface
* trans
)
1073 CheckRes(JackResult::Read(trans
));
1074 CheckRes(trans
->Read(&fStatus
, sizeof(int)));
1075 CheckRes(trans
->Read(&fIntRefNum
, sizeof(int)));
1079 int Write(detail::JackChannelTransactionInterface
* trans
)
1081 CheckRes(JackResult::Write(trans
));
1082 CheckRes(trans
->Write(&fStatus
, sizeof(int)));
1083 CheckRes(trans
->Write(&fIntRefNum
, sizeof(int)));
1087 int Size() { return sizeof(int) + sizeof(int); }
1091 \brief InternalClientUnload request.
1094 struct JackInternalClientUnloadRequest
: public JackRequest
1100 JackInternalClientUnloadRequest()
1102 JackInternalClientUnloadRequest(int refnum
, int int_ref
)
1103 : JackRequest(JackRequest::kInternalClientUnload
), fRefNum(refnum
), fIntRefNum(int_ref
)
1106 int Read(detail::JackChannelTransactionInterface
* trans
)
1109 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
1110 return trans
->Read(&fIntRefNum
, sizeof(int));
1113 int Write(detail::JackChannelTransactionInterface
* trans
)
1115 CheckRes(JackRequest::Write(trans
, Size()));
1116 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
1117 return trans
->Write(&fIntRefNum
, sizeof(int));
1120 int Size() { return sizeof(int) + sizeof(int); }
1124 \brief InternalClientLoad result.
1127 struct JackInternalClientUnloadResult
: public JackResult
1132 JackInternalClientUnloadResult(): JackResult()
1134 JackInternalClientUnloadResult(int32_t result
, int status
)
1135 : JackResult(result
), fStatus(status
)
1138 int Read(detail::JackChannelTransactionInterface
* trans
)
1140 CheckRes(JackResult::Read(trans
));
1141 CheckRes(trans
->Read(&fStatus
, sizeof(int)));
1145 int Write(detail::JackChannelTransactionInterface
* trans
)
1147 CheckRes(JackResult::Write(trans
));
1148 CheckRes(trans
->Write(&fStatus
, sizeof(int)));
1152 int Size() { return sizeof(int); }
1156 \brief ClientNotification request.
1159 struct JackClientNotificationRequest
: public JackRequest
1166 JackClientNotificationRequest()
1168 JackClientNotificationRequest(int refnum
, int notify
, int value
)
1169 : JackRequest(JackRequest::kNotification
), fRefNum(refnum
), fNotify(notify
), fValue(value
)
1172 int Read(detail::JackChannelTransactionInterface
* trans
)
1175 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
1176 CheckRes(trans
->Read(&fNotify
, sizeof(int)));
1177 CheckRes(trans
->Read(&fValue
, sizeof(int)));
1181 int Write(detail::JackChannelTransactionInterface
* trans
)
1183 CheckRes(JackRequest::Write(trans
, Size()));
1184 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
1185 CheckRes(trans
->Write(&fNotify
, sizeof(int)));
1186 CheckRes(trans
->Write(&fValue
, sizeof(int)));
1190 int Size() { return 3 * sizeof(int); }
1194 struct JackSessionCommand
1196 char fUUID
[JACK_UUID_SIZE
];
1197 char fClientName
[JACK_CLIENT_NAME_SIZE
+1];
1198 char fCommand
[JACK_SESSION_COMMAND_SIZE
];
1199 jack_session_flags_t fFlags
;
1201 JackSessionCommand()
1204 JackSessionCommand(const char *uuid
, const char *clientname
, const char *command
, jack_session_flags_t flags
)
1206 strncpy(fUUID
, uuid
, sizeof(fUUID
));
1207 strncpy(fClientName
, clientname
, sizeof(fClientName
));
1208 strncpy(fCommand
, command
, sizeof(fCommand
));
1213 struct JackSessionNotifyResult
: public JackResult
1216 std::list
<JackSessionCommand
> fCommandList
;
1219 JackSessionNotifyResult(): JackResult(), fDone(false)
1221 JackSessionNotifyResult(int32_t result
)
1222 : JackResult(result
), fDone(false)
1225 int Read(detail::JackChannelTransactionInterface
* trans
)
1232 CheckRes(JackResult::Read(trans
));
1234 JackSessionCommand buffer
;
1236 CheckRes(trans
->Read(buffer
.fUUID
, sizeof(buffer
.fUUID
)));
1237 if (buffer
.fUUID
[0] == '\0')
1240 CheckRes(trans
->Read(buffer
.fClientName
, sizeof(buffer
.fClientName
)));
1241 CheckRes(trans
->Read(buffer
.fCommand
, sizeof(buffer
.fCommand
)));
1242 CheckRes(trans
->Read(&(buffer
.fFlags
), sizeof(buffer
.fFlags
)));
1244 fCommandList
.push_back(buffer
);
1252 int Write(detail::JackChannelTransactionInterface
* trans
)
1260 char terminator
[JACK_UUID_SIZE
];
1261 terminator
[0] = '\0';
1263 CheckRes(JackResult::Write(trans
));
1264 for (std::list
<JackSessionCommand
>::iterator i
= fCommandList
.begin(); i
!= fCommandList
.end(); i
++) {
1265 CheckRes(trans
->Write(i
->fUUID
, sizeof(i
->fUUID
)));
1266 CheckRes(trans
->Write(i
->fClientName
, sizeof(i
->fClientName
)));
1267 CheckRes(trans
->Write(i
->fCommand
, sizeof(i
->fCommand
)));
1268 CheckRes(trans
->Write(&(i
->fFlags
), sizeof(i
->fFlags
)));
1270 CheckRes(trans
->Write(terminator
, sizeof(terminator
)));
1274 jack_session_command_t
* GetCommands()
1276 /* TODO: some kind of signal should be used instead */
1279 JackSleep(50000); /* 50 ms */
1282 jack_session_command_t
* session_command
= (jack_session_command_t
*)malloc(sizeof(jack_session_command_t
) * (fCommandList
.size() + 1));
1285 for (std::list
<JackSessionCommand
>::iterator ci
= fCommandList
.begin(); ci
!= fCommandList
.end(); ci
++) {
1286 session_command
[i
].uuid
= strdup(ci
->fUUID
);
1287 session_command
[i
].client_name
= strdup(ci
->fClientName
);
1288 session_command
[i
].command
= strdup(ci
->fCommand
);
1289 session_command
[i
].flags
= ci
->fFlags
;
1293 session_command
[i
].uuid
= NULL
;
1294 session_command
[i
].client_name
= NULL
;
1295 session_command
[i
].command
= NULL
;
1296 session_command
[i
].flags
= (jack_session_flags_t
)0;
1298 return session_command
;
1303 \brief SessionNotify request.
1306 struct JackSessionNotifyRequest
: public JackRequest
1308 char fPath
[JACK_MESSAGE_SIZE
+1];
1309 char fDst
[JACK_CLIENT_NAME_SIZE
+1];
1310 jack_session_event_type_t fEventType
;
1313 JackSessionNotifyRequest()
1315 JackSessionNotifyRequest(int refnum
, const char* path
, jack_session_event_type_t type
, const char* dst
)
1316 : JackRequest(JackRequest::kSessionNotify
), fEventType(type
), fRefNum(refnum
)
1318 snprintf(fPath
, sizeof(fPath
), "%s", path
);
1320 snprintf(fDst
, sizeof(fDst
), "%s", dst
);
1326 int Read(detail::JackChannelTransactionInterface
* trans
)
1329 CheckRes(trans
->Read(&fRefNum
, sizeof(fRefNum
)));
1330 CheckRes(trans
->Read(&fPath
, sizeof(fPath
)));
1331 CheckRes(trans
->Read(&fDst
, sizeof(fDst
)));
1332 CheckRes(trans
->Read(&fEventType
, sizeof(fEventType
)));
1336 int Write(detail::JackChannelTransactionInterface
* trans
)
1338 CheckRes(JackRequest::Write(trans
, Size()));
1339 CheckRes(trans
->Write(&fRefNum
, sizeof(fRefNum
)));
1340 CheckRes(trans
->Write(&fPath
, sizeof(fPath
)));
1341 CheckRes(trans
->Write(&fDst
, sizeof(fDst
)));
1342 CheckRes(trans
->Write(&fEventType
, sizeof(fEventType
)));
1346 int Size() { return sizeof(fRefNum
) + sizeof(fPath
) + sizeof(fDst
) + sizeof(fEventType
); }
1349 struct JackSessionReplyRequest
: public JackRequest
1353 JackSessionReplyRequest()
1356 JackSessionReplyRequest(int refnum
)
1357 : JackRequest(JackRequest::kSessionReply
), fRefNum(refnum
)
1360 int Read(detail::JackChannelTransactionInterface
* trans
)
1363 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
1367 int Write(detail::JackChannelTransactionInterface
* trans
)
1369 CheckRes(JackRequest::Write(trans
, Size()));
1370 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
1374 int Size() { return sizeof(int); }
1378 struct JackClientNameResult
: public JackResult
1380 char fName
[JACK_CLIENT_NAME_SIZE
+1];
1382 JackClientNameResult(): JackResult()
1384 JackClientNameResult(int32_t result
, const char* name
)
1385 : JackResult(result
)
1387 snprintf(fName
, sizeof(fName
), "%s", name
);
1390 int Read(detail::JackChannelTransactionInterface
* trans
)
1392 CheckRes(JackResult::Read(trans
));
1393 CheckRes(trans
->Read(&fName
, sizeof(fName
)));
1397 int Write(detail::JackChannelTransactionInterface
* trans
)
1399 CheckRes(JackResult::Write(trans
));
1400 CheckRes(trans
->Write(&fName
, sizeof(fName
)));
1406 struct JackUUIDResult
: public JackResult
1408 char fUUID
[JACK_UUID_SIZE
];
1410 JackUUIDResult(): JackResult()
1412 JackUUIDResult(int32_t result
, const char* uuid
)
1413 : JackResult(result
)
1415 snprintf(fUUID
, sizeof(fUUID
), "%s", uuid
);
1418 int Read(detail::JackChannelTransactionInterface
* trans
)
1420 CheckRes(JackResult::Read(trans
));
1421 CheckRes(trans
->Read(&fUUID
, sizeof(fUUID
)));
1425 int Write(detail::JackChannelTransactionInterface
* trans
)
1427 CheckRes(JackResult::Write(trans
));
1428 CheckRes(trans
->Write(&fUUID
, sizeof(fUUID
)));
1434 struct JackGetUUIDRequest
: public JackRequest
1436 char fName
[JACK_CLIENT_NAME_SIZE
+1];
1438 JackGetUUIDRequest()
1441 JackGetUUIDRequest(const char* client_name
)
1442 : JackRequest(JackRequest::kGetUUIDByClient
)
1444 strncpy(fName
, client_name
, sizeof(fName
));
1447 int Read(detail::JackChannelTransactionInterface
* trans
)
1450 CheckRes(trans
->Read(&fName
, sizeof(fName
)));
1454 int Write(detail::JackChannelTransactionInterface
* trans
)
1456 CheckRes(JackRequest::Write(trans
, Size()));
1457 CheckRes(trans
->Write(&fName
, sizeof(fName
)));
1461 int Size() { return sizeof(fName
); }
1465 struct JackGetClientNameRequest
: public JackRequest
1467 char fUUID
[JACK_UUID_SIZE
];
1469 JackGetClientNameRequest()
1472 JackGetClientNameRequest(const char* uuid
)
1473 : JackRequest(JackRequest::kGetClientByUUID
)
1475 strncpy(fUUID
, uuid
, sizeof(fUUID
));
1478 int Read(detail::JackChannelTransactionInterface
* trans
)
1481 CheckRes(trans
->Read(&fUUID
, sizeof(fUUID
)));
1485 int Write(detail::JackChannelTransactionInterface
* trans
)
1487 CheckRes(JackRequest::Write(trans
, Size()));
1488 CheckRes(trans
->Write(&fUUID
, sizeof(fUUID
)));
1492 int Size() { return sizeof(fUUID
); }
1496 struct JackReserveNameRequest
: public JackRequest
1499 char fName
[JACK_CLIENT_NAME_SIZE
+1];
1500 char fUUID
[JACK_UUID_SIZE
];
1502 JackReserveNameRequest()
1505 JackReserveNameRequest(int refnum
, const char *name
, const char* uuid
)
1506 : JackRequest(JackRequest::kReserveClientName
), fRefNum(refnum
)
1508 strncpy(fName
, name
, sizeof(fName
));
1509 strncpy(fUUID
, uuid
, sizeof(fUUID
));
1512 int Read(detail::JackChannelTransactionInterface
* trans
)
1515 CheckRes(trans
->Read(&fUUID
, sizeof(fUUID
)));
1516 CheckRes(trans
->Read(&fName
, sizeof(fName
)));
1517 CheckRes(trans
->Read(&fRefNum
, sizeof(fRefNum
)));
1521 int Write(detail::JackChannelTransactionInterface
* trans
)
1523 CheckRes(JackRequest::Write(trans
, Size()));
1524 CheckRes(trans
->Write(&fUUID
, sizeof(fUUID
)));
1525 CheckRes(trans
->Write(&fName
, sizeof(fName
)));
1526 CheckRes(trans
->Write(&fRefNum
, sizeof(fRefNum
)));
1530 int Size() { return sizeof(fUUID
) + sizeof(fName
) + sizeof(fRefNum
); }
1534 struct JackClientHasSessionCallbackRequest
: public JackRequest
1536 char fName
[JACK_CLIENT_NAME_SIZE
+1];
1538 JackClientHasSessionCallbackRequest()
1541 JackClientHasSessionCallbackRequest(const char *name
)
1542 : JackRequest(JackRequest::kClientHasSessionCallback
)
1544 strncpy(fName
, name
, sizeof(fName
));
1547 int Read(detail::JackChannelTransactionInterface
* trans
)
1550 CheckRes(trans
->Read(&fName
, sizeof(fName
)));
1554 int Write(detail::JackChannelTransactionInterface
* trans
)
1556 CheckRes(JackRequest::Write(trans
, Size()));
1557 CheckRes(trans
->Write(&fName
, sizeof(fName
)));
1561 int Size() { return sizeof(fName
); }
1566 \brief ClientNotification.
1569 struct JackClientNotification
1572 char fName
[JACK_CLIENT_NAME_SIZE
+1];
1578 char fMessage
[JACK_MESSAGE_SIZE
+1];
1580 JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)
1582 JackClientNotification(const char* name
, int refnum
, int notify
, int sync
, const char* message
, int value1
, int value2
)
1583 : fRefNum(refnum
), fNotify(notify
), fValue1(value1
), fValue2(value2
), fSync(sync
)
1585 snprintf(fName
, sizeof(fName
), "%s", name
);
1586 snprintf(fMessage
, sizeof(fMessage
), "%s", message
);
1590 int Read(detail::JackChannelTransactionInterface
* trans
)
1593 CheckRes(trans
->Read(&fName
, sizeof(fName
)));
1594 CheckRes(trans
->Read(&fRefNum
, sizeof(int)));
1595 CheckRes(trans
->Read(&fNotify
, sizeof(int)));
1596 CheckRes(trans
->Read(&fValue1
, sizeof(int)));
1597 CheckRes(trans
->Read(&fValue2
, sizeof(int)));
1598 CheckRes(trans
->Read(&fSync
, sizeof(int)));
1599 CheckRes(trans
->Read(&fMessage
, sizeof(fMessage
)));
1603 int Write(detail::JackChannelTransactionInterface
* trans
)
1605 CheckRes(trans
->Write(&fSize
, sizeof(int)));
1606 CheckRes(trans
->Write(&fName
, sizeof(fName
)));
1607 CheckRes(trans
->Write(&fRefNum
, sizeof(int)));
1608 CheckRes(trans
->Write(&fNotify
, sizeof(int)));
1609 CheckRes(trans
->Write(&fValue1
, sizeof(int)));
1610 CheckRes(trans
->Write(&fValue2
, sizeof(int)));
1611 CheckRes(trans
->Write(&fSync
, sizeof(int)));
1612 CheckRes(trans
->Write(&fMessage
, sizeof(fMessage
)));
1616 int Size() { return sizeof(int) + sizeof(fName
) + 5 * sizeof(int) + sizeof(fMessage
); }
1620 } // end of namespace