Jack2  1.9.13
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 
56 struct JackRequest
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  kPropertyChangeNotify = 40
94  };
95 
96  RequestType fType;
97  int fSize;
98 
99  JackRequest(): fType((RequestType)0), fSize(0)
100  {}
101 
102  JackRequest(RequestType type): fType(type), fSize(0)
103  {}
104 
105  virtual ~JackRequest()
106  {}
107 
108  virtual int Read(detail::JackChannelTransactionInterface* trans)
109  {
110  return trans->Read(&fType, sizeof(RequestType));
111  }
112 
113  virtual int Write(detail::JackChannelTransactionInterface* trans) { return -1; }
114 
115  virtual int Write(detail::JackChannelTransactionInterface* trans, int size)
116  {
117  fSize = size;
118  CheckRes(trans->Write(&fType, sizeof(RequestType)));
119  return trans->Write(&fSize, sizeof(int));
120  }
121 
122  virtual int Size() { return 0; }
123 
124 };
125 
130 struct JackResult
131 {
132 
133  int fResult;
134 
135  JackResult(): fResult( -1)
136  {}
137  JackResult(int result): fResult(result)
138  {}
139  virtual ~JackResult()
140  {}
141 
142  virtual int Read(detail::JackChannelTransactionInterface* trans)
143  {
144  return trans->Read(&fResult, sizeof(int));
145  }
146 
147  virtual int Write(detail::JackChannelTransactionInterface* trans)
148  {
149  return trans->Write(&fResult, sizeof(int));
150  }
151 
152 };
153 
158 struct JackClientCheckRequest : public JackRequest
159 {
160 
161  char fName[JACK_CLIENT_NAME_SIZE+1];
162  int fProtocol;
163  int fOptions;
164  int fOpen;
165  jack_uuid_t fUUID;
166 
167  JackClientCheckRequest() : fProtocol(0), fOptions(0), fOpen(0), fUUID(JACK_UUID_EMPTY_INITIALIZER)
168  {
169  memset(fName, 0, sizeof(fName));
170  }
171  JackClientCheckRequest(const char* name, int protocol, int options, jack_uuid_t uuid, int open = false)
172  : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options), fOpen(open), fUUID(uuid)
173  {
174  memset(fName, 0, sizeof(fName));
175  snprintf(fName, sizeof(fName), "%s", name);
176  }
177 
178  int Read(detail::JackChannelTransactionInterface* trans)
179  {
180  CheckSize();
181  CheckRes(trans->Read(&fName, sizeof(fName)));
182  CheckRes(trans->Read(&fProtocol, sizeof(int)));
183  CheckRes(trans->Read(&fOptions, sizeof(int)));
184  CheckRes(trans->Read(&fUUID, sizeof(jack_uuid_t)));
185  return trans->Read(&fOpen, sizeof(int));
186  }
187 
188  int Write(detail::JackChannelTransactionInterface* trans)
189  {
190  CheckRes(JackRequest::Write(trans, Size()));
191  CheckRes(trans->Write(&fName, sizeof(fName)));
192  CheckRes(trans->Write(&fProtocol, sizeof(int)));
193  CheckRes(trans->Write(&fOptions, sizeof(int)));
194  CheckRes(trans->Write(&fUUID, sizeof(jack_uuid_t)));
195  return trans->Write(&fOpen, sizeof(int));
196  }
197 
198  int Size() { return sizeof(fName) + 3 * sizeof(int) + sizeof(jack_uuid_t); }
199 
200 };
201 
206 struct JackClientCheckResult : public JackResult
207 {
208 
209  char fName[JACK_CLIENT_NAME_SIZE+1];
210  int fStatus;
211 
212  JackClientCheckResult(): JackResult(), fStatus(0)
213  {
214  memset(fName, 0, sizeof(fName));
215  }
216  JackClientCheckResult(int32_t result, const char* name, int status)
217  : JackResult(result), fStatus(status)
218  {
219  memset(fName, 0, sizeof(fName));
220  snprintf(fName, sizeof(fName), "%s", name);
221  }
222 
223  int Read(detail::JackChannelTransactionInterface* trans)
224  {
225  CheckRes(JackResult::Read(trans));
226  CheckRes(trans->Read(&fName, sizeof(fName)));
227  CheckRes(trans->Read(&fStatus, sizeof(int)));
228  return 0;
229  }
230 
231  int Write(detail::JackChannelTransactionInterface* trans)
232  {
233  CheckRes(JackResult::Write(trans));
234  CheckRes(trans->Write(&fName, sizeof(fName)));
235  CheckRes(trans->Write(&fStatus, sizeof(int)));
236  return 0;
237  }
238 
239 };
240 
245 struct JackClientOpenRequest : public JackRequest
246 {
247 
248  int fPID;
249  jack_uuid_t fUUID;
250  char fName[JACK_CLIENT_NAME_SIZE+1];
251 
252  JackClientOpenRequest() : fPID(0), fUUID(JACK_UUID_EMPTY_INITIALIZER)
253  {
254  memset(fName, 0, sizeof(fName));
255  }
256  JackClientOpenRequest(const char* name, int pid, jack_uuid_t uuid): JackRequest(JackRequest::kClientOpen)
257  {
258  memset(fName, 0, sizeof(fName));
259  snprintf(fName, sizeof(fName), "%s", name);
260  fPID = pid;
261  fUUID = uuid;
262  }
263 
264  int Read(detail::JackChannelTransactionInterface* trans)
265  {
266  CheckSize();
267  CheckRes(trans->Read(&fPID, sizeof(int)));
268  CheckRes(trans->Read(&fUUID, sizeof(jack_uuid_t)));
269  return trans->Read(&fName, sizeof(fName));
270  }
271 
272  int Write(detail::JackChannelTransactionInterface* trans)
273  {
274  CheckRes(JackRequest::Write(trans, Size()));
275  CheckRes(trans->Write(&fPID, sizeof(int)));
276  CheckRes(trans->Write(&fUUID, sizeof(jack_uuid_t)));
277  return trans->Write(&fName, sizeof(fName));
278  }
279 
280  int Size() { return sizeof(int) + sizeof(jack_uuid_t) + sizeof(fName); }
281 
282 };
283 
288 struct JackClientOpenResult : public JackResult
289 {
290 
291  int fSharedEngine;
292  int fSharedClient;
293  int fSharedGraph;
294 
295  JackClientOpenResult()
296  : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
297  {}
298  JackClientOpenResult(int32_t result, int index1, int index2, int index3)
299  : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
300  {}
301 
302  int Read(detail::JackChannelTransactionInterface* trans)
303  {
304  CheckRes(JackResult::Read(trans));
305  CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
306  CheckRes(trans->Read(&fSharedClient, sizeof(int)));
307  CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
308  return 0;
309  }
310 
311  int Write(detail::JackChannelTransactionInterface* trans)
312  {
313  CheckRes(JackResult::Write(trans));
314  CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
315  CheckRes(trans->Write(&fSharedClient, sizeof(int)));
316  CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
317  return 0;
318  }
319 
320 };
321 
326 struct JackClientCloseRequest : public JackRequest
327 {
328 
329  int fRefNum;
330 
331  JackClientCloseRequest() : fRefNum(0)
332  {}
333  JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
334  {}
335 
336  int Read(detail::JackChannelTransactionInterface* trans)
337  {
338  CheckSize();
339  return trans->Read(&fRefNum, sizeof(int));
340  }
341 
342  int Write(detail::JackChannelTransactionInterface* trans)
343  {
344  CheckRes(JackRequest::Write(trans, Size()));
345  return trans->Write(&fRefNum, sizeof(int));
346  }
347 
348  int Size() { return sizeof(int); }
349 };
350 
355 struct JackActivateRequest : public JackRequest
356 {
357 
358  int fRefNum;
359  int fIsRealTime;
360 
361  JackActivateRequest() : fRefNum(0), fIsRealTime(0)
362  {}
363  JackActivateRequest(int refnum, int is_real_time)
364  : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fIsRealTime(is_real_time)
365  {}
366 
367  int Read(detail::JackChannelTransactionInterface* trans)
368  {
369  CheckSize();
370  CheckRes(trans->Read(&fRefNum, sizeof(int)));
371  return trans->Read(&fIsRealTime, sizeof(int));
372  }
373 
374  int Write(detail::JackChannelTransactionInterface* trans)
375  {
376  CheckRes(JackRequest::Write(trans, Size()));
377  CheckRes(trans->Write(&fRefNum, sizeof(int)));
378  return trans->Write(&fIsRealTime, sizeof(int));
379  }
380 
381  int Size() { return 2 * sizeof(int); }
382 };
383 
388 struct JackDeactivateRequest : public JackRequest
389 {
390 
391  int fRefNum;
392 
393  JackDeactivateRequest() : fRefNum(0)
394  {}
395  JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
396  {}
397 
398  int Read(detail::JackChannelTransactionInterface* trans)
399  {
400  CheckSize();
401  return trans->Read(&fRefNum, sizeof(int));
402  }
403 
404  int Write(detail::JackChannelTransactionInterface* trans)
405  {
406  CheckRes(JackRequest::Write(trans, Size()));
407  return trans->Write(&fRefNum, sizeof(int));
408  }
409 
410  int Size() { return sizeof(int); }
411 };
412 
417 struct JackPortRegisterRequest : public JackRequest
418 {
419 
420  int fRefNum;
421  char fName[JACK_PORT_NAME_SIZE + 1]; // port short name
422  char fPortType[JACK_PORT_TYPE_SIZE + 1];
423  unsigned int fFlags;
424  unsigned int fBufferSize;
425 
426  JackPortRegisterRequest() : fRefNum(0), fFlags(0), fBufferSize(0)
427  {
428  memset(fName, 0, sizeof(fName));
429  memset(fPortType, 0, sizeof(fPortType));
430  }
431  JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
432  : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
433  {
434  memset(fName, 0, sizeof(fName));
435  memset(fPortType, 0, sizeof(fPortType));
436  strncpy(fName, name, sizeof(fName)-1);
437  strncpy(fPortType, port_type, sizeof(fPortType)-1);
438  }
439 
440  int Read(detail::JackChannelTransactionInterface* trans)
441  {
442  CheckSize();
443  CheckRes(trans->Read(&fRefNum, sizeof(int)));
444  CheckRes(trans->Read(&fName, sizeof(fName)));
445  CheckRes(trans->Read(&fPortType, sizeof(fPortType)));
446  CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
447  CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
448  return 0;
449  }
450 
451  int Write(detail::JackChannelTransactionInterface* trans)
452  {
453  CheckRes(JackRequest::Write(trans, Size()));
454  CheckRes(trans->Write(&fRefNum, sizeof(int)));
455  CheckRes(trans->Write(&fName, sizeof(fName)));
456  CheckRes(trans->Write(&fPortType, sizeof(fPortType)));
457  CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
458  CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
459  return 0;
460  }
461 
462  int Size() { return sizeof(int) + sizeof(fName) + sizeof(fPortType) + 2 * sizeof(unsigned int); }
463 
464 };
465 
470 struct JackPortRegisterResult : public JackResult
471 {
472 
473  jack_port_id_t fPortIndex;
474 
475  JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
476  {}
477 
478  int Read(detail::JackChannelTransactionInterface* trans)
479  {
480  CheckRes(JackResult::Read(trans));
481  return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
482  }
483 
484  int Write(detail::JackChannelTransactionInterface* trans)
485  {
486  CheckRes(JackResult::Write(trans));
487  return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
488  }
489 
490 };
491 
496 struct JackPortUnRegisterRequest : public JackRequest
497 {
498 
499  int fRefNum;
500  jack_port_id_t fPortIndex;
501 
502  JackPortUnRegisterRequest() : fRefNum(0), fPortIndex(0)
503  {}
504  JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
505  : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
506  {}
507 
508  int Read(detail::JackChannelTransactionInterface* trans)
509  {
510  CheckSize();
511  CheckRes(trans->Read(&fRefNum, sizeof(int)));
512  CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
513  return 0;
514  }
515 
516  int Write(detail::JackChannelTransactionInterface* trans)
517  {
518  CheckRes(JackRequest::Write(trans, Size()));
519  CheckRes(trans->Write(&fRefNum, sizeof(int)));
520  CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
521  return 0;
522  }
523 
524  int Size() { return sizeof(int) + sizeof(jack_port_id_t); }
525 };
526 
531 struct JackPortConnectNameRequest : public JackRequest
532 {
533 
534  int fRefNum;
535  char fSrc[REAL_JACK_PORT_NAME_SIZE+1]; // port full name
536  char fDst[REAL_JACK_PORT_NAME_SIZE+1]; // port full name
537 
538  JackPortConnectNameRequest() : fRefNum(0)
539  {
540  memset(fSrc, 0, sizeof(fSrc));
541  memset(fDst, 0, sizeof(fDst));
542  }
543  JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
544  : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
545  {
546  memset(fSrc, 0, sizeof(fSrc));
547  memset(fDst, 0, sizeof(fDst));
548  strncpy(fSrc, src_name, sizeof(fSrc)-1);
549  strncpy(fDst, dst_name, sizeof(fDst)-1);
550  }
551 
552  int Read(detail::JackChannelTransactionInterface* trans)
553  {
554  CheckSize();
555  CheckRes(trans->Read(&fRefNum, sizeof(int)));
556  CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
557  CheckRes(trans->Read(&fDst, sizeof(fDst)));
558  return 0;
559  }
560 
561  int Write(detail::JackChannelTransactionInterface* trans)
562  {
563  CheckRes(JackRequest::Write(trans, Size()));
564  CheckRes(trans->Write(&fRefNum, sizeof(int)));
565  CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
566  CheckRes(trans->Write(&fDst, sizeof(fDst)));
567  return 0;
568  }
569 
570  int Size() { return sizeof(int) + sizeof(fSrc) + sizeof(fDst); }
571 
572 };
573 
578 struct JackPortDisconnectNameRequest : public JackRequest
579 {
580 
581  int fRefNum;
582  char fSrc[REAL_JACK_PORT_NAME_SIZE+1]; // port full name
583  char fDst[REAL_JACK_PORT_NAME_SIZE+1]; // port full name
584 
585  JackPortDisconnectNameRequest() : fRefNum(0)
586  {
587  memset(fSrc, 0, sizeof(fSrc));
588  memset(fDst, 0, sizeof(fDst));
589  }
590  JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
591  : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
592  {
593  memset(fSrc, 0, sizeof(fSrc));
594  memset(fDst, 0, sizeof(fDst));
595  strncpy(fSrc, src_name, sizeof(fSrc)-1);
596  strncpy(fDst, dst_name, sizeof(fDst)-1);
597  }
598 
599  int Read(detail::JackChannelTransactionInterface* trans)
600  {
601  CheckSize();
602  CheckRes(trans->Read(&fRefNum, sizeof(int)));
603  CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
604  CheckRes(trans->Read(&fDst, sizeof(fDst)));
605  return 0;
606  }
607 
608  int Write(detail::JackChannelTransactionInterface* trans)
609  {
610  CheckRes(JackRequest::Write(trans, Size()));
611  CheckRes(trans->Write(&fRefNum, sizeof(int)));
612  CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
613  CheckRes(trans->Write(&fDst, sizeof(fDst)));
614  return 0;
615  }
616 
617  int Size() { return sizeof(int) + sizeof(fSrc) + sizeof(fDst); }
618 
619 };
620 
625 struct JackPortConnectRequest : public JackRequest
626 {
627 
628  int fRefNum;
629  jack_port_id_t fSrc;
630  jack_port_id_t fDst;
631 
632  JackPortConnectRequest() : fRefNum(0), fSrc(0), fDst(0)
633  {}
634  JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
635  : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
636  {}
637 
638  int Read(detail::JackChannelTransactionInterface* trans)
639  {
640  CheckSize();
641  CheckRes(trans->Read(&fRefNum, sizeof(int)));
642  CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
643  CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
644  return 0;
645  }
646 
647  int Write(detail::JackChannelTransactionInterface* trans)
648  {
649  CheckRes(JackRequest::Write(trans, Size()));
650  CheckRes(trans->Write(&fRefNum, sizeof(int)));
651  CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
652  CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
653  return 0;
654  }
655 
656  int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(jack_port_id_t); }
657 };
658 
663 struct JackPortDisconnectRequest : public JackRequest
664 {
665 
666  int fRefNum;
667  jack_port_id_t fSrc;
668  jack_port_id_t fDst;
669 
670  JackPortDisconnectRequest() : fRefNum(0), fSrc(0), fDst(0)
671  {}
672  JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
673  : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
674  {}
675 
676  int Read(detail::JackChannelTransactionInterface* trans)
677  {
678  CheckSize();
679  CheckRes(trans->Read(&fRefNum, sizeof(int)));
680  CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
681  CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
682  return 0;
683  }
684 
685  int Write(detail::JackChannelTransactionInterface* trans)
686  {
687  CheckRes(JackRequest::Write(trans, Size()));
688  CheckRes(trans->Write(&fRefNum, sizeof(int)));
689  CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
690  CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
691  return 0;
692  }
693 
694  int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(jack_port_id_t); }
695 };
696 
701 struct JackPortRenameRequest : public JackRequest
702 {
703 
704  int fRefNum;
705  jack_port_id_t fPort;
706  char fName[JACK_PORT_NAME_SIZE + 1]; // port short name
707 
708  JackPortRenameRequest() : fRefNum(0), fPort(0)
709  {
710  memset(fName, 0, sizeof(fName));
711  }
712  JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
713  : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
714  {
715  memset(fName, 0, sizeof(fName));
716  strncpy(fName, name, sizeof(fName)-1);
717  }
718 
719  int Read(detail::JackChannelTransactionInterface* trans)
720  {
721  CheckSize();
722  CheckRes(trans->Read(&fRefNum, sizeof(int)));
723  CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
724  CheckRes(trans->Read(&fName, sizeof(fName)));
725  return 0;
726  }
727 
728  int Write(detail::JackChannelTransactionInterface* trans)
729  {
730  CheckRes(JackRequest::Write(trans, Size()));
731  CheckRes(trans->Write(&fRefNum, sizeof(int)));
732  CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
733  CheckRes(trans->Write(&fName, sizeof(fName)));
734  return 0;
735  }
736 
737  int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(fName); }
738 
739 };
740 
745 struct JackSetBufferSizeRequest : public JackRequest
746 {
747 
748  jack_nframes_t fBufferSize;
749 
750  JackSetBufferSizeRequest() : fBufferSize(0)
751  {}
752  JackSetBufferSizeRequest(jack_nframes_t buffer_size)
753  : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
754  {}
755 
756  int Read(detail::JackChannelTransactionInterface* trans)
757  {
758  CheckSize();
759  return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
760  }
761 
762  int Write(detail::JackChannelTransactionInterface* trans)
763  {
764  CheckRes(JackRequest::Write(trans, Size()));
765  return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
766  }
767 
768  int Size() { return sizeof(jack_nframes_t); }
769 };
770 
775 struct JackSetFreeWheelRequest : public JackRequest
776 {
777 
778  int fOnOff;
779 
780  JackSetFreeWheelRequest() : fOnOff(0)
781  {}
782  JackSetFreeWheelRequest(int onoff)
783  : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
784  {}
785 
786  int Read(detail::JackChannelTransactionInterface* trans)
787  {
788  CheckSize();
789  return trans->Read(&fOnOff, sizeof(int));
790  }
791 
792  int Write(detail::JackChannelTransactionInterface* trans)
793  {
794  CheckRes(JackRequest::Write(trans, Size()));
795  return trans->Write(&fOnOff, sizeof(int));
796  }
797 
798  int Size() { return sizeof(int); }
799 
800 };
801 
806 struct JackComputeTotalLatenciesRequest : public JackRequest
807 {
808 
809  JackComputeTotalLatenciesRequest()
810  : JackRequest(JackRequest::kComputeTotalLatencies)
811  {}
812 
813  int Read(detail::JackChannelTransactionInterface* trans)
814  {
815  CheckSize();
816  return 0;
817  }
818 
819  int Write(detail::JackChannelTransactionInterface* trans)
820  {
821  CheckRes(JackRequest::Write(trans, Size()));
822  return 0;
823  }
824 
825  int Size() { return 0; }
826 };
827 
832 struct JackReleaseTimebaseRequest : public JackRequest
833 {
834 
835  int fRefNum;
836 
837  JackReleaseTimebaseRequest() : fRefNum(0)
838  {}
839  JackReleaseTimebaseRequest(int refnum)
840  : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
841  {}
842 
843  int Read(detail::JackChannelTransactionInterface* trans)
844  {
845  CheckSize();
846  return trans->Read(&fRefNum, sizeof(int));
847  }
848 
849  int Write(detail::JackChannelTransactionInterface* trans)
850  {
851  CheckRes(JackRequest::Write(trans, Size()));
852  return trans->Write(&fRefNum, sizeof(int));
853  }
854 
855  int Size() { return sizeof(int); }
856 
857 };
858 
863 struct JackSetTimebaseCallbackRequest : public JackRequest
864 {
865 
866  int fRefNum;
867  int fConditionnal;
868 
869  JackSetTimebaseCallbackRequest() : fRefNum(0), fConditionnal(0)
870  {}
871  JackSetTimebaseCallbackRequest(int refnum, int conditional)
872  : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
873  {}
874 
875  int Read(detail::JackChannelTransactionInterface* trans)
876  {
877  CheckSize();
878  CheckRes(trans->Read(&fRefNum, sizeof(int)));
879  return trans->Read(&fConditionnal, sizeof(int));
880  }
881 
882  int Write(detail::JackChannelTransactionInterface* trans)
883  {
884  CheckRes(JackRequest::Write(trans, Size()));
885  CheckRes(trans->Write(&fRefNum, sizeof(int)));
886  return trans->Write(&fConditionnal, sizeof(int));
887  }
888 
889  int Size() { return sizeof(int) + sizeof(int); }
890 };
891 
896 struct JackGetInternalClientNameRequest : public JackRequest
897 {
898 
899  int fRefNum;
900  int fIntRefNum;
901 
902  JackGetInternalClientNameRequest() : fRefNum(0), fIntRefNum(0)
903  {}
904  JackGetInternalClientNameRequest(int refnum, int int_ref)
905  : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
906  {}
907 
908  int Read(detail::JackChannelTransactionInterface* trans)
909  {
910  CheckSize();
911  CheckRes(trans->Read(&fRefNum, sizeof(int)));
912  return trans->Read(&fIntRefNum, sizeof(int));
913  }
914 
915  int Write(detail::JackChannelTransactionInterface* trans)
916  {
917  CheckRes(JackRequest::Write(trans, Size()));
918  CheckRes(trans->Write(&fRefNum, sizeof(int)));
919  return trans->Write(&fIntRefNum, sizeof(int));
920  }
921 
922  int Size() { return sizeof(int) + sizeof(int); }
923 };
924 
929 struct JackGetInternalClientNameResult : public JackResult
930 {
931 
932  char fName[JACK_CLIENT_NAME_SIZE+1];
933 
934  JackGetInternalClientNameResult(): JackResult()
935  {
936  memset(fName, 0, sizeof(fName));
937  }
938  JackGetInternalClientNameResult(int32_t result, const char* name)
939  : JackResult(result)
940  {
941  memset(fName, 0, sizeof(fName));
942  snprintf(fName, sizeof(fName), "%s", name);
943  }
944 
945  int Read(detail::JackChannelTransactionInterface* trans)
946  {
947  CheckRes(JackResult::Read(trans));
948  CheckRes(trans->Read(&fName, sizeof(fName)));
949  return 0;
950  }
951 
952  int Write(detail::JackChannelTransactionInterface* trans)
953  {
954  CheckRes(JackResult::Write(trans));
955  CheckRes(trans->Write(&fName, sizeof(fName)));
956  return 0;
957  }
958 
959  int Size() { return sizeof(fName); }
960 };
961 
966 struct JackInternalClientHandleRequest : public JackRequest
967 {
968 
969  int fRefNum;
970  char fName[JACK_CLIENT_NAME_SIZE+1];
971 
972  JackInternalClientHandleRequest() : fRefNum(0)
973  {
974  memset(fName, 0, sizeof(fName));
975  }
976  JackInternalClientHandleRequest(int refnum, const char* client_name)
977  : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
978  {
979  memset(fName, 0, sizeof(fName));
980  snprintf(fName, sizeof(fName), "%s", client_name);
981  }
982 
983  int Read(detail::JackChannelTransactionInterface* trans)
984  {
985  CheckSize();
986  CheckRes(trans->Read(&fRefNum, sizeof(int)));
987  return trans->Read(&fName, sizeof(fName));
988  }
989 
990  int Write(detail::JackChannelTransactionInterface* trans)
991  {
992  CheckRes(JackRequest::Write(trans, Size()));
993  CheckRes(trans->Write(&fRefNum, sizeof(int)));
994  return trans->Write(&fName, sizeof(fName));
995  }
996 
997  int Size() { return sizeof(int) + sizeof(fName); }
998 };
999 
1004 struct JackInternalClientHandleResult : public JackResult
1005 {
1006 
1007  int fStatus;
1008  int fIntRefNum;
1009 
1010  JackInternalClientHandleResult(): JackResult(), fStatus(0), fIntRefNum(0)
1011  {}
1012  JackInternalClientHandleResult(int32_t result, int status, int int_ref)
1013  : JackResult(result), fStatus(status), fIntRefNum(int_ref)
1014  {}
1015 
1016  int Read(detail::JackChannelTransactionInterface* trans)
1017  {
1018  CheckRes(JackResult::Read(trans));
1019  CheckRes(trans->Read(&fStatus, sizeof(int)));
1020  CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
1021  return 0;
1022  }
1023 
1024  int Write(detail::JackChannelTransactionInterface* trans)
1025  {
1026  CheckRes(JackResult::Write(trans));
1027  CheckRes(trans->Write(&fStatus, sizeof(int)));
1028  CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
1029  return 0;
1030  }
1031 
1032  int Size() { return sizeof(int) + sizeof(int); }
1033 };
1034 
1039 struct JackInternalClientLoadRequest : public JackRequest
1040 {
1041 
1042 #ifndef MAX_PATH
1043 #define MAX_PATH 256
1044 #endif
1045 
1046  int fRefNum;
1047  char fName[JACK_CLIENT_NAME_SIZE+1];
1048  char fDllName[MAX_PATH+1];
1049  char fLoadInitName[JACK_LOAD_INIT_LIMIT+1];
1050  int fOptions;
1051  jack_uuid_t fUUID;
1052 
1053  JackInternalClientLoadRequest() : fRefNum(0), fOptions(0), fUUID(JACK_UUID_EMPTY_INITIALIZER)
1054  {
1055  memset(fName, 0, sizeof(fName));
1056  memset(fDllName, 0, sizeof(fDllName));
1057  memset(fLoadInitName, 0, sizeof(fLoadInitName));
1058  }
1059  JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, jack_uuid_t uuid )
1060  : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options), fUUID(uuid)
1061  {
1062  memset(fName, 0, sizeof(fName));
1063  memset(fDllName, 0, sizeof(fDllName));
1064  memset(fLoadInitName, 0, sizeof(fLoadInitName));
1065  strncpy(fName, client_name, sizeof(fName)-1);
1066  if (so_name) {
1067  strncpy(fDllName, so_name, sizeof(fDllName)-1);
1068  }
1069  if (objet_data) {
1070  strncpy(fLoadInitName, objet_data, sizeof(fLoadInitName)-1);
1071  }
1072  }
1073 
1074  int Read(detail::JackChannelTransactionInterface* trans)
1075  {
1076  CheckSize();
1077  CheckRes(trans->Read(&fRefNum, sizeof(int)));
1078  CheckRes(trans->Read(&fName, sizeof(fName)));
1079  CheckRes(trans->Read(&fDllName, sizeof(fDllName)));
1080  CheckRes(trans->Read(&fLoadInitName, sizeof(fLoadInitName)));
1081  CheckRes(trans->Read(&fUUID, sizeof(jack_uuid_t)));
1082  return trans->Read(&fOptions, sizeof(int));
1083  }
1084 
1085  int Write(detail::JackChannelTransactionInterface* trans)
1086  {
1087  CheckRes(JackRequest::Write(trans, Size()));
1088  CheckRes(trans->Write(&fRefNum, sizeof(int)));
1089  CheckRes(trans->Write(&fName, sizeof(fName)));
1090  CheckRes(trans->Write(&fDllName, sizeof(fDllName)));
1091  CheckRes(trans->Write(&fLoadInitName, sizeof(fLoadInitName)));
1092  CheckRes(trans->Write(&fUUID, sizeof(jack_uuid_t)));
1093  return trans->Write(&fOptions, sizeof(int));
1094  }
1095 
1096  int Size() { return sizeof(int) + sizeof(fName) + sizeof(fDllName) + sizeof(fLoadInitName) + sizeof(int) + sizeof(jack_uuid_t); }
1097 };
1098 
1103 struct JackInternalClientLoadResult : public JackResult
1104 {
1105 
1106  int fStatus;
1107  int fIntRefNum;
1108 
1109  JackInternalClientLoadResult(): JackResult(), fStatus(0), fIntRefNum(0)
1110  {}
1111  JackInternalClientLoadResult(int32_t result, int status, int int_ref)
1112  : JackResult(result), fStatus(status), fIntRefNum(int_ref)
1113  {}
1114 
1115  int Read(detail::JackChannelTransactionInterface* trans)
1116  {
1117  CheckRes(JackResult::Read(trans));
1118  CheckRes(trans->Read(&fStatus, sizeof(int)));
1119  CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
1120  return 0;
1121  }
1122 
1123  int Write(detail::JackChannelTransactionInterface* trans)
1124  {
1125  CheckRes(JackResult::Write(trans));
1126  CheckRes(trans->Write(&fStatus, sizeof(int)));
1127  CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
1128  return 0;
1129  }
1130 
1131  int Size() { return sizeof(int) + sizeof(int); }
1132 };
1133 
1138 struct JackInternalClientUnloadRequest : public JackRequest
1139 {
1140 
1141  int fRefNum;
1142  int fIntRefNum;
1143 
1144  JackInternalClientUnloadRequest() : fRefNum(0), fIntRefNum(0)
1145  {}
1146  JackInternalClientUnloadRequest(int refnum, int int_ref)
1147  : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
1148  {}
1149 
1150  int Read(detail::JackChannelTransactionInterface* trans)
1151  {
1152  CheckSize();
1153  CheckRes(trans->Read(&fRefNum, sizeof(int)));
1154  return trans->Read(&fIntRefNum, sizeof(int));
1155  }
1156 
1157  int Write(detail::JackChannelTransactionInterface* trans)
1158  {
1159  CheckRes(JackRequest::Write(trans, Size()));
1160  CheckRes(trans->Write(&fRefNum, sizeof(int)));
1161  return trans->Write(&fIntRefNum, sizeof(int));
1162  }
1163 
1164  int Size() { return sizeof(int) + sizeof(int); }
1165 };
1166 
1171 struct JackInternalClientUnloadResult : public JackResult
1172 {
1173 
1174  int fStatus;
1175 
1176  JackInternalClientUnloadResult(): JackResult(), fStatus(0)
1177  {}
1178  JackInternalClientUnloadResult(int32_t result, int status)
1179  : JackResult(result), fStatus(status)
1180  {}
1181 
1182  int Read(detail::JackChannelTransactionInterface* trans)
1183  {
1184  CheckRes(JackResult::Read(trans));
1185  CheckRes(trans->Read(&fStatus, sizeof(int)));
1186  return 0;
1187  }
1188 
1189  int Write(detail::JackChannelTransactionInterface* trans)
1190  {
1191  CheckRes(JackResult::Write(trans));
1192  CheckRes(trans->Write(&fStatus, sizeof(int)));
1193  return 0;
1194  }
1195 
1196  int Size() { return sizeof(int); }
1197 };
1198 
1203 struct JackClientNotificationRequest : public JackRequest
1204 {
1205 
1206  int fRefNum;
1207  int fNotify;
1208  int fValue;
1209 
1210  JackClientNotificationRequest() : fRefNum(0), fNotify(0), fValue(0)
1211  {}
1212  JackClientNotificationRequest(int refnum, int notify, int value)
1213  : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
1214  {}
1215 
1216  int Read(detail::JackChannelTransactionInterface* trans)
1217  {
1218  CheckSize();
1219  CheckRes(trans->Read(&fRefNum, sizeof(int)));
1220  CheckRes(trans->Read(&fNotify, sizeof(int)));
1221  CheckRes(trans->Read(&fValue, sizeof(int)));
1222  return 0;
1223  }
1224 
1225  int Write(detail::JackChannelTransactionInterface* trans)
1226  {
1227  CheckRes(JackRequest::Write(trans, Size()));
1228  CheckRes(trans->Write(&fRefNum, sizeof(int)));
1229  CheckRes(trans->Write(&fNotify, sizeof(int)));
1230  CheckRes(trans->Write(&fValue, sizeof(int)));
1231  return 0;
1232  }
1233 
1234  int Size() { return 3 * sizeof(int); }
1235 
1236 };
1237 
1238 struct JackSessionCommand
1239 {
1240  char fUUID[JACK_UUID_STRING_SIZE];
1241  char fClientName[JACK_CLIENT_NAME_SIZE+1];
1242  char fCommand[JACK_SESSION_COMMAND_SIZE+1];
1243  jack_session_flags_t fFlags;
1244 
1245  JackSessionCommand() : fFlags(JackSessionSaveError)
1246  {
1247  memset(fUUID, 0, sizeof(fUUID));
1248  memset(fClientName, 0, sizeof(fClientName));
1249  memset(fCommand, 0, sizeof(fCommand));
1250  }
1251  JackSessionCommand(const char *uuid, const char *clientname, const char *command, jack_session_flags_t flags)
1252  {
1253  memset(fUUID, 0, sizeof(fUUID));
1254  memset(fClientName, 0, sizeof(fClientName));
1255  memset(fCommand, 0, sizeof(fCommand));
1256  strncpy(fUUID, uuid, sizeof(fUUID)-1);
1257  strncpy(fClientName, clientname, sizeof(fClientName)-1);
1258  strncpy(fCommand, command, sizeof(fCommand)-1);
1259  fFlags = flags;
1260  }
1261 };
1262 
1263 struct JackSessionNotifyResult : public JackResult
1264 {
1265 
1266  std::list<JackSessionCommand> fCommandList;
1267  bool fDone;
1268 
1269  JackSessionNotifyResult(): JackResult(), fDone(false)
1270  {}
1271  JackSessionNotifyResult(int32_t result)
1272  : JackResult(result), fDone(false)
1273  {}
1274 
1275  int Read(detail::JackChannelTransactionInterface* trans)
1276  {
1277  if (trans == NULL)
1278  {
1279  return 0;
1280  }
1281 
1282  CheckRes(JackResult::Read(trans));
1283  while (true) {
1284  JackSessionCommand buffer;
1285 
1286  CheckRes(trans->Read(buffer.fUUID, sizeof(buffer.fUUID)));
1287  if (buffer.fUUID[0] == '\0')
1288  break;
1289 
1290  CheckRes(trans->Read(buffer.fClientName, sizeof(buffer.fClientName)));
1291  CheckRes(trans->Read(buffer.fCommand, sizeof(buffer.fCommand)));
1292  CheckRes(trans->Read(&(buffer.fFlags), sizeof(buffer.fFlags)));
1293 
1294  fCommandList.push_back(buffer);
1295  }
1296 
1297  fDone = true;
1298 
1299  return 0;
1300  }
1301 
1302  int Write(detail::JackChannelTransactionInterface* trans)
1303  {
1304  if (trans == NULL)
1305  {
1306  fDone = true;
1307  return 0;
1308  }
1309 
1310  char terminator[JACK_UUID_STRING_SIZE];
1311  memset(terminator, 0, sizeof(terminator));
1312 
1313  CheckRes(JackResult::Write(trans));
1314  for (std::list<JackSessionCommand>::iterator i = fCommandList.begin(); i != fCommandList.end(); i++) {
1315  CheckRes(trans->Write(i->fUUID, sizeof(i->fUUID)));
1316  CheckRes(trans->Write(i->fClientName, sizeof(i->fClientName)));
1317  CheckRes(trans->Write(i->fCommand, sizeof(i->fCommand)));
1318  CheckRes(trans->Write(&(i->fFlags), sizeof(i->fFlags)));
1319  }
1320  CheckRes(trans->Write(terminator, sizeof(terminator)));
1321  return 0;
1322  }
1323 
1324  jack_session_command_t* GetCommands()
1325  {
1326  /* TODO: some kind of signal should be used instead */
1327  while (!fDone)
1328  {
1329  JackSleep(50000); /* 50 ms */
1330  }
1331 
1332  jack_session_command_t* session_command = (jack_session_command_t *)malloc(sizeof(jack_session_command_t) * (fCommandList.size() + 1));
1333  int i = 0;
1334 
1335  for (std::list<JackSessionCommand>::iterator ci = fCommandList.begin(); ci != fCommandList.end(); ci++) {
1336  session_command[i].uuid = strdup(ci->fUUID);
1337  session_command[i].client_name = strdup(ci->fClientName);
1338  session_command[i].command = strdup(ci->fCommand);
1339  session_command[i].flags = ci->fFlags;
1340  i += 1;
1341  }
1342 
1343  session_command[i].uuid = NULL;
1344  session_command[i].client_name = NULL;
1345  session_command[i].command = NULL;
1346  session_command[i].flags = (jack_session_flags_t)0;
1347 
1348  return session_command;
1349  }
1350 };
1351 
1356 struct JackSessionNotifyRequest : public JackRequest
1357 {
1358  char fPath[JACK_MESSAGE_SIZE+1];
1359  char fDst[JACK_CLIENT_NAME_SIZE+1];
1360  jack_session_event_type_t fEventType;
1361  int fRefNum;
1362 
1363  JackSessionNotifyRequest() : fEventType(JackSessionSave), fRefNum(0)
1364  {}
1365  JackSessionNotifyRequest(int refnum, const char* path, jack_session_event_type_t type, const char* dst)
1366  : JackRequest(JackRequest::kSessionNotify), fEventType(type), fRefNum(refnum)
1367  {
1368  memset(fPath, 0, sizeof(fPath));
1369  memset(fDst, 0, sizeof(fDst));
1370  strncpy(fPath, path, sizeof(fPath)-1);
1371  if (dst) {
1372  strncpy(fDst, dst, sizeof(fDst)-1);
1373  }
1374  }
1375 
1376  int Read(detail::JackChannelTransactionInterface* trans)
1377  {
1378  CheckSize();
1379  CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
1380  CheckRes(trans->Read(&fPath, sizeof(fPath)));
1381  CheckRes(trans->Read(&fDst, sizeof(fDst)));
1382  CheckRes(trans->Read(&fEventType, sizeof(fEventType)));
1383  return 0;
1384  }
1385 
1386  int Write(detail::JackChannelTransactionInterface* trans)
1387  {
1388  CheckRes(JackRequest::Write(trans, Size()));
1389  CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
1390  CheckRes(trans->Write(&fPath, sizeof(fPath)));
1391  CheckRes(trans->Write(&fDst, sizeof(fDst)));
1392  CheckRes(trans->Write(&fEventType, sizeof(fEventType)));
1393  return 0;
1394  }
1395 
1396  int Size() { return sizeof(fRefNum) + sizeof(fPath) + sizeof(fDst) + sizeof(fEventType); }
1397 };
1398 
1399 struct JackSessionReplyRequest : public JackRequest
1400 {
1401  int fRefNum;
1402 
1403  JackSessionReplyRequest() : fRefNum(0)
1404  {}
1405 
1406  JackSessionReplyRequest(int refnum)
1407  : JackRequest(JackRequest::kSessionReply), fRefNum(refnum)
1408  {}
1409 
1410  int Read(detail::JackChannelTransactionInterface* trans)
1411  {
1412  CheckSize();
1413  CheckRes(trans->Read(&fRefNum, sizeof(int)));
1414  return 0;
1415  }
1416 
1417  int Write(detail::JackChannelTransactionInterface* trans)
1418  {
1419  CheckRes(JackRequest::Write(trans, Size()));
1420  CheckRes(trans->Write(&fRefNum, sizeof(int)));
1421  return 0;
1422  }
1423 
1424  int Size() { return sizeof(int); }
1425 
1426 };
1427 
1428 struct JackClientNameResult : public JackResult
1429 {
1430  char fName[JACK_CLIENT_NAME_SIZE+1];
1431 
1432  JackClientNameResult(): JackResult()
1433  {
1434  memset(fName, 0, sizeof(fName));
1435  }
1436  JackClientNameResult(int32_t result, const char* name)
1437  : JackResult(result)
1438  {
1439  memset(fName, 0, sizeof(fName));
1440  strncpy(fName, name, sizeof(fName)-1);
1441  }
1442 
1443  int Read(detail::JackChannelTransactionInterface* trans)
1444  {
1445  CheckRes(JackResult::Read(trans));
1446  CheckRes(trans->Read(&fName, sizeof(fName)));
1447  return 0;
1448  }
1449 
1450  int Write(detail::JackChannelTransactionInterface* trans)
1451  {
1452  CheckRes(JackResult::Write(trans));
1453  CheckRes(trans->Write(&fName, sizeof(fName)));
1454  return 0;
1455  }
1456 
1457 };
1458 
1459 struct JackUUIDResult : public JackResult
1460 {
1461  char fUUID[JACK_UUID_STRING_SIZE];
1462 
1463  JackUUIDResult(): JackResult()
1464  {
1465  memset(fUUID, 0, sizeof(fUUID));
1466  }
1467  JackUUIDResult(int32_t result, const char* uuid)
1468  : JackResult(result)
1469  {
1470  memset(fUUID, 0, sizeof(fUUID));
1471  strncpy(fUUID, uuid, sizeof(fUUID)-1);
1472  }
1473 
1474  int Read(detail::JackChannelTransactionInterface* trans)
1475  {
1476  CheckRes(JackResult::Read(trans));
1477  CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1478  return 0;
1479  }
1480 
1481  int Write(detail::JackChannelTransactionInterface* trans)
1482  {
1483  CheckRes(JackResult::Write(trans));
1484  CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1485  return 0;
1486  }
1487 
1488 };
1489 
1490 struct JackGetUUIDRequest : public JackRequest
1491 {
1492  char fName[JACK_CLIENT_NAME_SIZE+1];
1493 
1494  JackGetUUIDRequest()
1495  {
1496  memset(fName, 0, sizeof(fName));
1497  }
1498 
1499  JackGetUUIDRequest(const char* client_name)
1500  : JackRequest(JackRequest::kGetUUIDByClient)
1501  {
1502  memset(fName, 0, sizeof(fName));
1503  strncpy(fName, client_name, sizeof(fName)-1);
1504  }
1505 
1506  int Read(detail::JackChannelTransactionInterface* trans)
1507  {
1508  CheckSize();
1509  CheckRes(trans->Read(&fName, sizeof(fName)));
1510  return 0;
1511  }
1512 
1513  int Write(detail::JackChannelTransactionInterface* trans)
1514  {
1515  CheckRes(JackRequest::Write(trans, Size()));
1516  CheckRes(trans->Write(&fName, sizeof(fName)));
1517  return 0;
1518  }
1519 
1520  int Size() { return sizeof(fName); }
1521 
1522 };
1523 
1524 struct JackGetClientNameRequest : public JackRequest
1525 {
1526  char fUUID[JACK_UUID_STRING_SIZE];
1527 
1528  JackGetClientNameRequest()
1529  {
1530  memset(fUUID, 0, sizeof(fUUID));
1531  }
1532 
1533  JackGetClientNameRequest(const char* uuid)
1534  : JackRequest(JackRequest::kGetClientByUUID)
1535  {
1536  memset(fUUID, 0, sizeof(fUUID));
1537  strncpy(fUUID, uuid, sizeof(fUUID)-1);
1538  }
1539 
1540  int Read(detail::JackChannelTransactionInterface* trans)
1541  {
1542  CheckSize();
1543  CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1544  return 0;
1545  }
1546 
1547  int Write(detail::JackChannelTransactionInterface* trans)
1548  {
1549  CheckRes(JackRequest::Write(trans, Size()));
1550  CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1551  return 0;
1552  }
1553 
1554  int Size() { return sizeof(fUUID); }
1555 
1556 };
1557 
1558 struct JackReserveNameRequest : public JackRequest
1559 {
1560  int fRefNum;
1561  char fName[JACK_CLIENT_NAME_SIZE+1];
1562  char fUUID[JACK_UUID_STRING_SIZE];
1563 
1564  JackReserveNameRequest() : fRefNum(0)
1565  {
1566  memset(fName, 0, sizeof(fName));
1567  memset(fUUID, 0, sizeof(fUUID));
1568  }
1569 
1570  JackReserveNameRequest(int refnum, const char *name, const char* uuid)
1571  : JackRequest(JackRequest::kReserveClientName), fRefNum(refnum)
1572  {
1573  memset(fName, 0, sizeof(fName));
1574  memset(fUUID, 0, sizeof(fUUID));
1575  strncpy(fName, name, sizeof(fName)-1);
1576  strncpy(fUUID, uuid, sizeof(fUUID)-1);
1577  }
1578 
1579  int Read(detail::JackChannelTransactionInterface* trans)
1580  {
1581  CheckSize();
1582  CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1583  CheckRes(trans->Read(&fName, sizeof(fName)));
1584  CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
1585  return 0;
1586  }
1587 
1588  int Write(detail::JackChannelTransactionInterface* trans)
1589  {
1590  CheckRes(JackRequest::Write(trans, Size()));
1591  CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1592  CheckRes(trans->Write(&fName, sizeof(fName)));
1593  CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
1594  return 0;
1595  }
1596 
1597  int Size() { return sizeof(fUUID) + sizeof(fName) + sizeof(fRefNum); }
1598 
1599 };
1600 
1601 struct JackClientHasSessionCallbackRequest : public JackRequest
1602 {
1603  char fName[JACK_CLIENT_NAME_SIZE+1];
1604 
1605  JackClientHasSessionCallbackRequest()
1606  {
1607  memset(fName, 0, sizeof(fName));
1608  }
1609 
1610  JackClientHasSessionCallbackRequest(const char *name)
1611  : JackRequest(JackRequest::kClientHasSessionCallback)
1612  {
1613  memset(fName, 0, sizeof(fName));
1614  strncpy(fName, name, sizeof(fName)-1);
1615  }
1616 
1617  int Read(detail::JackChannelTransactionInterface* trans)
1618  {
1619  CheckSize();
1620  CheckRes(trans->Read(&fName, sizeof(fName)));
1621  return 0;
1622  }
1623 
1624  int Write(detail::JackChannelTransactionInterface* trans)
1625  {
1626  CheckRes(JackRequest::Write(trans, Size()));
1627  CheckRes(trans->Write(&fName, sizeof(fName)));
1628  return 0;
1629  }
1630 
1631  int Size() { return sizeof(fName); }
1632 
1633 };
1634 
1635 
1636 struct JackPropertyChangeNotifyRequest : public JackRequest
1637 {
1638  jack_uuid_t fSubject;
1639  char fKey[MAX_PATH+1];
1640  jack_property_change_t fChange;
1641 
1642  JackPropertyChangeNotifyRequest() : fChange((jack_property_change_t)0)
1643  {
1644  jack_uuid_clear(&fSubject);
1645  memset(fKey, 0, sizeof(fKey));
1646  }
1647  JackPropertyChangeNotifyRequest(jack_uuid_t subject, const char* key, jack_property_change_t change)
1648  : JackRequest(JackRequest::kPropertyChangeNotify), fChange(change)
1649  {
1650  jack_uuid_copy(&fSubject, subject);
1651  memset(fKey, 0, sizeof(fKey));
1652  if (key)
1653  strncpy(fKey, key, sizeof(fKey)-1);
1654  }
1655 
1656  int Read(detail::JackChannelTransactionInterface* trans)
1657  {
1658  CheckSize();
1659  CheckRes(trans->Read(&fSubject, sizeof(fSubject)));
1660  CheckRes(trans->Read(&fKey, sizeof(fKey)));
1661  CheckRes(trans->Read(&fChange, sizeof(fChange)));
1662  return 0;
1663  }
1664 
1665  int Write(detail::JackChannelTransactionInterface* trans)
1666  {
1667  CheckRes(JackRequest::Write(trans, Size()));
1668  CheckRes(trans->Write(&fSubject, sizeof(fSubject)));
1669  CheckRes(trans->Write(&fKey, sizeof(fKey)));
1670  CheckRes(trans->Write(&fChange, sizeof(fChange)));
1671  return 0;
1672  }
1673 
1674  int Size() { return sizeof(fSubject) + sizeof(fKey) + sizeof(fChange); }
1675 };
1676 
1681 struct JackClientNotification
1682 {
1683  int fSize;
1684  char fName[JACK_CLIENT_NAME_SIZE+1];
1685  int fRefNum;
1686  int fNotify;
1687  int fValue1;
1688  int fValue2;
1689  int fSync;
1690  char fMessage[JACK_MESSAGE_SIZE+1];
1691 
1692  JackClientNotification(): fSize(0), fRefNum(0), fNotify(-1), fValue1(-1), fValue2(-1), fSync(0)
1693  {
1694  memset(fName, 0, sizeof(fName));
1695  memset(fMessage, 0, sizeof(fMessage));
1696  }
1697  JackClientNotification(const char* name, int refnum, int notify, int sync, const char* message, int value1, int value2)
1698  : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
1699  {
1700  memset(fName, 0, sizeof(fName));
1701  memset(fMessage, 0, sizeof(fMessage));
1702  strncpy(fName, name, sizeof(fName)-1);
1703  if (message) {
1704  strncpy(fMessage, message, sizeof(fMessage)-1);
1705  }
1706  fSize = Size();
1707  }
1708 
1709  int Read(detail::JackChannelTransactionInterface* trans)
1710  {
1711  CheckSize();
1712  CheckRes(trans->Read(&fName, sizeof(fName)));
1713  CheckRes(trans->Read(&fRefNum, sizeof(int)));
1714  CheckRes(trans->Read(&fNotify, sizeof(int)));
1715  CheckRes(trans->Read(&fValue1, sizeof(int)));
1716  CheckRes(trans->Read(&fValue2, sizeof(int)));
1717  CheckRes(trans->Read(&fSync, sizeof(int)));
1718  CheckRes(trans->Read(&fMessage, sizeof(fMessage)));
1719  return 0;
1720  }
1721 
1722  int Write(detail::JackChannelTransactionInterface* trans)
1723  {
1724  CheckRes(trans->Write(&fSize, sizeof(int)));
1725  CheckRes(trans->Write(&fName, sizeof(fName)));
1726  CheckRes(trans->Write(&fRefNum, sizeof(int)));
1727  CheckRes(trans->Write(&fNotify, sizeof(int)));
1728  CheckRes(trans->Write(&fValue1, sizeof(int)));
1729  CheckRes(trans->Write(&fValue2, sizeof(int)));
1730  CheckRes(trans->Write(&fSync, sizeof(int)));
1731  CheckRes(trans->Write(&fMessage, sizeof(fMessage)));
1732  return 0;
1733  }
1734 
1735  int Size() { return sizeof(int) + sizeof(fName) + 5 * sizeof(int) + sizeof(fMessage); }
1736 
1737 };
1738 
1739 } // end of namespace
1740 
1741 #endif
Jack::JackReleaseTimebaseRequest
ReleaseTimebase request.
Definition: JackRequest.h:832
Jack::JackPortConnectNameRequest
PortConnectName request.
Definition: JackRequest.h:531
JackSessionSaveError
Definition: session.h:87
Jack::JackSetBufferSizeRequest
SetBufferSize request.
Definition: JackRequest.h:745
Jack::JackInternalClientHandleResult
InternalClientHandle result.
Definition: JackRequest.h:1004
Jack::JackClientCloseRequest
CloseClient request.
Definition: JackRequest.h:326
Jack::JackClientCheckResult
CheckClient result.
Definition: JackRequest.h:206
Jack::JackSetTimebaseCallbackRequest
SetTimebaseCallback request.
Definition: JackRequest.h:863
Jack::JackPortDisconnectRequest
PortDisconnect request.
Definition: JackRequest.h:663
Jack::JackResult
Result from the server.
Definition: JackRequest.h:130
Jack::JackClientOpenRequest
NewClient request.
Definition: JackRequest.h:245
Jack::JackInternalClientLoadResult
InternalClientLoad result.
Definition: JackRequest.h:1103
Jack::JackRequest
Request from client to server.
Definition: JackRequest.h:56
Jack::JackClientNotificationRequest
ClientNotification request.
Definition: JackRequest.h:1203
Jack::JackClientCheckRequest
CheckClient request.
Definition: JackRequest.h:158
Jack::JackGetInternalClientNameRequest
GetInternalClientName request.
Definition: JackRequest.h:896
Jack::JackClientOpenResult
NewClient result.
Definition: JackRequest.h:288
Jack::JackGetInternalClientNameResult
GetInternalClient result.
Definition: JackRequest.h:929
jack_session_command_t
Definition: JackSession.h:59
Jack::JackPortRegisterResult
PortRegister result.
Definition: JackRequest.h:470
Jack::JackComputeTotalLatenciesRequest
ComputeTotalLatencies request.
Definition: JackRequest.h:806
Jack::JackPortRenameRequest
PortRename request.
Definition: JackRequest.h:701
Jack::JackDeactivateRequest
Deactivate request.
Definition: JackRequest.h:388
Jack::JackActivateRequest
Activate request.
Definition: JackRequest.h:355
Jack::JackPortUnRegisterRequest
PortUnregister request.
Definition: JackRequest.h:496
jack_session_flags_t
enum JackSessionFlags jack_session_flags_t
Definition: session.h:98
Jack::JackSessionNotifyRequest
SessionNotify request.
Definition: JackRequest.h:1356
Jack::JackInternalClientUnloadRequest
InternalClientUnload request.
Definition: JackRequest.h:1138
Jack::JackInternalClientLoadRequest
InternalClientLoad request.
Definition: JackRequest.h:1039
Jack::JackPortConnectRequest
PortConnect request.
Definition: JackRequest.h:625
Jack::JackInternalClientUnloadResult
InternalClientLoad result.
Definition: JackRequest.h:1171
Jack::JackPortDisconnectNameRequest
PortDisconnectName request.
Definition: JackRequest.h:578
Jack::JackSetFreeWheelRequest
SetFreeWheel request.
Definition: JackRequest.h:775
Jack::JackClientNotification
ClientNotification.
Definition: JackRequest.h:1681
Jack::JackPortRegisterRequest
PortRegister request.
Definition: JackRequest.h:417
JackSessionSave
Definition: session.h:57
Jack::JackInternalClientHandleRequest
InternalClientHandle request.
Definition: JackRequest.h:966
Generated by   doxygen 1.8.6