Jack2  1.9.8
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 "JackPlatformPlug.h"
26 #include "JackTime.h"
27 #include "types.h"
28 #include <string.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <list>
32 
33 namespace Jack
34 {
35 
36 #define CheckRes(exp) { if ((exp) < 0) return -1; }
37 
42 enum JackSessionReply {
43 
44  kImmediateSessionReply = 1,
45  kPendingSessionReply = 2
46 
47 };
48 
54 {
55 
56  enum RequestType {
57  kRegisterPort = 1,
58  kUnRegisterPort = 2,
59  kConnectPorts = 3,
60  kDisconnectPorts = 4,
61  kSetTimeBaseClient = 5,
62  kActivateClient = 6,
63  kDeactivateClient = 7,
64  kDisconnectPort = 8,
65  kSetClientCapabilities = 9,
66  kGetPortConnections = 10,
67  kGetPortNConnections = 11,
68  kReleaseTimebase = 12,
69  kSetTimebaseCallback = 13,
70  kSetBufferSize = 20,
71  kSetFreeWheel = 21,
72  kClientCheck = 22,
73  kClientOpen = 23,
74  kClientClose = 24,
75  kConnectNamePorts = 25,
76  kDisconnectNamePorts = 26,
77  kGetInternalClientName = 27,
78  kInternalClientHandle = 28,
79  kInternalClientLoad = 29,
80  kInternalClientUnload = 30,
81  kPortRename = 31,
82  kNotification = 32,
83  kSessionNotify = 33,
84  kSessionReply = 34,
85  kGetClientByUUID = 35,
86  kReserveClientName = 36,
87  kGetUUIDByClient = 37,
88  kClientHasSessionCallback = 38,
89  kComputeTotalLatencies = 39
90  };
91 
92  RequestType fType;
93 
94  JackRequest(): fType((RequestType)0)
95  {}
96 
97  JackRequest(RequestType type): fType(type)
98  {}
99 
100  virtual ~JackRequest()
101  {}
102 
103  virtual int Read(JackChannelTransaction* trans)
104  {
105  return trans->Read(&fType, sizeof(RequestType));
106  }
107 
108  virtual int Write(JackChannelTransaction* trans)
109  {
110  return trans->Write(&fType, sizeof(RequestType));
111  }
112 
113 };
114 
120 {
121 
122  int fResult;
123 
124  JackResult(): fResult( -1)
125  {}
126  JackResult(int result): fResult(result)
127  {}
128  virtual ~JackResult()
129  {}
130 
131  virtual int Read(JackChannelTransaction* trans)
132  {
133  return trans->Read(&fResult, sizeof(int));
134  }
135 
136  virtual int Write(JackChannelTransaction* trans)
137  {
138  return trans->Write(&fResult, sizeof(int));
139  }
140 
141 };
142 
148 {
149 
150  char fName[JACK_CLIENT_NAME_SIZE + 1];
151  int fProtocol;
152  int fOptions;
153  int fUUID;
154  int fOpen;
155 
157  {}
158  JackClientCheckRequest(const char* name, int protocol, int options, int uuid, int open = false)
159  : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options), fUUID(uuid), fOpen(open)
160  {
161  snprintf(fName, sizeof(fName), "%s", name);
162  }
163 
164  int Read(JackChannelTransaction* trans)
165  {
166  CheckRes(trans->Read(&fName, sizeof(fName)));
167  CheckRes(trans->Read(&fProtocol, sizeof(int)));
168  CheckRes(trans->Read(&fOptions, sizeof(int)));
169  CheckRes(trans->Read(&fUUID, sizeof(int)));
170  return trans->Read(&fOpen, sizeof(int));
171  }
172 
173  int Write(JackChannelTransaction* trans)
174  {
175  CheckRes(JackRequest::Write(trans));
176  CheckRes(trans->Write(&fName, sizeof(fName)));
177  CheckRes(trans->Write(&fProtocol, sizeof(int)));
178  CheckRes(trans->Write(&fOptions, sizeof(int)));
179  CheckRes(trans->Write(&fUUID, sizeof(int)));
180  return trans->Write(&fOpen, sizeof(int));
181  }
182 
183 };
184 
190 {
191 
192  char fName[JACK_CLIENT_NAME_SIZE + 1];
193  int fStatus;
194 
195  JackClientCheckResult(): JackResult(), fStatus(0)
196  {}
197  JackClientCheckResult(int32_t result, const char* name, int status)
198  : JackResult(result), fStatus(status)
199  {
200  snprintf(fName, sizeof(fName), "%s", name);
201  }
202 
203  int Read(JackChannelTransaction* trans)
204  {
205  CheckRes(JackResult::Read(trans));
206  CheckRes(trans->Read(&fName, sizeof(fName)));
207  CheckRes(trans->Read(&fStatus, sizeof(int)));
208  return 0;
209  }
210 
211  int Write(JackChannelTransaction* trans)
212  {
213  CheckRes(JackResult::Write(trans));
214  CheckRes(trans->Write(&fName, sizeof(fName)));
215  CheckRes(trans->Write(&fStatus, sizeof(int)));
216  return 0;
217  }
218 
219 };
220 
226 {
227 
228  int fPID;
229  int fUUID;
230  char fName[JACK_CLIENT_NAME_SIZE + 1];
231 
233  {}
234  JackClientOpenRequest(const char* name, int pid, int uuid): JackRequest(JackRequest::kClientOpen)
235  {
236  snprintf(fName, sizeof(fName), "%s", name);
237  fPID = pid;
238  fUUID = uuid;
239  }
240 
241  int Read(JackChannelTransaction* trans)
242  {
243  CheckRes(trans->Read(&fPID, sizeof(int)));
244  CheckRes(trans->Read(&fUUID, sizeof(int)));
245  return trans->Read(&fName, sizeof(fName));
246  }
247 
248  int Write(JackChannelTransaction* trans)
249  {
250  CheckRes(JackRequest::Write(trans));
251  CheckRes(trans->Write(&fPID, sizeof(int)));
252  CheckRes(trans->Write(&fUUID, sizeof(int)));
253  return trans->Write(&fName, sizeof(fName));
254  }
255 
256 };
257 
263 {
264 
265  int fSharedEngine;
266  int fSharedClient;
267  int fSharedGraph;
268 
270  : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
271  {}
272  JackClientOpenResult(int32_t result, int index1, int index2, int index3)
273  : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
274  {}
275 
276  int Read(JackChannelTransaction* trans)
277  {
278  CheckRes(JackResult::Read(trans));
279  CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
280  CheckRes(trans->Read(&fSharedClient, sizeof(int)));
281  CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
282  return 0;
283  }
284 
285  int Write(JackChannelTransaction* trans)
286  {
287  CheckRes(JackResult::Write(trans));
288  CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
289  CheckRes(trans->Write(&fSharedClient, sizeof(int)));
290  CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
291  return 0;
292  }
293 
294 };
295 
301 {
302 
303  int fRefNum;
304 
306  {}
307  JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
308  {}
309 
310  int Read(JackChannelTransaction* trans)
311  {
312  return trans->Read(&fRefNum, sizeof(int));
313  }
314 
315  int Write(JackChannelTransaction* trans)
316  {
317  CheckRes(JackRequest::Write(trans));
318  return trans->Write(&fRefNum, sizeof(int));
319  }
320 
321 };
322 
328 {
329 
330  int fRefNum;
331  int fIsRealTime;
332 
334  {}
335  JackActivateRequest(int refnum, int is_real_time)
336  : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fIsRealTime(is_real_time)
337  {}
338 
339  int Read(JackChannelTransaction* trans)
340  {
341  CheckRes(trans->Read(&fRefNum, sizeof(int)));
342  return trans->Read(&fIsRealTime, sizeof(int));
343  }
344 
345  int Write(JackChannelTransaction* trans)
346  {
347  CheckRes(JackRequest::Write(trans));
348  CheckRes(trans->Write(&fRefNum, sizeof(int)));
349  return trans->Write(&fIsRealTime, sizeof(int));
350  }
351 
352 };
353 
359 {
360 
361  int fRefNum;
362 
364  {}
365  JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
366  {}
367 
368  int Read(JackChannelTransaction* trans)
369  {
370  return trans->Read(&fRefNum, sizeof(int));
371  }
372 
373  int Write(JackChannelTransaction* trans)
374  {
375  CheckRes(JackRequest::Write(trans));
376  return trans->Write(&fRefNum, sizeof(int));
377  }
378 
379 };
380 
386 {
387 
388  int fRefNum;
389  char fName[JACK_PORT_NAME_SIZE + 1];
390  char fPortType[JACK_PORT_TYPE_SIZE + 1];
391  unsigned int fFlags;
392  unsigned int fBufferSize;
393 
395  {}
396  JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
397  : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
398  {
399  strcpy(fName, name);
400  strcpy(fPortType, port_type);
401  }
402 
403  int Read(JackChannelTransaction* trans)
404  {
405  CheckRes(trans->Read(&fRefNum, sizeof(int)));
406  CheckRes(trans->Read(&fName, sizeof(fName)));
407  CheckRes(trans->Read(&fPortType, sizeof(fPortType)));
408  CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
409  CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
410  return 0;
411  }
412 
413  int Write(JackChannelTransaction* trans)
414  {
415  CheckRes(JackRequest::Write(trans));
416  CheckRes(trans->Write(&fRefNum, sizeof(int)));
417  CheckRes(trans->Write(&fName, sizeof(fName)));
418  CheckRes(trans->Write(&fPortType, sizeof(fPortType)));
419  CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
420  CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
421  return 0;
422  }
423 
424 };
425 
431 {
432 
433  jack_port_id_t fPortIndex;
434 
435  JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
436  {}
437 
438  int Read(JackChannelTransaction* trans)
439  {
440  CheckRes(JackResult::Read(trans));
441  return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
442  }
443 
444  int Write(JackChannelTransaction* trans)
445  {
446  CheckRes(JackResult::Write(trans));
447  return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
448  }
449 
450 };
451 
457 {
458 
459  int fRefNum;
460  jack_port_id_t fPortIndex;
461 
463  {}
464  JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
465  : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
466  {}
467 
468  int Read(JackChannelTransaction* trans)
469  {
470  CheckRes(trans->Read(&fRefNum, sizeof(int)));
471  CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
472  return 0;
473  }
474 
475  int Write(JackChannelTransaction* trans)
476  {
477  CheckRes(JackRequest::Write(trans));
478  CheckRes(trans->Write(&fRefNum, sizeof(int)));
479  CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
480  return 0;
481  }
482 
483 };
484 
490 {
491 
492  int fRefNum;
493  char fSrc[JACK_PORT_NAME_SIZE + 1];
494  char fDst[JACK_PORT_NAME_SIZE + 1];
495 
497  {}
498  JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
499  : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
500  {
501  strcpy(fSrc, src_name);
502  strcpy(fDst, dst_name);
503  }
504 
505  int Read(JackChannelTransaction* trans)
506  {
507  CheckRes(trans->Read(&fRefNum, sizeof(int)));
508  CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
509  CheckRes(trans->Read(&fDst, sizeof(fDst)));
510  return 0;
511 
512  }
513 
514  int Write(JackChannelTransaction* trans)
515  {
516  CheckRes(JackRequest::Write(trans));
517  CheckRes(trans->Write(&fRefNum, sizeof(int)));
518  CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
519  CheckRes(trans->Write(&fDst, sizeof(fDst)));
520  return 0;
521  }
522 
523 };
524 
530 {
531 
532  int fRefNum;
533  char fSrc[JACK_PORT_NAME_SIZE + 1];
534  char fDst[JACK_PORT_NAME_SIZE + 1];
535 
537  {}
538  JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
539  : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
540  {
541  strcpy(fSrc, src_name);
542  strcpy(fDst, dst_name);
543  }
544 
545  int Read(JackChannelTransaction* trans)
546  {
547  CheckRes(trans->Read(&fRefNum, sizeof(int)));
548  CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
549  CheckRes(trans->Read(&fDst, sizeof(fDst)));
550  return 0;
551  }
552 
553  int Write(JackChannelTransaction* trans)
554  {
555  CheckRes(JackRequest::Write(trans));
556  CheckRes(trans->Write(&fRefNum, sizeof(int)));
557  CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
558  CheckRes(trans->Write(&fDst, sizeof(fDst)));
559  return 0;
560  }
561 
562 };
563 
569 {
570 
571  int fRefNum;
572  jack_port_id_t fSrc;
573  jack_port_id_t fDst;
574 
576  {}
577  JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
578  : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
579  {}
580 
581  int Read(JackChannelTransaction* trans)
582  {
583  CheckRes(trans->Read(&fRefNum, sizeof(int)));
584  CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
585  CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
586  return 0;
587  }
588 
589  int Write(JackChannelTransaction* trans)
590  {
591  CheckRes(JackRequest::Write(trans));
592  CheckRes(trans->Write(&fRefNum, sizeof(int)));
593  CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
594  CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
595  return 0;
596  }
597 
598 };
599 
605 {
606 
607  int fRefNum;
608  jack_port_id_t fSrc;
609  jack_port_id_t fDst;
610 
612  {}
613  JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
614  : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
615  {}
616 
617  int Read(JackChannelTransaction* trans)
618  {
619  CheckRes(trans->Read(&fRefNum, sizeof(int)));
620  CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
621  CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
622  return 0;
623  }
624 
625  int Write(JackChannelTransaction* trans)
626  {
627  CheckRes(JackRequest::Write(trans));
628  CheckRes(trans->Write(&fRefNum, sizeof(int)));
629  CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
630  CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
631  return 0;
632  }
633 
634 };
635 
641 {
642 
643  int fRefNum;
644  jack_port_id_t fPort;
645  char fName[JACK_PORT_NAME_SIZE + 1];
646 
648  {}
649  JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
650  : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
651  {
652  strcpy(fName, name);
653  }
654 
655  int Read(JackChannelTransaction* trans)
656  {
657  CheckRes(trans->Read(&fRefNum, sizeof(int)));
658  CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
659  CheckRes(trans->Read(&fName, sizeof(fName)));
660  return 0;
661  }
662 
663  int Write(JackChannelTransaction* trans)
664  {
665  CheckRes(JackRequest::Write(trans));
666  CheckRes(trans->Write(&fRefNum, sizeof(int)));
667  CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
668  CheckRes(trans->Write(&fName, sizeof(fName)));
669  return 0;
670 
671  }
672 
673 };
674 
680 {
681 
682  jack_nframes_t fBufferSize;
683 
685  {}
686  JackSetBufferSizeRequest(jack_nframes_t buffer_size)
687  : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
688  {}
689 
690  int Read(JackChannelTransaction* trans)
691  {
692  return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
693  }
694 
695  int Write(JackChannelTransaction* trans)
696  {
697  CheckRes(JackRequest::Write(trans));
698  return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
699  }
700 
701 };
702 
708 {
709 
710  int fOnOff;
711 
713  {}
714  JackSetFreeWheelRequest(int onoff)
715  : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
716  {}
717 
718  int Read(JackChannelTransaction* trans)
719  {
720  return trans->Read(&fOnOff, sizeof(int));
721  }
722 
723  int Write(JackChannelTransaction* trans)
724  {
725  CheckRes(JackRequest::Write(trans));
726  return trans->Write(&fOnOff, sizeof(int));
727  }
728 
729 };
730 
736 {
737 
739  : JackRequest(JackRequest::kComputeTotalLatencies)
740  {}
741 
742  int Read(JackChannelTransaction* trans)
743  {
744  return 0;
745  }
746 
747  int Write(JackChannelTransaction* trans)
748  {
749  CheckRes(JackRequest::Write(trans));
750  return 0;
751  }
752 
753 };
754 
760 {
761 
762  int fRefNum;
763 
765  {}
766  JackReleaseTimebaseRequest(int refnum)
767  : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
768  {}
769 
770  int Read(JackChannelTransaction* trans)
771  {
772  return trans->Read(&fRefNum, sizeof(int));
773  }
774 
775  int Write(JackChannelTransaction* trans)
776  {
777  CheckRes(JackRequest::Write(trans));
778  return trans->Write(&fRefNum, sizeof(int));
779  }
780 
781 };
782 
788 {
789 
790  int fRefNum;
791  int fConditionnal;
792 
794  {}
795  JackSetTimebaseCallbackRequest(int refnum, int conditional)
796  : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
797  {}
798 
799  int Read(JackChannelTransaction* trans)
800  {
801  CheckRes(trans->Read(&fRefNum, sizeof(int)));
802  return trans->Read(&fConditionnal, sizeof(int));
803  }
804 
805  int Write(JackChannelTransaction* trans)
806  {
807  CheckRes(JackRequest::Write(trans));
808  CheckRes(trans->Write(&fRefNum, sizeof(int)));
809  return trans->Write(&fConditionnal, sizeof(int));
810  }
811 
812 };
813 
819 {
820 
821  int fRefNum;
822  int fIntRefNum;
823 
825  {}
826  JackGetInternalClientNameRequest(int refnum, int int_ref)
827  : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
828  {}
829 
830  int Read(JackChannelTransaction* trans)
831  {
832  CheckRes(trans->Read(&fRefNum, sizeof(int)));
833  return trans->Read(&fIntRefNum, sizeof(int));
834  }
835 
836  int Write(JackChannelTransaction* trans)
837  {
838  CheckRes(JackRequest::Write(trans));
839  CheckRes(trans->Write(&fRefNum, sizeof(int)));
840  return trans->Write(&fIntRefNum, sizeof(int));
841  }
842 
843 };
844 
850 {
851 
852  char fName[JACK_CLIENT_NAME_SIZE + 1];
853 
855  {}
856  JackGetInternalClientNameResult(int32_t result, const char* name)
857  : JackResult(result)
858  {
859  snprintf(fName, sizeof(fName), "%s", name);
860  }
861 
862  int Read(JackChannelTransaction* trans)
863  {
864  CheckRes(JackResult::Read(trans));
865  CheckRes(trans->Read(&fName, sizeof(fName)));
866  return 0;
867  }
868 
869  int Write(JackChannelTransaction* trans)
870  {
871  CheckRes(JackResult::Write(trans));
872  CheckRes(trans->Write(&fName, sizeof(fName)));
873  return 0;
874  }
875 
876 };
877 
883 {
884 
885  int fRefNum;
886  char fName[JACK_CLIENT_NAME_SIZE + 1];
887 
889  {}
890  JackInternalClientHandleRequest(int refnum, const char* client_name)
891  : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
892  {
893  snprintf(fName, sizeof(fName), "%s", client_name);
894  }
895 
896  int Read(JackChannelTransaction* trans)
897  {
898  CheckRes(trans->Read(&fRefNum, sizeof(int)));
899  return trans->Read(&fName, sizeof(fName));
900  }
901 
902  int Write(JackChannelTransaction* trans)
903  {
904  CheckRes(JackRequest::Write(trans));
905  CheckRes(trans->Write(&fRefNum, sizeof(int)));
906  return trans->Write(&fName, sizeof(fName));
907  }
908 
909 };
910 
916 {
917 
918  int fStatus;
919  int fIntRefNum;
920 
922  {}
923  JackInternalClientHandleResult(int32_t result, int status, int int_ref)
924  : JackResult(result), fStatus(status), fIntRefNum(int_ref)
925  {}
926 
927  int Read(JackChannelTransaction* trans)
928  {
929  CheckRes(JackResult::Read(trans));
930  CheckRes(trans->Read(&fStatus, sizeof(int)));
931  CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
932  return 0;
933  }
934 
935  int Write(JackChannelTransaction* trans)
936  {
937  CheckRes(JackResult::Write(trans));
938  CheckRes(trans->Write(&fStatus, sizeof(int)));
939  CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
940  return 0;
941  }
942 
943 };
944 
950 {
951 
952 #ifndef MAX_PATH
953 #define MAX_PATH 256
954 #endif
955 
956  int fRefNum;
957  char fName[JACK_CLIENT_NAME_SIZE + 1];
958  char fDllName[MAX_PATH + 1];
959  char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
960  int fOptions;
961  int fUUID;
962 
964  {}
965  JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int uuid )
966  : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options), fUUID(uuid)
967  {
968  snprintf(fName, sizeof(fName), "%s", client_name);
969  snprintf(fDllName, sizeof(fDllName), "%s", so_name);
970  snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
971  snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
972  }
973 
974  int Read(JackChannelTransaction* trans)
975  {
976  CheckRes(trans->Read(&fRefNum, sizeof(int)));
977  CheckRes(trans->Read(&fName, sizeof(fName)));
978  CheckRes(trans->Read(&fDllName, sizeof(fDllName)));
979  CheckRes(trans->Read(&fLoadInitName, sizeof(fLoadInitName)));
980  CheckRes(trans->Read(&fUUID, sizeof(int)));
981  return trans->Read(&fOptions, sizeof(int));
982  }
983 
984  int Write(JackChannelTransaction* trans)
985  {
986  CheckRes(JackRequest::Write(trans));
987  CheckRes(trans->Write(&fRefNum, sizeof(int)));
988  CheckRes(trans->Write(&fName, sizeof(fName)));
989  CheckRes(trans->Write(&fDllName, sizeof(fDllName)));
990  CheckRes(trans->Write(&fLoadInitName, sizeof(fLoadInitName)));
991  CheckRes(trans->Write(&fUUID, sizeof(int)));
992  return trans->Write(&fOptions, sizeof(int));
993  }
994 
995 };
996 
1002 {
1003 
1004  int fStatus;
1005  int fIntRefNum;
1006 
1008  {}
1009  JackInternalClientLoadResult(int32_t result, int status, int int_ref)
1010  : JackResult(result), fStatus(status), fIntRefNum(int_ref)
1011  {}
1012 
1013  int Read(JackChannelTransaction* trans)
1014  {
1015  CheckRes(JackResult::Read(trans));
1016  CheckRes(trans->Read(&fStatus, sizeof(int)));
1017  CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
1018  return 0;
1019  }
1020 
1021  int Write(JackChannelTransaction* trans)
1022  {
1023  CheckRes(JackResult::Write(trans));
1024  CheckRes(trans->Write(&fStatus, sizeof(int)));
1025  CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
1026  return 0;
1027  }
1028 
1029 };
1030 
1036 {
1037 
1038  int fRefNum;
1039  int fIntRefNum;
1040 
1042  {}
1043  JackInternalClientUnloadRequest(int refnum, int int_ref)
1044  : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
1045  {}
1046 
1047  int Read(JackChannelTransaction* trans)
1048  {
1049  CheckRes(trans->Read(&fRefNum, sizeof(int)));
1050  return trans->Read(&fIntRefNum, sizeof(int));
1051  }
1052 
1053  int Write(JackChannelTransaction* trans)
1054  {
1055  CheckRes(JackRequest::Write(trans));
1056  CheckRes(trans->Write(&fRefNum, sizeof(int)));
1057  return trans->Write(&fIntRefNum, sizeof(int));
1058  }
1059 };
1060 
1066 {
1067 
1068  int fStatus;
1069 
1071  {}
1072  JackInternalClientUnloadResult(int32_t result, int status)
1073  : JackResult(result), fStatus(status)
1074  {}
1075 
1076  int Read(JackChannelTransaction* trans)
1077  {
1078  CheckRes(JackResult::Read(trans));
1079  CheckRes(trans->Read(&fStatus, sizeof(int)));
1080  return 0;
1081  }
1082 
1083  int Write(JackChannelTransaction* trans)
1084  {
1085  CheckRes(JackResult::Write(trans));
1086  CheckRes(trans->Write(&fStatus, sizeof(int)));
1087  return 0;
1088  }
1089 
1090 };
1091 
1097 {
1098 
1099  int fRefNum;
1100  int fNotify;
1101  int fValue;
1102 
1104  {}
1105  JackClientNotificationRequest(int refnum, int notify, int value)
1106  : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
1107  {}
1108 
1109  int Read(JackChannelTransaction* trans)
1110  {
1111  CheckRes(trans->Read(&fRefNum, sizeof(int)));
1112  CheckRes(trans->Read(&fNotify, sizeof(int)));
1113  CheckRes(trans->Read(&fValue, sizeof(int)));
1114  return 0;
1115  }
1116 
1117  int Write(JackChannelTransaction* trans)
1118  {
1119  CheckRes(JackRequest::Write(trans));
1120  CheckRes(trans->Write(&fRefNum, sizeof(int)));
1121  CheckRes(trans->Write(&fNotify, sizeof(int)));
1122  CheckRes(trans->Write(&fValue, sizeof(int)));
1123  return 0;
1124  }
1125 
1126 };
1127 
1129 {
1130  char fUUID[JACK_UUID_SIZE];
1131  char fClientName[JACK_CLIENT_NAME_SIZE+1];
1132  char fCommand[JACK_SESSION_COMMAND_SIZE];
1133  jack_session_flags_t fFlags;
1134 
1136  {}
1137 
1138  JackSessionCommand(const char *uuid, const char *clientname, const char *command, jack_session_flags_t flags)
1139  {
1140  strncpy(fUUID, uuid, sizeof(fUUID));
1141  strncpy(fClientName, clientname, sizeof(fClientName));
1142  strncpy(fCommand, command, sizeof(fCommand));
1143  fFlags = flags;
1144  }
1145 };
1146 
1148 {
1149 
1150  std::list<JackSessionCommand> fCommandList;
1151  bool fDone;
1152 
1153  JackSessionNotifyResult(): JackResult(), fDone(false)
1154  {}
1155  JackSessionNotifyResult(int32_t result)
1156  : JackResult(result), fDone(false)
1157  {}
1158 
1159  int Read(JackChannelTransaction* trans)
1160  {
1161  if (trans == NULL)
1162  {
1163  return 0;
1164  }
1165 
1166  CheckRes(JackResult::Read(trans));
1167  while (true) {
1168  JackSessionCommand buffer;
1169 
1170  CheckRes(trans->Read(buffer.fUUID, sizeof(buffer.fUUID)));
1171  if (buffer.fUUID[0] == '\0')
1172  break;
1173 
1174  CheckRes(trans->Read(buffer.fClientName, sizeof(buffer.fClientName)));
1175  CheckRes(trans->Read(buffer.fCommand, sizeof(buffer.fCommand)));
1176  CheckRes(trans->Read(&(buffer.fFlags), sizeof(buffer.fFlags)));
1177 
1178  fCommandList.push_back(buffer);
1179  }
1180 
1181  fDone = true;
1182 
1183  return 0;
1184  }
1185 
1186  int Write(JackChannelTransaction* trans)
1187  {
1188  if (trans == NULL)
1189  {
1190  fDone = true;
1191  return 0;
1192  }
1193 
1194  char terminator[JACK_UUID_SIZE];
1195  terminator[0] = '\0';
1196 
1197  CheckRes(JackResult::Write(trans));
1198  for (std::list<JackSessionCommand>::iterator i = fCommandList.begin(); i != fCommandList.end(); i++) {
1199  CheckRes(trans->Write(i->fUUID, sizeof(i->fUUID)));
1200  CheckRes(trans->Write(i->fClientName, sizeof(i->fClientName)));
1201  CheckRes(trans->Write(i->fCommand, sizeof(i->fCommand)));
1202  CheckRes(trans->Write(&(i->fFlags), sizeof(i->fFlags)));
1203  }
1204  CheckRes(trans->Write(terminator, sizeof(terminator)));
1205  return 0;
1206  }
1207 
1208  jack_session_command_t* GetCommands()
1209  {
1210  /* TODO: some kind of signal should be used instead */
1211  while (!fDone)
1212  {
1213  JackSleep(50000); /* 50 ms */
1214  }
1215 
1216  jack_session_command_t* session_command = (jack_session_command_t *)malloc(sizeof(jack_session_command_t) * (fCommandList.size() + 1));
1217  int i = 0;
1218 
1219  for (std::list<JackSessionCommand>::iterator ci = fCommandList.begin(); ci != fCommandList.end(); ci++) {
1220  session_command[i].uuid = strdup(ci->fUUID);
1221  session_command[i].client_name = strdup(ci->fClientName);
1222  session_command[i].command = strdup(ci->fCommand);
1223  session_command[i].flags = ci->fFlags;
1224  i += 1;
1225  }
1226 
1227  session_command[i].uuid = NULL;
1228  session_command[i].client_name = NULL;
1229  session_command[i].command = NULL;
1230  session_command[i].flags = (jack_session_flags_t)0;
1231 
1232  return session_command;
1233  }
1234 };
1235 
1241 {
1242  char fPath[JACK_MESSAGE_SIZE + 1];
1243  char fDst[JACK_CLIENT_NAME_SIZE + 1];
1244  jack_session_event_type_t fEventType;
1245  int fRefNum;
1246 
1248  {}
1249  JackSessionNotifyRequest(int refnum, const char* path, jack_session_event_type_t type, const char* dst)
1250  : JackRequest(JackRequest::kSessionNotify), fEventType(type), fRefNum(refnum)
1251  {
1252  snprintf(fPath, sizeof(fPath), "%s", path);
1253  if (dst) {
1254  snprintf(fDst, sizeof(fDst), "%s", dst);
1255  } else {
1256  fDst[0] = '\0';
1257  }
1258  }
1259 
1260  int Read(JackChannelTransaction* trans)
1261  {
1262  CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
1263  CheckRes(trans->Read(&fPath, sizeof(fPath)));
1264  CheckRes(trans->Read(&fDst, sizeof(fDst)));
1265  CheckRes(trans->Read(&fEventType, sizeof(fEventType)));
1266  return 0;
1267  }
1268 
1269  int Write(JackChannelTransaction* trans)
1270  {
1271  CheckRes(JackRequest::Write(trans));
1272  CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
1273  CheckRes(trans->Write(&fPath, sizeof(fPath)));
1274  CheckRes(trans->Write(&fDst, sizeof(fDst)));
1275  CheckRes(trans->Write(&fEventType, sizeof(fEventType)));
1276  return 0;
1277  }
1278 
1279 };
1280 
1282 {
1283  int fRefNum;
1284 
1286  {}
1287 
1288  JackSessionReplyRequest(int refnum)
1289  : JackRequest(JackRequest::kSessionReply), fRefNum(refnum)
1290  {}
1291 
1292  int Read(JackChannelTransaction* trans)
1293  {
1294  CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
1295  return 0;
1296  }
1297 
1298  int Write(JackChannelTransaction* trans)
1299  {
1300  CheckRes(JackRequest::Write(trans));
1301  CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
1302  return 0;
1303  }
1304 
1305 };
1306 
1308 {
1309  char fName[JACK_CLIENT_NAME_SIZE + 1];
1310 
1312  {}
1313  JackClientNameResult(int32_t result, const char* name)
1314  : JackResult(result)
1315  {
1316  snprintf(fName, sizeof(fName), "%s", name);
1317  }
1318 
1319  int Read(JackChannelTransaction* trans)
1320  {
1321  CheckRes(JackResult::Read(trans));
1322  CheckRes(trans->Read(&fName, sizeof(fName)));
1323  return 0;
1324  }
1325 
1326  int Write(JackChannelTransaction* trans)
1327  {
1328  CheckRes(JackResult::Write(trans));
1329  CheckRes(trans->Write(&fName, sizeof(fName)));
1330  return 0;
1331  }
1332 
1333 };
1334 
1336 {
1337  char fUUID[JACK_UUID_SIZE];
1338 
1340  {}
1341  JackUUIDResult(int32_t result, const char* uuid)
1342  : JackResult(result)
1343  {
1344  snprintf(fUUID, sizeof(fUUID), "%s", uuid);
1345  }
1346 
1347  int Read(JackChannelTransaction* trans)
1348  {
1349  CheckRes(JackResult::Read(trans));
1350  CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1351  return 0;
1352  }
1353 
1354  int Write(JackChannelTransaction* trans)
1355  {
1356  CheckRes(JackResult::Write(trans));
1357  CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1358  return 0;
1359  }
1360 
1361 };
1362 
1364 {
1365  char fName[JACK_CLIENT_NAME_SIZE + 1];
1366 
1368  {}
1369 
1370  JackGetUUIDRequest(const char* client_name)
1371  : JackRequest(JackRequest::kGetUUIDByClient)
1372  {
1373  strncpy(fName, client_name, sizeof(fName));
1374  }
1375 
1376  int Read(JackChannelTransaction* trans)
1377  {
1378  CheckRes(trans->Read(&fName, sizeof(fName)));
1379  return 0;
1380  }
1381 
1382  int Write(JackChannelTransaction* trans)
1383  {
1384  CheckRes(JackRequest::Write(trans));
1385  CheckRes(trans->Write(&fName, sizeof(fName)));
1386  return 0;
1387  }
1388 
1389 };
1390 
1392 {
1393  char fUUID[JACK_UUID_SIZE];
1394 
1396  {}
1397 
1398  JackGetClientNameRequest(const char* uuid)
1399  : JackRequest(JackRequest::kGetClientByUUID)
1400  {
1401  strncpy(fUUID, uuid, sizeof(fUUID));
1402  }
1403 
1404  int Read(JackChannelTransaction* trans)
1405  {
1406  CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1407  return 0;
1408  }
1409 
1410  int Write(JackChannelTransaction* trans)
1411  {
1412  CheckRes(JackRequest::Write(trans));
1413  CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1414  return 0;
1415  }
1416 
1417 };
1418 
1420 {
1421  int fRefNum;
1422  char fName[JACK_CLIENT_NAME_SIZE + 1];
1423  char fUUID[JACK_UUID_SIZE];
1424 
1426  {}
1427 
1428  JackReserveNameRequest(int refnum, const char *name, const char* uuid)
1429  : JackRequest(JackRequest::kReserveClientName), fRefNum(refnum)
1430  {
1431  strncpy(fName, name, sizeof(fName));
1432  strncpy(fUUID, uuid, sizeof(fUUID));
1433  }
1434 
1435  int Read(JackChannelTransaction* trans)
1436  {
1437  CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1438  CheckRes(trans->Read(&fName, sizeof(fName)));
1439  CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
1440  return 0;
1441  }
1442 
1443  int Write(JackChannelTransaction* trans)
1444  {
1445  CheckRes(JackRequest::Write(trans));
1446  CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1447  CheckRes(trans->Write(&fName, sizeof(fName)));
1448  CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
1449  return 0;
1450  }
1451 
1452 };
1453 
1455 {
1456  char fName[JACK_CLIENT_NAME_SIZE + 1];
1457 
1459  {}
1460 
1461  JackClientHasSessionCallbackRequest(const char *name)
1462  : JackRequest(JackRequest::kClientHasSessionCallback)
1463  {
1464  strncpy(fName, name, sizeof(fName));
1465  }
1466 
1467  int Read(JackChannelTransaction* trans)
1468  {
1469  CheckRes(trans->Read(&fName, sizeof(fName)));
1470  return 0;
1471  }
1472 
1473  int Write(JackChannelTransaction* trans)
1474  {
1475  CheckRes(JackRequest::Write(trans));
1476  CheckRes(trans->Write(&fName, sizeof(fName)));
1477  return 0;
1478  }
1479 
1480 };
1481 
1487 {
1488  char fName[JACK_CLIENT_NAME_SIZE + 1];
1489  int fRefNum;
1490  int fNotify;
1491  int fValue1;
1492  int fValue2;
1493  int fSync;
1494  char fMessage[JACK_MESSAGE_SIZE + 1];
1495 
1496  JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)
1497  {}
1498  JackClientNotification(const char* name, int refnum, int notify, int sync, const char* message, int value1, int value2)
1499  : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
1500  {
1501  snprintf(fName, sizeof(fName), "%s", name);
1502  snprintf(fMessage, sizeof(fMessage), "%s", message);
1503  }
1504 
1505  int Read(JackChannelTransaction* trans)
1506  {
1507  CheckRes(trans->Read(&fName, sizeof(fName)));
1508  CheckRes(trans->Read(&fRefNum, sizeof(int)));
1509  CheckRes(trans->Read(&fNotify, sizeof(int)));
1510  CheckRes(trans->Read(&fValue1, sizeof(int)));
1511  CheckRes(trans->Read(&fValue2, sizeof(int)));
1512  CheckRes(trans->Read(&fSync, sizeof(int)));
1513  CheckRes(trans->Read(&fMessage, sizeof(fMessage)));
1514  return 0;
1515  }
1516 
1517  int Write(JackChannelTransaction* trans)
1518  {
1519  CheckRes(trans->Write(&fName, sizeof(fName)));
1520  CheckRes(trans->Write(&fRefNum, sizeof(int)));
1521  CheckRes(trans->Write(&fNotify, sizeof(int)));
1522  CheckRes(trans->Write(&fValue1, sizeof(int)));
1523  CheckRes(trans->Write(&fValue2, sizeof(int)));
1524  CheckRes(trans->Write(&fSync, sizeof(int)));
1525  CheckRes(trans->Write(&fMessage, sizeof(fMessage)));
1526  return 0;
1527  }
1528 
1529 };
1530 
1531 } // end of namespace
1532 
1533 #endif