Jack2  1.9.9
JackRequest.h
1 /*
2 Copyright (C) 2001 Paul Davis
3 Copyright (C) 2004-2008 Grame
4 
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.
9 
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.
14 
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.
18 
19 */
20 
21 #ifndef __JackRequest__
22 #define __JackRequest__
23 
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>
34 
35 namespace Jack
36 {
37 
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; } }
40 
45 enum JackSessionReply {
46 
47  kImmediateSessionReply = 1,
48  kPendingSessionReply = 2
49 
50 };
51 
57 {
58 
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  };
94 
95  RequestType fType;
96  int fSize;
97 
98  JackRequest(): fType((RequestType)0), fSize(0)
99  {}
100 
101  JackRequest(RequestType type): fType(type), fSize(0)
102  {}
103 
104  virtual ~JackRequest()
105  {}
106 
107  virtual int Read(detail::JackChannelTransactionInterface* trans)
108  {
109  return trans->Read(&fType, sizeof(RequestType));
110  }
111 
112  virtual int Write(detail::JackChannelTransactionInterface* trans) { return -1; }
113 
114  virtual int Write(detail::JackChannelTransactionInterface* trans, int size)
115  {
116  fSize = size;
117  CheckRes(trans->Write(&fType, sizeof(RequestType)));
118  return trans->Write(&fSize, sizeof(int));
119  }
120 
121  virtual int Size() { return 0; }
122 
123 };
124 
130 {
131 
132  int fResult;
133 
134  JackResult(): fResult( -1)
135  {}
136  JackResult(int result): fResult(result)
137  {}
138  virtual ~JackResult()
139  {}
140 
141  virtual int Read(detail::JackChannelTransactionInterface* trans)
142  {
143  return trans->Read(&fResult, sizeof(int));
144  }
145 
146  virtual int Write(detail::JackChannelTransactionInterface* trans)
147  {
148  return trans->Write(&fResult, sizeof(int));
149  }
150 
151 };
152 
158 {
159 
160  char fName[JACK_CLIENT_NAME_SIZE + 1];
161  int fProtocol;
162  int fOptions;
163  int fUUID;
164  int fOpen;
165 
167  {}
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)
170  {
171  snprintf(fName, sizeof(fName), "%s", name);
172  }
173 
175  {
176  CheckSize();
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));
182  }
183 
185  {
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));
192  }
193 
194  int Size() { return sizeof(fName) + 4 * sizeof(int); }
195 
196 };
197 
203 {
204 
205  char fName[JACK_CLIENT_NAME_SIZE + 1];
206  int fStatus;
207 
208  JackClientCheckResult(): JackResult(), fStatus(0)
209  {}
210  JackClientCheckResult(int32_t result, const char* name, int status)
211  : JackResult(result), fStatus(status)
212  {
213  snprintf(fName, sizeof(fName), "%s", name);
214  }
215 
217  {
218  CheckRes(JackResult::Read(trans));
219  CheckRes(trans->Read(&fName, sizeof(fName)));
220  CheckRes(trans->Read(&fStatus, sizeof(int)));
221  return 0;
222  }
223 
225  {
226  CheckRes(JackResult::Write(trans));
227  CheckRes(trans->Write(&fName, sizeof(fName)));
228  CheckRes(trans->Write(&fStatus, sizeof(int)));
229  return 0;
230  }
231 
232 };
233 
239 {
240 
241  int fPID;
242  int fUUID;
243  char fName[JACK_CLIENT_NAME_SIZE + 1];
244 
246  {}
247  JackClientOpenRequest(const char* name, int pid, int uuid): JackRequest(JackRequest::kClientOpen)
248  {
249  snprintf(fName, sizeof(fName), "%s", name);
250  fPID = pid;
251  fUUID = uuid;
252  }
253 
255  {
256  CheckSize();
257  CheckRes(trans->Read(&fPID, sizeof(int)));
258  CheckRes(trans->Read(&fUUID, sizeof(int)));
259  return trans->Read(&fName, sizeof(fName));
260  }
261 
263  {
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));
268  }
269 
270  int Size() { return 2 * sizeof(int) + sizeof(fName); }
271 
272 };
273 
279 {
280 
281  int fSharedEngine;
282  int fSharedClient;
283  int fSharedGraph;
284 
286  : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
287  {}
288  JackClientOpenResult(int32_t result, int index1, int index2, int index3)
289  : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
290  {}
291 
293  {
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)));
298  return 0;
299  }
300 
302  {
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)));
307  return 0;
308  }
309 
310 };
311 
317 {
318 
319  int fRefNum;
320 
322  {}
323  JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
324  {}
325 
327  {
328  CheckSize();
329  return trans->Read(&fRefNum, sizeof(int));
330  }
331 
333  {
334  CheckRes(JackRequest::Write(trans, Size()));
335  return trans->Write(&fRefNum, sizeof(int));
336  }
337 
338  int Size() { return sizeof(int); }
339 };
340 
346 {
347 
348  int fRefNum;
349  int fIsRealTime;
350 
352  {}
353  JackActivateRequest(int refnum, int is_real_time)
354  : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fIsRealTime(is_real_time)
355  {}
356 
358  {
359  CheckSize();
360  CheckRes(trans->Read(&fRefNum, sizeof(int)));
361  return trans->Read(&fIsRealTime, sizeof(int));
362  }
363 
365  {
366  CheckRes(JackRequest::Write(trans, Size()));
367  CheckRes(trans->Write(&fRefNum, sizeof(int)));
368  return trans->Write(&fIsRealTime, sizeof(int));
369  }
370 
371  int Size() { return 2 * sizeof(int); }
372 };
373 
379 {
380 
381  int fRefNum;
382 
384  {}
385  JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
386  {}
387 
389  {
390  CheckSize();
391  return trans->Read(&fRefNum, sizeof(int));
392  }
393 
395  {
396  CheckRes(JackRequest::Write(trans, Size()));
397  return trans->Write(&fRefNum, sizeof(int));
398  }
399 
400  int Size() { return sizeof(int); }
401 };
402 
408 {
409 
410  int fRefNum;
411  char fName[JACK_PORT_NAME_SIZE + 1];
412  char fPortType[JACK_PORT_TYPE_SIZE + 1];
413  unsigned int fFlags;
414  unsigned int fBufferSize;
415 
417  {}
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)
420  {
421  strcpy(fName, name);
422  strcpy(fPortType, port_type);
423  }
424 
426  {
427  CheckSize();
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)));
433  return 0;
434  }
435 
437  {
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)));
444  return 0;
445  }
446 
447  int Size() { return sizeof(int) + sizeof(fName) + sizeof(fPortType) + 2 * sizeof(unsigned int); }
448 
449 };
450 
456 {
457 
458  jack_port_id_t fPortIndex;
459 
460  JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
461  {}
462 
464  {
465  CheckRes(JackResult::Read(trans));
466  return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
467  }
468 
470  {
471  CheckRes(JackResult::Write(trans));
472  return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
473  }
474 
475 };
476 
482 {
483 
484  int fRefNum;
485  jack_port_id_t fPortIndex;
486 
488  {}
489  JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
490  : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
491  {}
492 
494  {
495  CheckSize();
496  CheckRes(trans->Read(&fRefNum, sizeof(int)));
497  CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
498  return 0;
499  }
500 
502  {
503  CheckRes(JackRequest::Write(trans, Size()));
504  CheckRes(trans->Write(&fRefNum, sizeof(int)));
505  CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
506  return 0;
507  }
508 
509  int Size() { return sizeof(int) + sizeof(jack_port_id_t); }
510 };
511 
517 {
518 
519  int fRefNum;
520  char fSrc[JACK_PORT_NAME_SIZE + 1];
521  char fDst[JACK_PORT_NAME_SIZE + 1];
522 
524  {}
525  JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
526  : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
527  {
528  strcpy(fSrc, src_name);
529  strcpy(fDst, dst_name);
530  }
531 
533  {
534  CheckSize();
535  CheckRes(trans->Read(&fRefNum, sizeof(int)));
536  CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
537  CheckRes(trans->Read(&fDst, sizeof(fDst)));
538  return 0;
539  }
540 
542  {
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)));
547  return 0;
548  }
549 
550  int Size() { return sizeof(int) + sizeof(fSrc) + sizeof(fDst); }
551 
552 };
553 
559 {
560 
561  int fRefNum;
562  char fSrc[JACK_PORT_NAME_SIZE + 1];
563  char fDst[JACK_PORT_NAME_SIZE + 1];
564 
566  {}
567  JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
568  : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
569  {
570  strcpy(fSrc, src_name);
571  strcpy(fDst, dst_name);
572  }
573 
575  {
576  CheckSize();
577  CheckRes(trans->Read(&fRefNum, sizeof(int)));
578  CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
579  CheckRes(trans->Read(&fDst, sizeof(fDst)));
580  return 0;
581  }
582 
584  {
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)));
589  return 0;
590  }
591 
592  int Size() { return sizeof(int) + sizeof(fSrc) + sizeof(fDst); }
593 
594 };
595 
601 {
602 
603  int fRefNum;
604  jack_port_id_t fSrc;
605  jack_port_id_t fDst;
606 
608  {}
609  JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
610  : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
611  {}
612 
614  {
615  CheckSize();
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)));
619  return 0;
620  }
621 
623  {
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)));
628  return 0;
629  }
630 
631  int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(jack_port_id_t); }
632 };
633 
639 {
640 
641  int fRefNum;
642  jack_port_id_t fSrc;
643  jack_port_id_t fDst;
644 
646  {}
647  JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
648  : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
649  {}
650 
652  {
653  CheckSize();
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)));
657  return 0;
658  }
659 
661  {
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)));
666  return 0;
667  }
668 
669  int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(jack_port_id_t); }
670 };
671 
677 {
678 
679  int fRefNum;
680  jack_port_id_t fPort;
681  char fName[JACK_PORT_NAME_SIZE + 1];
682 
684  {}
685  JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
686  : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
687  {
688  strcpy(fName, name);
689  }
690 
692  {
693  CheckSize();
694  CheckRes(trans->Read(&fRefNum, sizeof(int)));
695  CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
696  CheckRes(trans->Read(&fName, sizeof(fName)));
697  return 0;
698  }
699 
701  {
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)));
706  return 0;
707  }
708 
709  int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(fName); }
710 
711 };
712 
718 {
719 
720  jack_nframes_t fBufferSize;
721 
723  {}
724  JackSetBufferSizeRequest(jack_nframes_t buffer_size)
725  : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
726  {}
727 
729  {
730  CheckSize();
731  return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
732  }
733 
735  {
736  CheckRes(JackRequest::Write(trans, Size()));
737  return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
738  }
739 
740  int Size() { return sizeof(jack_nframes_t); }
741 };
742 
748 {
749 
750  int fOnOff;
751 
753  {}
754  JackSetFreeWheelRequest(int onoff)
755  : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
756  {}
757 
759  {
760  CheckSize();
761  return trans->Read(&fOnOff, sizeof(int));
762  }
763 
765  {
766  CheckRes(JackRequest::Write(trans, Size()));
767  return trans->Write(&fOnOff, sizeof(int));
768  }
769 
770  int Size() { return sizeof(int); }
771 
772 };
773 
779 {
780 
782  : JackRequest(JackRequest::kComputeTotalLatencies)
783  {}
784 
786  {
787  CheckSize();
788  return 0;
789  }
790 
792  {
793  CheckRes(JackRequest::Write(trans, Size()));
794  return 0;
795  }
796 
797  int Size() { return 0; }
798 };
799 
805 {
806 
807  int fRefNum;
808 
810  {}
811  JackReleaseTimebaseRequest(int refnum)
812  : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
813  {}
814 
816  {
817  CheckSize();
818  return trans->Read(&fRefNum, sizeof(int));
819  }
820 
822  {
823  CheckRes(JackRequest::Write(trans, Size()));
824  return trans->Write(&fRefNum, sizeof(int));
825  }
826 
827  int Size() { return sizeof(int); }
828 
829 };
830 
836 {
837 
838  int fRefNum;
839  int fConditionnal;
840 
842  {}
843  JackSetTimebaseCallbackRequest(int refnum, int conditional)
844  : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
845  {}
846 
848  {
849  CheckSize();
850  CheckRes(trans->Read(&fRefNum, sizeof(int)));
851  return trans->Read(&fConditionnal, sizeof(int));
852  }
853 
855  {
856  CheckRes(JackRequest::Write(trans, Size()));
857  CheckRes(trans->Write(&fRefNum, sizeof(int)));
858  return trans->Write(&fConditionnal, sizeof(int));
859  }
860 
861  int Size() { return sizeof(int) + sizeof(int); }
862 };
863 
869 {
870 
871  int fRefNum;
872  int fIntRefNum;
873 
875  {}
876  JackGetInternalClientNameRequest(int refnum, int int_ref)
877  : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
878  {}
879 
881  {
882  CheckSize();
883  CheckRes(trans->Read(&fRefNum, sizeof(int)));
884  return trans->Read(&fIntRefNum, sizeof(int));
885  }
886 
888  {
889  CheckRes(JackRequest::Write(trans, Size()));
890  CheckRes(trans->Write(&fRefNum, sizeof(int)));
891  return trans->Write(&fIntRefNum, sizeof(int));
892  }
893 
894  int Size() { return sizeof(int) + sizeof(int); }
895 };
896 
902 {
903 
904  char fName[JACK_CLIENT_NAME_SIZE + 1];
905 
907  {}
908  JackGetInternalClientNameResult(int32_t result, const char* name)
909  : JackResult(result)
910  {
911  snprintf(fName, sizeof(fName), "%s", name);
912  }
913 
915  {
916  CheckRes(JackResult::Read(trans));
917  CheckRes(trans->Read(&fName, sizeof(fName)));
918  return 0;
919  }
920 
922  {
923  CheckRes(JackResult::Write(trans));
924  CheckRes(trans->Write(&fName, sizeof(fName)));
925  return 0;
926  }
927 
928  int Size() { return sizeof(fName); }
929 };
930 
936 {
937 
938  int fRefNum;
939  char fName[JACK_CLIENT_NAME_SIZE + 1];
940 
942  {}
943  JackInternalClientHandleRequest(int refnum, const char* client_name)
944  : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
945  {
946  snprintf(fName, sizeof(fName), "%s", client_name);
947  }
948 
950  {
951  CheckSize();
952  CheckRes(trans->Read(&fRefNum, sizeof(int)));
953  return trans->Read(&fName, sizeof(fName));
954  }
955 
957  {
958  CheckRes(JackRequest::Write(trans, Size()));
959  CheckRes(trans->Write(&fRefNum, sizeof(int)));
960  return trans->Write(&fName, sizeof(fName));
961  }
962 
963  int Size() { return sizeof(int) + sizeof(fName); }
964 };
965 
971 {
972 
973  int fStatus;
974  int fIntRefNum;
975 
977  {}
978  JackInternalClientHandleResult(int32_t result, int status, int int_ref)
979  : JackResult(result), fStatus(status), fIntRefNum(int_ref)
980  {}
981 
983  {
984  CheckRes(JackResult::Read(trans));
985  CheckRes(trans->Read(&fStatus, sizeof(int)));
986  CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
987  return 0;
988  }
989 
991  {
992  CheckRes(JackResult::Write(trans));
993  CheckRes(trans->Write(&fStatus, sizeof(int)));
994  CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
995  return 0;
996  }
997 
998  int Size() { return sizeof(int) + sizeof(int); }
999 };
1000 
1006 {
1007 
1008 #ifndef MAX_PATH
1009 #define MAX_PATH 256
1010 #endif
1011 
1012  int fRefNum;
1013  char fName[JACK_CLIENT_NAME_SIZE + 1];
1014  char fDllName[MAX_PATH + 1];
1015  char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
1016  int fOptions;
1017  int fUUID;
1018 
1020  {}
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)
1023  {
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);
1028  }
1029 
1031  {
1032  CheckSize();
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));
1039  }
1040 
1041  int Write(detail::JackChannelTransactionInterface* trans)
1042  {
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));
1050  }
1051 
1052  int Size() { return sizeof(int) + sizeof(fName) + sizeof(fDllName) + sizeof(fLoadInitName) + 2 * sizeof(int); }
1053 };
1054 
1060 {
1061 
1062  int fStatus;
1063  int fIntRefNum;
1064 
1066  {}
1067  JackInternalClientLoadResult(int32_t result, int status, int int_ref)
1068  : JackResult(result), fStatus(status), fIntRefNum(int_ref)
1069  {}
1070 
1072  {
1073  CheckRes(JackResult::Read(trans));
1074  CheckRes(trans->Read(&fStatus, sizeof(int)));
1075  CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
1076  return 0;
1077  }
1078 
1079  int Write(detail::JackChannelTransactionInterface* trans)
1080  {
1081  CheckRes(JackResult::Write(trans));
1082  CheckRes(trans->Write(&fStatus, sizeof(int)));
1083  CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
1084  return 0;
1085  }
1086 
1087  int Size() { return sizeof(int) + sizeof(int); }
1088 };
1089 
1095 {
1096 
1097  int fRefNum;
1098  int fIntRefNum;
1099 
1101  {}
1102  JackInternalClientUnloadRequest(int refnum, int int_ref)
1103  : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
1104  {}
1105 
1107  {
1108  CheckSize();
1109  CheckRes(trans->Read(&fRefNum, sizeof(int)));
1110  return trans->Read(&fIntRefNum, sizeof(int));
1111  }
1112 
1113  int Write(detail::JackChannelTransactionInterface* trans)
1114  {
1115  CheckRes(JackRequest::Write(trans, Size()));
1116  CheckRes(trans->Write(&fRefNum, sizeof(int)));
1117  return trans->Write(&fIntRefNum, sizeof(int));
1118  }
1119 
1120  int Size() { return sizeof(int) + sizeof(int); }
1121 };
1122 
1128 {
1129 
1130  int fStatus;
1131 
1133  {}
1134  JackInternalClientUnloadResult(int32_t result, int status)
1135  : JackResult(result), fStatus(status)
1136  {}
1137 
1139  {
1140  CheckRes(JackResult::Read(trans));
1141  CheckRes(trans->Read(&fStatus, sizeof(int)));
1142  return 0;
1143  }
1144 
1145  int Write(detail::JackChannelTransactionInterface* trans)
1146  {
1147  CheckRes(JackResult::Write(trans));
1148  CheckRes(trans->Write(&fStatus, sizeof(int)));
1149  return 0;
1150  }
1151 
1152  int Size() { return sizeof(int); }
1153 };
1154 
1160 {
1161 
1162  int fRefNum;
1163  int fNotify;
1164  int fValue;
1165 
1167  {}
1168  JackClientNotificationRequest(int refnum, int notify, int value)
1169  : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
1170  {}
1171 
1173  {
1174  CheckSize();
1175  CheckRes(trans->Read(&fRefNum, sizeof(int)));
1176  CheckRes(trans->Read(&fNotify, sizeof(int)));
1177  CheckRes(trans->Read(&fValue, sizeof(int)));
1178  return 0;
1179  }
1180 
1181  int Write(detail::JackChannelTransactionInterface* trans)
1182  {
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)));
1187  return 0;
1188  }
1189 
1190  int Size() { return 3 * sizeof(int); }
1191 
1192 };
1193 
1195 {
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;
1200 
1202  {}
1203 
1204  JackSessionCommand(const char *uuid, const char *clientname, const char *command, jack_session_flags_t flags)
1205  {
1206  strncpy(fUUID, uuid, sizeof(fUUID));
1207  strncpy(fClientName, clientname, sizeof(fClientName));
1208  strncpy(fCommand, command, sizeof(fCommand));
1209  fFlags = flags;
1210  }
1211 };
1212 
1214 {
1215 
1216  std::list<JackSessionCommand> fCommandList;
1217  bool fDone;
1218 
1219  JackSessionNotifyResult(): JackResult(), fDone(false)
1220  {}
1221  JackSessionNotifyResult(int32_t result)
1222  : JackResult(result), fDone(false)
1223  {}
1224 
1226  {
1227  if (trans == NULL)
1228  {
1229  return 0;
1230  }
1231 
1232  CheckRes(JackResult::Read(trans));
1233  while (true) {
1234  JackSessionCommand buffer;
1235 
1236  CheckRes(trans->Read(buffer.fUUID, sizeof(buffer.fUUID)));
1237  if (buffer.fUUID[0] == '\0')
1238  break;
1239 
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)));
1243 
1244  fCommandList.push_back(buffer);
1245  }
1246 
1247  fDone = true;
1248 
1249  return 0;
1250  }
1251 
1252  int Write(detail::JackChannelTransactionInterface* trans)
1253  {
1254  if (trans == NULL)
1255  {
1256  fDone = true;
1257  return 0;
1258  }
1259 
1260  char terminator[JACK_UUID_SIZE];
1261  terminator[0] = '\0';
1262 
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)));
1269  }
1270  CheckRes(trans->Write(terminator, sizeof(terminator)));
1271  return 0;
1272  }
1273 
1274  jack_session_command_t* GetCommands()
1275  {
1276  /* TODO: some kind of signal should be used instead */
1277  while (!fDone)
1278  {
1279  JackSleep(50000); /* 50 ms */
1280  }
1281 
1282  jack_session_command_t* session_command = (jack_session_command_t *)malloc(sizeof(jack_session_command_t) * (fCommandList.size() + 1));
1283  int i = 0;
1284 
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;
1290  i += 1;
1291  }
1292 
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;
1297 
1298  return session_command;
1299  }
1300 };
1301 
1307 {
1308  char fPath[JACK_MESSAGE_SIZE + 1];
1309  char fDst[JACK_CLIENT_NAME_SIZE + 1];
1310  jack_session_event_type_t fEventType;
1311  int fRefNum;
1312 
1314  {}
1315  JackSessionNotifyRequest(int refnum, const char* path, jack_session_event_type_t type, const char* dst)
1316  : JackRequest(JackRequest::kSessionNotify), fEventType(type), fRefNum(refnum)
1317  {
1318  snprintf(fPath, sizeof(fPath), "%s", path);
1319  if (dst) {
1320  snprintf(fDst, sizeof(fDst), "%s", dst);
1321  } else {
1322  fDst[0] = '\0';
1323  }
1324  }
1325 
1327  {
1328  CheckSize();
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)));
1333  return 0;
1334  }
1335 
1336  int Write(detail::JackChannelTransactionInterface* trans)
1337  {
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)));
1343  return 0;
1344  }
1345 
1346  int Size() { return sizeof(fRefNum) + sizeof(fPath) + sizeof(fDst) + sizeof(fEventType); }
1347 };
1348 
1350 {
1351  int fRefNum;
1352 
1354  {}
1355 
1356  JackSessionReplyRequest(int refnum)
1357  : JackRequest(JackRequest::kSessionReply), fRefNum(refnum)
1358  {}
1359 
1361  {
1362  CheckSize();
1363  CheckRes(trans->Read(&fRefNum, sizeof(int)));
1364  return 0;
1365  }
1366 
1367  int Write(detail::JackChannelTransactionInterface* trans)
1368  {
1369  CheckRes(JackRequest::Write(trans, Size()));
1370  CheckRes(trans->Write(&fRefNum, sizeof(int)));
1371  return 0;
1372  }
1373 
1374  int Size() { return sizeof(int); }
1375 
1376 };
1377 
1379 {
1380  char fName[JACK_CLIENT_NAME_SIZE + 1];
1381 
1383  {}
1384  JackClientNameResult(int32_t result, const char* name)
1385  : JackResult(result)
1386  {
1387  snprintf(fName, sizeof(fName), "%s", name);
1388  }
1389 
1391  {
1392  CheckRes(JackResult::Read(trans));
1393  CheckRes(trans->Read(&fName, sizeof(fName)));
1394  return 0;
1395  }
1396 
1397  int Write(detail::JackChannelTransactionInterface* trans)
1398  {
1399  CheckRes(JackResult::Write(trans));
1400  CheckRes(trans->Write(&fName, sizeof(fName)));
1401  return 0;
1402  }
1403 
1404 };
1405 
1407 {
1408  char fUUID[JACK_UUID_SIZE];
1409 
1411  {}
1412  JackUUIDResult(int32_t result, const char* uuid)
1413  : JackResult(result)
1414  {
1415  snprintf(fUUID, sizeof(fUUID), "%s", uuid);
1416  }
1417 
1419  {
1420  CheckRes(JackResult::Read(trans));
1421  CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1422  return 0;
1423  }
1424 
1425  int Write(detail::JackChannelTransactionInterface* trans)
1426  {
1427  CheckRes(JackResult::Write(trans));
1428  CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1429  return 0;
1430  }
1431 
1432 };
1433 
1435 {
1436  char fName[JACK_CLIENT_NAME_SIZE + 1];
1437 
1439  {}
1440 
1441  JackGetUUIDRequest(const char* client_name)
1442  : JackRequest(JackRequest::kGetUUIDByClient)
1443  {
1444  strncpy(fName, client_name, sizeof(fName));
1445  }
1446 
1448  {
1449  CheckSize();
1450  CheckRes(trans->Read(&fName, sizeof(fName)));
1451  return 0;
1452  }
1453 
1454  int Write(detail::JackChannelTransactionInterface* trans)
1455  {
1456  CheckRes(JackRequest::Write(trans, Size()));
1457  CheckRes(trans->Write(&fName, sizeof(fName)));
1458  return 0;
1459  }
1460 
1461  int Size() { return sizeof(fName); }
1462 
1463 };
1464 
1466 {
1467  char fUUID[JACK_UUID_SIZE];
1468 
1470  {}
1471 
1472  JackGetClientNameRequest(const char* uuid)
1473  : JackRequest(JackRequest::kGetClientByUUID)
1474  {
1475  strncpy(fUUID, uuid, sizeof(fUUID));
1476  }
1477 
1479  {
1480  CheckSize();
1481  CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1482  return 0;
1483  }
1484 
1485  int Write(detail::JackChannelTransactionInterface* trans)
1486  {
1487  CheckRes(JackRequest::Write(trans, Size()));
1488  CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1489  return 0;
1490  }
1491 
1492  int Size() { return sizeof(fUUID); }
1493 
1494 };
1495 
1497 {
1498  int fRefNum;
1499  char fName[JACK_CLIENT_NAME_SIZE + 1];
1500  char fUUID[JACK_UUID_SIZE];
1501 
1503  {}
1504 
1505  JackReserveNameRequest(int refnum, const char *name, const char* uuid)
1506  : JackRequest(JackRequest::kReserveClientName), fRefNum(refnum)
1507  {
1508  strncpy(fName, name, sizeof(fName));
1509  strncpy(fUUID, uuid, sizeof(fUUID));
1510  }
1511 
1513  {
1514  CheckSize();
1515  CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1516  CheckRes(trans->Read(&fName, sizeof(fName)));
1517  CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
1518  return 0;
1519  }
1520 
1521  int Write(detail::JackChannelTransactionInterface* trans)
1522  {
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)));
1527  return 0;
1528  }
1529 
1530  int Size() { return sizeof(fUUID) + sizeof(fName) + sizeof(fRefNum); }
1531 
1532 };
1533 
1535 {
1536  char fName[JACK_CLIENT_NAME_SIZE + 1];
1537 
1539  {}
1540 
1541  JackClientHasSessionCallbackRequest(const char *name)
1542  : JackRequest(JackRequest::kClientHasSessionCallback)
1543  {
1544  strncpy(fName, name, sizeof(fName));
1545  }
1546 
1548  {
1549  CheckSize();
1550  CheckRes(trans->Read(&fName, sizeof(fName)));
1551  return 0;
1552  }
1553 
1554  int Write(detail::JackChannelTransactionInterface* trans)
1555  {
1556  CheckRes(JackRequest::Write(trans, Size()));
1557  CheckRes(trans->Write(&fName, sizeof(fName)));
1558  return 0;
1559  }
1560 
1561  int Size() { return sizeof(fName); }
1562 
1563 };
1564 
1570 {
1571  int fSize;
1572  char fName[JACK_CLIENT_NAME_SIZE + 1];
1573  int fRefNum;
1574  int fNotify;
1575  int fValue1;
1576  int fValue2;
1577  int fSync;
1578  char fMessage[JACK_MESSAGE_SIZE + 1];
1579 
1580  JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)
1581  {}
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)
1584  {
1585  snprintf(fName, sizeof(fName), "%s", name);
1586  snprintf(fMessage, sizeof(fMessage), "%s", message);
1587  fSize = Size();
1588  }
1589 
1591  {
1592  CheckSize();
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)));
1600  return 0;
1601  }
1602 
1603  int Write(detail::JackChannelTransactionInterface* trans)
1604  {
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)));
1613  return 0;
1614  }
1615 
1616  int Size() { return sizeof(int) + sizeof(fName) + 5 * sizeof(int) + sizeof(fMessage); }
1617 
1618 };
1619 
1620 } // end of namespace
1621 
1622 #endif
ReleaseTimebase request.
Definition: JackRequest.h:804
PortConnectName request.
Definition: JackRequest.h:516
SetBufferSize request.
Definition: JackRequest.h:717
InternalClientHandle result.
Definition: JackRequest.h:970
CloseClient request.
Definition: JackRequest.h:316
CheckClient result.
Definition: JackRequest.h:202
SetTimebaseCallback request.
Definition: JackRequest.h:835
PortDisconnect request.
Definition: JackRequest.h:638
Result from the server.
Definition: JackRequest.h:129
NewClient request.
Definition: JackRequest.h:238
InternalClientLoad result.
Definition: JackRequest.h:1059
Request from client to server.
Definition: JackRequest.h:56
ClientNotification request.
Definition: JackRequest.h:1159
CheckClient request.
Definition: JackRequest.h:157
GetInternalClientName request.
Definition: JackRequest.h:868
NewClient result.
Definition: JackRequest.h:278
GetInternalClient result.
Definition: JackRequest.h:901
PortRegister result.
Definition: JackRequest.h:455
ComputeTotalLatencies request.
Definition: JackRequest.h:778
PortRename request.
Definition: JackRequest.h:676
Deactivate request.
Definition: JackRequest.h:378
Activate request.
Definition: JackRequest.h:345
PortUnregister request.
Definition: JackRequest.h:481
enum JackSessionFlags jack_session_flags_t
Definition: session.h:98
SessionNotify request.
Definition: JackRequest.h:1306
InternalClientUnload request.
Definition: JackRequest.h:1094
InternalClientLoad request.
Definition: JackRequest.h:1005
PortConnect request.
Definition: JackRequest.h:600
InternalClientLoad result.
Definition: JackRequest.h:1127
PortDisconnectName request.
Definition: JackRequest.h:558
SetFreeWheel request.
Definition: JackRequest.h:747
ClientNotification.
Definition: JackRequest.h:1569
PortRegister request.
Definition: JackRequest.h:407
InternalClientHandle request.
Definition: JackRequest.h:935