jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2507 Commits
7 Branches
94MB
Tree: b8c47e5967
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b8c47e5967'
${ noResults }
jack2/common/JackRequest.h

1480 lines
36KB
Raw Blame History 

  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 "types.h"

  27. #include <string.h>

  28. #include <stdio.h>

  29. #include <list>

  30. 

  31. namespace Jack

  32. {

  33. 

  34. #define CheckRes(exp) { if ((exp) < 0) return -1;}

  35. 

  36. /*!

  37. \brief Request from client to server.

  38. */

  39. 

  40. struct JackRequest

  41. {

  42. 

  43.     enum RequestType {

  44.         kRegisterPort = 1,

  45.         kUnRegisterPort = 2,

  46.         kConnectPorts = 3,

  47.         kDisconnectPorts = 4,

  48.         kSetTimeBaseClient = 5,

  49.         kActivateClient = 6,

  50.         kDeactivateClient = 7,

  51.         kDisconnectPort = 8,

  52.         kSetClientCapabilities = 9,

  53.         kGetPortConnections = 10,

  54.         kGetPortNConnections = 11,

  55.         kReleaseTimebase = 12,

  56.         kSetTimebaseCallback = 13,

  57.         kSetBufferSize = 20,

  58.         kSetFreeWheel = 21,

  59.         kClientCheck = 22,

  60.         kClientOpen = 23,

  61.         kClientClose = 24,

  62.         kConnectNamePorts = 25,

  63.         kDisconnectNamePorts = 26,

  64.         kGetInternalClientName = 27,

  65.         kInternalClientHandle = 28,

  66.         kInternalClientLoad = 29,

  67.         kInternalClientUnload = 30,

  68.         kPortRename = 31,

  69.         kNotification = 32,

  70.         kSessionNotify = 33,

  71.         kSessionReply  = 34,

  72.         kGetClientByUUID = 35,

  73.         kReserveClientName = 36,

  74.         kGetUUIDByClient = 37,

  75.         kClientHasSessionCallback = 38,

  76.         kComputeTotalLatencies = 39

  77.     };

  78. 

  79.     RequestType fType;

  80. 

  81.     JackRequest()

  82.     {}

  83. 

  84.     JackRequest(RequestType type): fType(type)

  85.     {}

  86. 

  87.     virtual ~JackRequest()

  88.     {}

  89. 

  90.     virtual int Read(JackChannelTransaction* trans)

  91.     {

  92.         return trans->Read(&fType, sizeof(RequestType));

  93.     }

  94. 

  95.     virtual int Write(JackChannelTransaction* trans)

  96.     {

  97.         return trans->Write(&fType, sizeof(RequestType));

  98.     }

  99. 

  100. };

  101. 

  102. /*!

  103. \brief Result from the server.

  104. */

  105. 

  106. struct JackResult

  107. {

  108. 

  109.     int fResult;

  110. 

  111.     JackResult(): fResult( -1)

  112.     {}

  113.     JackResult(int result): fResult(result)

  114.     {}

  115.     virtual ~JackResult()

  116.     {}

  117. 

  118.     virtual int Read(JackChannelTransaction* trans)

  119.     {

  120.         return trans->Read(&fResult, sizeof(int));

  121.     }

  122. 

  123.     virtual int Write(JackChannelTransaction* trans)

  124.     {

  125.         return trans->Write(&fResult, sizeof(int));

  126.     }

  127. 

  128. };

  129. 

  130. /*!

  131. \brief CheckClient request.

  132. */

  133. 

  134. struct JackClientCheckRequest : public JackRequest

  135. {

  136. 

  137.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  138.     int fProtocol;

  139.     int fOptions;

  140.     int fUUID;

  141.     int fOpen;

  142. 

  143.     JackClientCheckRequest()

  144.     {}

  145.     JackClientCheckRequest(const char* name, int protocol, int options, int uuid, int open = false)

  146.         : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options), fUUID(uuid), fOpen(open)

  147.     {

  148.         snprintf(fName, sizeof(fName), "%s", name);

  149.     }

  150. 

  151.     int Read(JackChannelTransaction* trans)

  152.     {

  153.         CheckRes(trans->Read(&fName, sizeof(fName)));

  154.         CheckRes(trans->Read(&fProtocol, sizeof(int)));

  155.         CheckRes(trans->Read(&fOptions, sizeof(int)));

  156.         CheckRes(trans->Read(&fUUID, sizeof(int)));

  157.         return trans->Read(&fOpen, sizeof(int));

  158.     }

  159. 

  160.     int Write(JackChannelTransaction* trans)

  161.     {

  162.         CheckRes(JackRequest::Write(trans));

  163.         CheckRes(trans->Write(&fName,  sizeof(fName)));

  164.         CheckRes(trans->Write(&fProtocol, sizeof(int)));

  165.         CheckRes(trans->Write(&fOptions, sizeof(int)));

  166.         CheckRes(trans->Write(&fUUID, sizeof(int)));

  167.         return trans->Write(&fOpen, sizeof(int));

  168.     }

  169. 

  170. };

  171. 

  172. /*!

  173. \brief CheckClient result.

  174. */

  175. 

  176. struct JackClientCheckResult : public JackResult

  177. {

  178. 

  179.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  180.     int fStatus;

  181. 

  182.     JackClientCheckResult(): JackResult(), fStatus(0)

  183.     {}

  184.     JackClientCheckResult(int32_t result, const char* name, int status)

  185.             : JackResult(result), fStatus(status)

  186.     {

  187.         snprintf(fName, sizeof(fName), "%s", name);

  188.     }

  189. 

  190.     int Read(JackChannelTransaction* trans)

  191.     {

  192.         CheckRes(JackResult::Read(trans));

  193.         CheckRes(trans->Read(&fName, sizeof(fName)));

  194.         CheckRes(trans->Read(&fStatus, sizeof(int)));

  195.         return 0;

  196.     }

  197. 

  198.     int Write(JackChannelTransaction* trans)

  199.     {

  200.         CheckRes(JackResult::Write(trans));

  201.         CheckRes(trans->Write(&fName, sizeof(fName)));

  202.         CheckRes(trans->Write(&fStatus, sizeof(int)));

  203.         return 0;

  204.     }

  205. 

  206. };

  207. 

  208. /*!

  209. \brief NewClient request.

  210. */

  211. 

  212. struct JackClientOpenRequest : public JackRequest

  213. {

  214. 

  215.     int fPID;

  216.     int fUUID;

  217.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  218. 

  219.     JackClientOpenRequest()

  220.     {}

  221.     JackClientOpenRequest(const char* name, int pid, int uuid): JackRequest(JackRequest::kClientOpen)

  222.     {

  223.         snprintf(fName, sizeof(fName), "%s", name);

  224.         fPID = pid;

  225.         fUUID = uuid;

  226.     }

  227. 

  228.     int Read(JackChannelTransaction* trans)

  229.     {

  230.         CheckRes(trans->Read(&fPID, sizeof(int)));

  231.         CheckRes(trans->Read(&fUUID, sizeof(int)));

  232.         return trans->Read(&fName,  sizeof(fName));

  233.     }

  234. 

  235.     int Write(JackChannelTransaction* trans)

  236.     {

  237.         CheckRes(JackRequest::Write(trans));

  238.         CheckRes(trans->Write(&fPID, sizeof(int)));

  239.         CheckRes(trans->Write(&fUUID, sizeof(int)));

  240.         return trans->Write(&fName,  sizeof(fName));

  241.     }

  242. 

  243. };

  244. 

  245. /*!

  246. \brief NewClient result.

  247. */

  248. 

  249. struct JackClientOpenResult : public JackResult

  250. {

  251. 

  252.     int fSharedEngine;

  253.     int fSharedClient;

  254.     int fSharedGraph;

  255. 

  256.     JackClientOpenResult()

  257.             : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)

  258.     {}

  259.     JackClientOpenResult(int32_t result, int index1, int index2, int index3)

  260.             : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)

  261.     {}

  262. 

  263.     int Read(JackChannelTransaction* trans)

  264.     {

  265.         CheckRes(JackResult::Read(trans));

  266.         CheckRes(trans->Read(&fSharedEngine, sizeof(int)));

  267.         CheckRes(trans->Read(&fSharedClient, sizeof(int)));

  268.         CheckRes(trans->Read(&fSharedGraph, sizeof(int)));

  269.         return 0;

  270.     }

  271. 

  272.     int Write(JackChannelTransaction* trans)

  273.     {

  274.         CheckRes(JackResult::Write(trans));

  275.         CheckRes(trans->Write(&fSharedEngine, sizeof(int)));

  276.         CheckRes(trans->Write(&fSharedClient, sizeof(int)));

  277.         CheckRes(trans->Write(&fSharedGraph, sizeof(int)));

  278.         return 0;

  279.     }

  280. 

  281. };

  282. 

  283. /*!

  284. \brief CloseClient request.

  285. */

  286. 

  287. struct JackClientCloseRequest : public JackRequest

  288. {

  289. 

  290.     int fRefNum;

  291. 

  292.     JackClientCloseRequest()

  293.     {}

  294.     JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)

  295.     {}

  296. 

  297.     int Read(JackChannelTransaction* trans)

  298.     {

  299.         return trans->Read(&fRefNum, sizeof(int));

  300.     }

  301. 

  302.     int Write(JackChannelTransaction* trans)

  303.     {

  304.         CheckRes(JackRequest::Write(trans));

  305.         return trans->Write(&fRefNum, sizeof(int));

  306.     }

  307. 

  308. };

  309. 

  310. /*!

  311. \brief Activate request.

  312. */

  313. 

  314. struct JackActivateRequest : public JackRequest

  315. {

  316. 

  317.     int fRefNum;

  318.     int fIsRealTime;

  319. 

  320.     JackActivateRequest()

  321.     {}

  322.     JackActivateRequest(int refnum, int is_real_time)

  323.         : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fIsRealTime(is_real_time)

  324.     {}

  325. 

  326.     int Read(JackChannelTransaction* trans)

  327.     {

  328.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  329.         return trans->Read(&fIsRealTime, sizeof(int));

  330.     }

  331. 

  332.     int Write(JackChannelTransaction* trans)

  333.     {

  334.         CheckRes(JackRequest::Write(trans));

  335.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  336.         return trans->Write(&fIsRealTime, sizeof(int));

  337.     }

  338. 

  339. };

  340. 

  341. /*!

  342. \brief Deactivate request.

  343. */

  344. 

  345. struct JackDeactivateRequest : public JackRequest

  346. {

  347. 

  348.     int fRefNum;

  349. 

  350.     JackDeactivateRequest()

  351.     {}

  352.     JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)

  353.     {}

  354. 

  355.     int Read(JackChannelTransaction* trans)

  356.     {

  357.         return trans->Read(&fRefNum, sizeof(int));

  358.     }

  359. 

  360.     int Write(JackChannelTransaction* trans)

  361.     {

  362.         CheckRes(JackRequest::Write(trans));

  363.         return trans->Write(&fRefNum, sizeof(int));

  364.     }

  365. 

  366. };

  367. 

  368. /*!

  369. \brief PortRegister request.

  370. */

  371. 

  372. struct JackPortRegisterRequest : public JackRequest

  373. {

  374. 

  375.     int fRefNum;

  376.     char fName[JACK_PORT_NAME_SIZE + 1];

  377.     char fPortType[JACK_PORT_TYPE_SIZE + 1];

  378.     unsigned int fFlags;

  379.     unsigned int fBufferSize;

  380. 

  381.     JackPortRegisterRequest()

  382.     {}

  383.     JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)

  384.             : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)

  385.     {

  386.         strcpy(fName, name);

  387.         strcpy(fPortType, port_type);

  388.     }

  389. 

  390.     int Read(JackChannelTransaction* trans)

  391.     {

  392.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  393.         CheckRes(trans->Read(&fName, sizeof(fName)));

  394.         CheckRes(trans->Read(&fPortType, sizeof(fPortType)));

  395.         CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));

  396.         CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));

  397.         return 0;

  398.     }

  399. 

  400.     int Write(JackChannelTransaction* trans)

  401.     {

  402.         CheckRes(JackRequest::Write(trans));

  403.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  404.         CheckRes(trans->Write(&fName, sizeof(fName)));

  405.         CheckRes(trans->Write(&fPortType, sizeof(fPortType)));

  406.         CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));

  407.         CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));

  408.         return 0;

  409.     }

  410. 

  411. };

  412. 

  413. /*!

  414. \brief PortRegister result.

  415. */

  416. 

  417. struct JackPortRegisterResult : public JackResult

  418. {

  419. 

  420.     jack_port_id_t fPortIndex;

  421. 

  422.     JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)

  423.     {}

  424. 

  425.     int Read(JackChannelTransaction* trans)

  426.     {

  427.         CheckRes(JackResult::Read(trans));

  428.         return trans->Read(&fPortIndex, sizeof(jack_port_id_t));

  429.     }

  430. 

  431.     int Write(JackChannelTransaction* trans)

  432.     {

  433.         CheckRes(JackResult::Write(trans));

  434.         return trans->Write(&fPortIndex, sizeof(jack_port_id_t));

  435.     }

  436. 

  437. };

  438. 

  439. /*!

  440. \brief PortUnregister request.

  441. */

  442. 

  443. struct JackPortUnRegisterRequest : public JackRequest

  444. {

  445. 

  446.     int fRefNum;

  447.     jack_port_id_t fPortIndex;

  448. 

  449.     JackPortUnRegisterRequest()

  450.     {}

  451.     JackPortUnRegisterRequest(int refnum, jack_port_id_t index)

  452.         : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)

  453.     {}

  454. 

  455.     int Read(JackChannelTransaction* trans)

  456.     {

  457.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  458.         CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));

  459.         return 0;

  460.     }

  461. 

  462.     int Write(JackChannelTransaction* trans)

  463.     {

  464.         CheckRes(JackRequest::Write(trans));

  465.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  466.         CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));

  467.         return 0;

  468.     }

  469. 

  470. };

  471. 

  472. /*!

  473. \brief PortConnectName request.

  474. */

  475. 

  476. struct JackPortConnectNameRequest : public JackRequest

  477. {

  478. 

  479.     int fRefNum;

  480.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  481.     char fDst[JACK_PORT_NAME_SIZE + 1];

  482. 

  483.     JackPortConnectNameRequest()

  484.     {}

  485.     JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)

  486.         : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)

  487.     {

  488.         strcpy(fSrc, src_name);

  489.         strcpy(fDst, dst_name);

  490.     }

  491. 

  492.     int Read(JackChannelTransaction* trans)

  493.     {

  494.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  495.         CheckRes(trans->Read(&fSrc, sizeof(fSrc)));

  496.         CheckRes(trans->Read(&fDst, sizeof(fDst)));

  497.         return 0;

  498. 

  499.     }

  500. 

  501.     int Write(JackChannelTransaction* trans)

  502.     {

  503.         CheckRes(JackRequest::Write(trans));

  504.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  505.         CheckRes(trans->Write(&fSrc, sizeof(fSrc)));

  506.         CheckRes(trans->Write(&fDst, sizeof(fDst)));

  507.         return 0;

  508.     }

  509. 

  510. };

  511. 

  512. /*!

  513. \brief PortDisconnectName request.

  514. */

  515. 

  516. struct JackPortDisconnectNameRequest : public JackRequest

  517. {

  518. 

  519.     int fRefNum;

  520.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  521.     char fDst[JACK_PORT_NAME_SIZE + 1];

  522. 

  523.     JackPortDisconnectNameRequest()

  524.     {}

  525.     JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)

  526.         : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)

  527.     {

  528.         strcpy(fSrc, src_name);

  529.         strcpy(fDst, dst_name);

  530.     }

  531. 

  532.     int Read(JackChannelTransaction* trans)

  533.     {

  534.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  535.         CheckRes(trans->Read(&fSrc, sizeof(fSrc)));

  536.         CheckRes(trans->Read(&fDst, sizeof(fDst)));

  537.         return 0;

  538.     }

  539. 

  540.     int Write(JackChannelTransaction* trans)

  541.     {

  542.         CheckRes(JackRequest::Write(trans));

  543.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  544.         CheckRes(trans->Write(&fSrc, sizeof(fSrc)));

  545.         CheckRes(trans->Write(&fDst, sizeof(fDst)));

  546.         return 0;

  547.     }

  548. 

  549. };

  550. 

  551. /*!

  552. \brief PortConnect request.

  553. */

  554. 

  555. struct JackPortConnectRequest : public JackRequest

  556. {

  557. 

  558.     int fRefNum;

  559.     jack_port_id_t fSrc;

  560.     jack_port_id_t fDst;

  561. 

  562.     JackPortConnectRequest()

  563.     {}

  564.     JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)

  565.         : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)

  566.     {}

  567. 

  568.     int Read(JackChannelTransaction* trans)

  569.     {

  570.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  571.         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));

  572.         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));

  573.         return 0;

  574.     }

  575. 

  576.     int Write(JackChannelTransaction* trans)

  577.     {

  578.         CheckRes(JackRequest::Write(trans));

  579.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  580.         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));

  581.         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));

  582.         return 0;

  583.     }

  584. 

  585. };

  586. 

  587. /*!

  588. \brief PortDisconnect request.

  589. */

  590. 

  591. struct JackPortDisconnectRequest : public JackRequest

  592. {

  593. 

  594.     int fRefNum;

  595.     jack_port_id_t fSrc;

  596.     jack_port_id_t fDst;

  597. 

  598.     JackPortDisconnectRequest()

  599.     {}

  600.     JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)

  601.         : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)

  602.     {}

  603. 

  604.     int Read(JackChannelTransaction* trans)

  605.     {

  606.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  607.         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));

  608.         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));

  609.         return 0;

  610.     }

  611. 

  612.     int Write(JackChannelTransaction* trans)

  613.     {

  614.         CheckRes(JackRequest::Write(trans));

  615.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  616.         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));

  617.         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));

  618.         return 0;

  619.     }

  620. 

  621. };

  622. 

  623. /*!

  624. \brief PortRename request.

  625. */

  626. 

  627. struct JackPortRenameRequest : public JackRequest

  628. {

  629. 

  630.     int fRefNum;

  631.     jack_port_id_t fPort;

  632.     char fName[JACK_PORT_NAME_SIZE + 1];

  633. 

  634.     JackPortRenameRequest()

  635.     {}

  636.     JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)

  637.         : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)

  638.     {

  639.         strcpy(fName, name);

  640.     }

  641. 

  642.     int Read(JackChannelTransaction* trans)

  643.     {

  644.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  645.         CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));

  646.         CheckRes(trans->Read(&fName, sizeof(fName)));

  647.         return 0;

  648.     }

  649. 

  650.     int Write(JackChannelTransaction* trans)

  651.     {

  652.         CheckRes(JackRequest::Write(trans));

  653.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  654.         CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));

  655.         CheckRes(trans->Write(&fName, sizeof(fName)));

  656.         return 0;

  657. 

  658.     }

  659. 

  660. };

  661. 

  662. /*!

  663. \brief SetBufferSize request.

  664. */

  665. 

  666. struct JackSetBufferSizeRequest : public JackRequest

  667. {

  668. 

  669.     jack_nframes_t fBufferSize;

  670. 

  671.     JackSetBufferSizeRequest()

  672.     {}

  673.     JackSetBufferSizeRequest(jack_nframes_t buffer_size)

  674.         : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)

  675.     {}

  676. 

  677.     int Read(JackChannelTransaction* trans)

  678.     {

  679.         return trans->Read(&fBufferSize, sizeof(jack_nframes_t));

  680.     }

  681. 

  682.     int Write(JackChannelTransaction* trans)

  683.     {

  684.         CheckRes(JackRequest::Write(trans));

  685.         return trans->Write(&fBufferSize, sizeof(jack_nframes_t));

  686.     }

  687. 

  688. };

  689. 

  690. /*!

  691. \brief SetFreeWheel request.

  692. */

  693. 

  694. struct JackSetFreeWheelRequest : public JackRequest

  695. {

  696. 

  697.     int fOnOff;

  698. 

  699.     JackSetFreeWheelRequest()

  700.     {}

  701.     JackSetFreeWheelRequest(int onoff)

  702.         : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)

  703.     {}

  704. 

  705.     int Read(JackChannelTransaction* trans)

  706.     {

  707.         return trans->Read(&fOnOff, sizeof(int));

  708.     }

  709. 

  710.     int Write(JackChannelTransaction* trans)

  711.     {

  712.         CheckRes(JackRequest::Write(trans));

  713.         return trans->Write(&fOnOff, sizeof(int));

  714.     }

  715. 

  716. };

  717. 

  718. /*!

  719. \brief ComputeTotalLatencies request.

  720. */

  721. 

  722. struct JackComputeTotalLatenciesRequest : public JackRequest

  723. {

  724. 

  725.     JackComputeTotalLatenciesRequest()

  726.         : JackRequest(JackRequest::kComputeTotalLatencies)

  727.     {}

  728. 

  729.     int Read(JackChannelTransaction* trans)

  730.     {

  731.         return 0;

  732.     }

  733. 

  734.     int Write(JackChannelTransaction* trans)

  735.     {

  736.         CheckRes(JackRequest::Write(trans));

  737.         return 0;

  738.     }

  739. 

  740. };

  741. 

  742. /*!

  743. \brief ReleaseTimebase request.

  744. */

  745. 

  746. struct JackReleaseTimebaseRequest : public JackRequest

  747. {

  748. 

  749.     int fRefNum;

  750. 

  751.     JackReleaseTimebaseRequest()

  752.     {}

  753.     JackReleaseTimebaseRequest(int refnum)

  754.         : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)

  755.     {}

  756. 

  757.     int Read(JackChannelTransaction* trans)

  758.     {

  759.         return trans->Read(&fRefNum, sizeof(int));

  760.     }

  761. 

  762.     int Write(JackChannelTransaction* trans)

  763.     {

  764.         CheckRes(JackRequest::Write(trans));

  765.         return trans->Write(&fRefNum, sizeof(int));

  766.     }

  767. 

  768. };

  769. 

  770. /*!

  771. \brief SetTimebaseCallback request.

  772. */

  773. 

  774. struct JackSetTimebaseCallbackRequest : public JackRequest

  775. {

  776. 

  777.     int fRefNum;

  778.     int fConditionnal;

  779. 

  780.     JackSetTimebaseCallbackRequest()

  781.     {}

  782.     JackSetTimebaseCallbackRequest(int refnum, int conditional)

  783.         : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)

  784.     {}

  785. 

  786.     int Read(JackChannelTransaction* trans)

  787.     {

  788.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  789.         return trans->Read(&fConditionnal, sizeof(int));

  790.     }

  791. 

  792.     int Write(JackChannelTransaction* trans)

  793.     {

  794.         CheckRes(JackRequest::Write(trans));

  795.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  796.         return trans->Write(&fConditionnal, sizeof(int));

  797.     }

  798. 

  799. };

  800. 

  801. /*!

  802. \brief GetInternalClientName request.

  803. */

  804. 

  805. struct JackGetInternalClientNameRequest : public JackRequest

  806. {

  807. 

  808.     int fRefNum;

  809.     int fIntRefNum;

  810. 

  811.     JackGetInternalClientNameRequest()

  812.     {}

  813.     JackGetInternalClientNameRequest(int refnum, int int_ref)

  814.             : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)

  815.     {}

  816. 

  817.     int Read(JackChannelTransaction* trans)

  818.     {

  819.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  820.         return trans->Read(&fIntRefNum, sizeof(int));

  821.     }

  822. 

  823.     int Write(JackChannelTransaction* trans)

  824.     {

  825.         CheckRes(JackRequest::Write(trans));

  826.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  827.         return trans->Write(&fIntRefNum, sizeof(int));

  828.     }

  829. 

  830. };

  831. 

  832. /*!

  833. \brief GetInternalClient result.

  834. */

  835. 

  836. struct JackGetInternalClientNameResult : public JackResult

  837. {

  838. 

  839.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  840. 

  841.     JackGetInternalClientNameResult(): JackResult()

  842.     {}

  843.     JackGetInternalClientNameResult(int32_t result, const char* name)

  844.             : JackResult(result)

  845.     {

  846.         snprintf(fName, sizeof(fName), "%s", name);

  847.     }

  848. 

  849.     int Read(JackChannelTransaction* trans)

  850.     {

  851.         CheckRes(JackResult::Read(trans));

  852.         CheckRes(trans->Read(&fName,  sizeof(fName)));

  853.         return 0;

  854.     }

  855. 

  856.     int Write(JackChannelTransaction* trans)

  857.     {

  858.         CheckRes(JackResult::Write(trans));

  859.         CheckRes(trans->Write(&fName,  sizeof(fName)));

  860.         return 0;

  861.     }

  862. 

  863. };

  864. 

  865. /*!

  866. \brief InternalClientHandle request.

  867. */

  868. 

  869. struct JackInternalClientHandleRequest : public JackRequest

  870. {

  871. 

  872.     int fRefNum;

  873.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  874. 

  875.     JackInternalClientHandleRequest()

  876.     {}

  877.     JackInternalClientHandleRequest(int refnum, const char* client_name)

  878.             : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)

  879.     {

  880.         snprintf(fName, sizeof(fName), "%s", client_name);

  881.     }

  882. 

  883.     int Read(JackChannelTransaction* trans)

  884.     {

  885.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  886.         return trans->Read(&fName,  sizeof(fName));

  887.     }

  888. 

  889.     int Write(JackChannelTransaction* trans)

  890.     {

  891.         CheckRes(JackRequest::Write(trans));

  892.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  893.         return trans->Write(&fName,  sizeof(fName));

  894.     }

  895. 

  896. };

  897. 

  898. /*!

  899. \brief InternalClientHandle result.

  900. */

  901. 

  902. struct JackInternalClientHandleResult : public JackResult

  903. {

  904. 

  905.     int fStatus;

  906.     int fIntRefNum;

  907. 

  908.     JackInternalClientHandleResult(): JackResult()

  909.     {}

  910.     JackInternalClientHandleResult(int32_t result, int status, int int_ref)

  911.             : JackResult(result), fStatus(status), fIntRefNum(int_ref)

  912.     {}

  913. 

  914.     int Read(JackChannelTransaction* trans)

  915.     {

  916.         CheckRes(JackResult::Read(trans));

  917.         CheckRes(trans->Read(&fStatus, sizeof(int)));

  918.         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));

  919.         return 0;

  920.     }

  921. 

  922.     int Write(JackChannelTransaction* trans)

  923.     {

  924.         CheckRes(JackResult::Write(trans));

  925.         CheckRes(trans->Write(&fStatus, sizeof(int)));

  926.         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));

  927.         return 0;

  928.     }

  929. 

  930. };

  931. 

  932. /*!

  933. \brief InternalClientLoad request.

  934. */

  935. 

  936. struct JackInternalClientLoadRequest : public JackRequest

  937. {

  938. 

  939. #ifndef MAX_PATH

  940. #define MAX_PATH 256

  941. #endif

  942. 

  943.     int fRefNum;

  944.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  945.     char fDllName[MAX_PATH + 1];

  946.     char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];

  947.     int fOptions;

  948.     int fUUID;

  949. 

  950.     JackInternalClientLoadRequest()

  951.     {}

  952.     JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int uuid )

  953.             : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options), fUUID(uuid)

  954.     {

  955.         snprintf(fName, sizeof(fName), "%s", client_name);

  956.         snprintf(fDllName, sizeof(fDllName), "%s", so_name);

  957.         snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);

  958.         snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);

  959.     }

  960. 

  961.     int Read(JackChannelTransaction* trans)

  962.     {

  963.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  964.         CheckRes(trans->Read(&fName,  sizeof(fName)));

  965.         CheckRes(trans->Read(&fDllName, sizeof(fDllName)));

  966.         CheckRes(trans->Read(&fLoadInitName, sizeof(fLoadInitName)));

  967.         CheckRes(trans->Read(&fUUID, sizeof(int)));

  968.         return trans->Read(&fOptions, sizeof(int));

  969.     }

  970. 

  971.     int Write(JackChannelTransaction* trans)

  972.     {

  973.         CheckRes(JackRequest::Write(trans));

  974.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  975.         CheckRes(trans->Write(&fName,  sizeof(fName)));

  976.         CheckRes(trans->Write(&fDllName, sizeof(fDllName)));

  977.         CheckRes(trans->Write(&fLoadInitName, sizeof(fLoadInitName)));

  978.         CheckRes(trans->Write(&fUUID, sizeof(int)));

  979.         return trans->Write(&fOptions, sizeof(int));

  980.     }

  981. 

  982. };

  983. 

  984. /*!

  985. \brief InternalClientLoad result.

  986. */

  987. 

  988. struct JackInternalClientLoadResult : public JackResult

  989. {

  990. 

  991.     int fStatus;

  992.     int fIntRefNum;

  993. 

  994.     JackInternalClientLoadResult(): JackResult()

  995.     {}

  996.     JackInternalClientLoadResult(int32_t result, int status, int int_ref)

  997.             : JackResult(result), fStatus(status), fIntRefNum(int_ref)

  998.     {}

  999. 

  1000.     int Read(JackChannelTransaction* trans)

  1001.     {

  1002.         CheckRes(JackResult::Read(trans));

  1003.         CheckRes(trans->Read(&fStatus, sizeof(int)));

  1004.         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));

  1005.         return 0;

  1006.     }

  1007. 

  1008.     int Write(JackChannelTransaction* trans)

  1009.     {

  1010.         CheckRes(JackResult::Write(trans));

  1011.         CheckRes(trans->Write(&fStatus, sizeof(int)));

  1012.         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));

  1013.         return 0;

  1014.     }

  1015. 

  1016. };

  1017. 

  1018. /*!

  1019. \brief InternalClientUnload request.

  1020. */

  1021. 

  1022. struct JackInternalClientUnloadRequest : public JackRequest

  1023. {

  1024. 

  1025.     int fRefNum;

  1026.     int fIntRefNum;

  1027. 

  1028.     JackInternalClientUnloadRequest()

  1029.     {}

  1030.     JackInternalClientUnloadRequest(int refnum, int int_ref)

  1031.             : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)

  1032.     {}

  1033. 

  1034.     int Read(JackChannelTransaction* trans)

  1035.     {

  1036.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  1037.         return trans->Read(&fIntRefNum, sizeof(int));

  1038.     }

  1039. 

  1040.     int Write(JackChannelTransaction* trans)

  1041.     {

  1042.         CheckRes(JackRequest::Write(trans));

  1043.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  1044.         return trans->Write(&fIntRefNum, sizeof(int));

  1045.     }

  1046. };

  1047. 

  1048. /*!

  1049. \brief InternalClientLoad result.

  1050. */

  1051. 

  1052. struct JackInternalClientUnloadResult : public JackResult

  1053. {

  1054. 

  1055.     int fStatus;

  1056. 

  1057.     JackInternalClientUnloadResult(): JackResult()

  1058.     {}

  1059.     JackInternalClientUnloadResult(int32_t result, int status)

  1060.             : JackResult(result), fStatus(status)

  1061.     {}

  1062. 

  1063.     int Read(JackChannelTransaction* trans)

  1064.     {

  1065.         CheckRes(JackResult::Read(trans));

  1066.         CheckRes(trans->Read(&fStatus, sizeof(int)));

  1067.         return 0;

  1068.     }

  1069. 

  1070.     int Write(JackChannelTransaction* trans)

  1071.     {

  1072.         CheckRes(JackResult::Write(trans));

  1073.         CheckRes(trans->Write(&fStatus, sizeof(int)));

  1074.         return 0;

  1075.     }

  1076. 

  1077. };

  1078. 

  1079. /*!

  1080. \brief ClientNotification request.

  1081. */

  1082. 

  1083. struct JackClientNotificationRequest : public JackRequest

  1084. {

  1085. 

  1086.     int fRefNum;

  1087.     int fNotify;

  1088.     int fValue;

  1089. 

  1090.     JackClientNotificationRequest()

  1091.     {}

  1092.     JackClientNotificationRequest(int refnum, int notify, int value)

  1093.             : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)

  1094.     {}

  1095. 

  1096.     int Read(JackChannelTransaction* trans)

  1097.     {

  1098.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  1099.         CheckRes(trans->Read(&fNotify, sizeof(int)));

  1100.         CheckRes(trans->Read(&fValue, sizeof(int)));

  1101.         return 0;

  1102.     }

  1103. 

  1104.     int Write(JackChannelTransaction* trans)

  1105.     {

  1106.         CheckRes(JackRequest::Write(trans));

  1107.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  1108.         CheckRes(trans->Write(&fNotify, sizeof(int)));

  1109.         CheckRes(trans->Write(&fValue, sizeof(int)));

  1110.         return 0;

  1111.     }

  1112. 

  1113. };

  1114. 

  1115. struct JackSessionCommand

  1116. {

  1117.     char fUUID[JACK_UUID_SIZE];

  1118.     char fClientName[JACK_CLIENT_NAME_SIZE+1];

  1119.     char fCommand[JACK_SESSION_COMMAND_SIZE];

  1120.     jack_session_flags_t fFlags;

  1121. 

  1122.     JackSessionCommand()

  1123.     {}

  1124. 

  1125.     JackSessionCommand( const char *uuid, const char *clientname, const char *command, jack_session_flags_t flags )

  1126.     {

  1127.         strncpy( fUUID, uuid, sizeof(fUUID));

  1128.         strncpy( fClientName, clientname, sizeof(fClientName));

  1129.         strncpy( fCommand, command, sizeof(fCommand));

  1130.         fFlags = flags;

  1131.     }

  1132. };

  1133. 

  1134. struct JackSessionNotifyResult : public JackResult

  1135. {

  1136. 

  1137.     std::list<JackSessionCommand> fCommandList;

  1138. 

  1139.     JackSessionNotifyResult(): JackResult()

  1140.     {}

  1141.     JackSessionNotifyResult(int32_t result)

  1142.             : JackResult(result)

  1143.     {}

  1144. 

  1145.     int Read(JackChannelTransaction* trans)

  1146.     {

  1147.         CheckRes(JackResult::Read(trans));

  1148.         while(1) {

  1149.             JackSessionCommand buffer;

  1150. 

  1151.             CheckRes(trans->Read(buffer.fUUID, sizeof(buffer.fUUID)));

  1152.             if (buffer.fUUID[0] == '\0')

  1153.                 break;

  1154. 

  1155.             CheckRes(trans->Read(buffer.fClientName, sizeof(buffer.fClientName)));

  1156.             CheckRes(trans->Read(buffer.fCommand, sizeof(buffer.fCommand)));

  1157.             CheckRes(trans->Read(&(buffer.fFlags), sizeof(buffer.fFlags)));

  1158. 

  1159.             fCommandList.push_back(buffer);

  1160.         }

  1161.         return 0;

  1162.     }

  1163. 

  1164.     int Write(JackChannelTransaction* trans)

  1165.     {

  1166.         char terminator[JACK_UUID_SIZE];

  1167.         terminator[0] = '\0';

  1168. 

  1169.         CheckRes(JackResult::Write(trans));

  1170.         for (std::list<JackSessionCommand>::iterator i=fCommandList.begin(); i!=fCommandList.end(); i++) {

  1171.             CheckRes(trans->Write(i->fUUID, sizeof(i->fUUID)));

  1172.             CheckRes(trans->Write(i->fClientName, sizeof(i->fClientName)));

  1173.             CheckRes(trans->Write(i->fCommand, sizeof(i->fCommand)));

  1174.             CheckRes(trans->Write(&(i->fFlags), sizeof(i->fFlags)));

  1175.         }

  1176.         CheckRes(trans->Write(terminator, sizeof(terminator)));

  1177.         return 0;

  1178.     }

  1179. 

  1180. };

  1181. 

  1182. /*!

  1183. \brief SessionNotify request.

  1184. */

  1185. 

  1186. struct JackSessionNotifyRequest : public JackRequest

  1187. {

  1188.     char fPath[JACK_MESSAGE_SIZE + 1];

  1189.     char fDst[JACK_CLIENT_NAME_SIZE + 1];

  1190.     jack_session_event_type_t  fEventType;

  1191.     int  fRefNum;

  1192. 

  1193.     JackSessionNotifyRequest()

  1194.     {}

  1195.     JackSessionNotifyRequest(int refnum, const char *path, jack_session_event_type_t type, const char *dst)

  1196.             : JackRequest(JackRequest::kSessionNotify), fEventType(type), fRefNum(refnum)

  1197.     {

  1198.         snprintf(fPath, sizeof(fPath), "%s", path);

  1199.         if (dst)

  1200.             snprintf(fDst, sizeof(fDst), "%s", dst);

  1201.         else

  1202.             fDst[0] = '\0';

  1203.     }

  1204. 

  1205.     int Read(JackChannelTransaction* trans)

  1206.     {

  1207.         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));

  1208.         CheckRes(trans->Read(&fPath, sizeof(fPath)));

  1209.         CheckRes(trans->Read(&fDst, sizeof(fDst)));

  1210.         CheckRes(trans->Read(&fEventType, sizeof(fEventType)));

  1211.         return 0;

  1212.     }

  1213. 

  1214.     int Write(JackChannelTransaction* trans)

  1215.     {

  1216.         CheckRes(JackRequest::Write(trans));

  1217.         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));

  1218.         CheckRes(trans->Write(&fPath, sizeof(fPath)));

  1219.         CheckRes(trans->Write(&fDst, sizeof(fDst)));

  1220.         CheckRes(trans->Write(&fEventType, sizeof(fEventType)));

  1221.         return 0;

  1222.     }

  1223. 

  1224. };

  1225. 

  1226. struct JackSessionReplyRequest : public JackRequest

  1227. {

  1228.     int fRefNum;

  1229. 

  1230.     JackSessionReplyRequest()

  1231.     {}

  1232. 

  1233.     JackSessionReplyRequest(int refnum)

  1234.             : JackRequest(JackRequest::kSessionReply), fRefNum(refnum)

  1235.     {}

  1236. 

  1237.     int Read(JackChannelTransaction* trans)

  1238.     {

  1239.         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));

  1240.         return 0;

  1241.     }

  1242. 

  1243.     int Write(JackChannelTransaction* trans)

  1244.     {

  1245.         CheckRes(JackRequest::Write(trans));

  1246.         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));

  1247.         return 0;

  1248.     }

  1249. 

  1250. };

  1251. 

  1252. struct JackClientNameResult : public JackResult

  1253. {

  1254.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  1255. 

  1256.     JackClientNameResult(): JackResult()

  1257.     {}

  1258.     JackClientNameResult(int32_t result, const char* name)

  1259.             : JackResult(result)

  1260.     {

  1261.         snprintf(fName, sizeof(fName), "%s", name);

  1262.     }

  1263. 

  1264.     int Read(JackChannelTransaction* trans)

  1265.     {

  1266.         CheckRes(JackResult::Read(trans));

  1267.         CheckRes(trans->Read(&fName, sizeof(fName)));

  1268.         return 0;

  1269.     }

  1270. 

  1271.     int Write(JackChannelTransaction* trans)

  1272.     {

  1273.         CheckRes(JackResult::Write(trans));

  1274.         CheckRes(trans->Write(&fName, sizeof(fName)));

  1275.         return 0;

  1276.     }

  1277. 

  1278. };

  1279. 

  1280. struct JackUUIDResult : public JackResult

  1281. {

  1282. 

  1283.     char fUUID[JACK_UUID_SIZE];

  1284. 

  1285.     JackUUIDResult(): JackResult()

  1286.     {}

  1287.     JackUUIDResult(int32_t result, const char* uuid)

  1288.             : JackResult(result)

  1289.     {

  1290.         snprintf(fUUID, sizeof(fUUID), "%s", uuid);

  1291.     }

  1292. 

  1293.     int Read(JackChannelTransaction* trans)

  1294.     {

  1295.         CheckRes(JackResult::Read(trans));

  1296.         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));

  1297.         return 0;

  1298.     }

  1299. 

  1300.     int Write(JackChannelTransaction* trans)

  1301.     {

  1302.         CheckRes(JackResult::Write(trans));

  1303.         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));

  1304.         return 0;

  1305.     }

  1306. 

  1307. };

  1308. 

  1309. struct JackGetUUIDRequest : public JackRequest

  1310. {

  1311.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  1312. 

  1313.     JackGetUUIDRequest()

  1314.     {}

  1315. 

  1316.     JackGetUUIDRequest(const char* client_name)

  1317.             : JackRequest(JackRequest::kGetUUIDByClient)

  1318.     {

  1319.         strncpy(fName, client_name, sizeof(fName));

  1320.     }

  1321. 

  1322.     int Read(JackChannelTransaction* trans)

  1323.     {

  1324.         CheckRes(trans->Read(&fName, sizeof(fName)));

  1325.         return 0;

  1326.     }

  1327. 

  1328.     int Write(JackChannelTransaction* trans)

  1329.     {

  1330.         CheckRes(JackRequest::Write(trans));

  1331.         CheckRes(trans->Write(&fName, sizeof(fName)));

  1332.         return 0;

  1333.     }

  1334. 

  1335. };

  1336. 

  1337. struct JackGetClientNameRequest : public JackRequest

  1338. {

  1339.     char fUUID[JACK_UUID_SIZE];

  1340. 

  1341.     JackGetClientNameRequest()

  1342.     {}

  1343. 

  1344.     JackGetClientNameRequest(const char* uuid)

  1345.             : JackRequest(JackRequest::kGetClientByUUID)

  1346.     {

  1347.         strncpy(fUUID, uuid, sizeof(fUUID));

  1348.     }

  1349. 

  1350.     int Read(JackChannelTransaction* trans)

  1351.     {

  1352.         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));

  1353.         return 0;

  1354.     }

  1355. 

  1356.     int Write(JackChannelTransaction* trans)

  1357.     {

  1358.         CheckRes(JackRequest::Write(trans));

  1359.         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));

  1360.         return 0;

  1361.     }

  1362. 

  1363. };

  1364. 

  1365. struct JackReserveNameRequest : public JackRequest

  1366. {

  1367.     int  fRefNum;

  1368.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  1369.     char fUUID[JACK_UUID_SIZE];

  1370. 

  1371.     JackReserveNameRequest()

  1372.     {}

  1373. 

  1374.     JackReserveNameRequest(int refnum, const char *name, const char* uuid)

  1375.             : JackRequest(JackRequest::kReserveClientName), fRefNum(refnum)

  1376.     {

  1377.         strncpy(fName, name, sizeof(fName));

  1378.         strncpy(fUUID, uuid, sizeof(fUUID));

  1379.     }

  1380. 

  1381.     int Read(JackChannelTransaction* trans)

  1382.     {

  1383.         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));

  1384.         CheckRes(trans->Read(&fName, sizeof(fName)));

  1385.         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));

  1386.         return 0;

  1387.     }

  1388. 

  1389.     int Write(JackChannelTransaction* trans)

  1390.     {

  1391.         CheckRes(JackRequest::Write(trans));

  1392.         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));

  1393.         CheckRes(trans->Write(&fName, sizeof(fName)));

  1394.         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));

  1395.         return 0;

  1396.     }

  1397. 

  1398. };

  1399. 

  1400. struct JackClientHasSessionCallbackRequest : public JackRequest

  1401. {

  1402.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  1403. 

  1404.     JackClientHasSessionCallbackRequest()

  1405.     {}

  1406. 

  1407.     JackClientHasSessionCallbackRequest(const char *name)

  1408.             : JackRequest(JackRequest::kClientHasSessionCallback)

  1409.     {

  1410.         strncpy(fName, name, sizeof(fName));

  1411.     }

  1412. 

  1413.     int Read(JackChannelTransaction* trans)

  1414.     {

  1415.         CheckRes(trans->Read(&fName, sizeof(fName)));

  1416.         return 0;

  1417.     }

  1418. 

  1419.     int Write(JackChannelTransaction* trans)

  1420.     {

  1421.         CheckRes(JackRequest::Write(trans));

  1422.         CheckRes(trans->Write(&fName, sizeof(fName)));

  1423.         return 0;

  1424.     }

  1425. 

  1426. };

  1427. 

  1428. /*!

  1429. \brief ClientNotification.

  1430. */

  1431. 

  1432. struct JackClientNotification

  1433. {

  1434.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  1435.     int fRefNum;

  1436.     int fNotify;

  1437.     int fValue1;

  1438.     int fValue2;

  1439.     int fSync;

  1440.     char fMessage[JACK_MESSAGE_SIZE + 1];

  1441. 

  1442.     JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)

  1443.     {}

  1444.     JackClientNotification(const char* name, int refnum, int notify, int sync, const char* message, int value1, int value2)

  1445.             : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)

  1446.     {

  1447.         snprintf(fName, sizeof(fName), "%s", name);

  1448.         snprintf(fMessage, sizeof(fMessage), "%s", message);

  1449.     }

  1450. 

  1451.     int Read(JackChannelTransaction* trans)

  1452.     {

  1453.         CheckRes(trans->Read(&fName, sizeof(fName)));

  1454.         CheckRes(trans->Read(&fRefNum, sizeof(int)));

  1455.         CheckRes(trans->Read(&fNotify, sizeof(int)));

  1456.         CheckRes(trans->Read(&fValue1, sizeof(int)));

  1457.         CheckRes(trans->Read(&fValue2, sizeof(int)));

  1458.         CheckRes(trans->Read(&fSync, sizeof(int)));

  1459.         CheckRes(trans->Read(&fMessage, sizeof(fName)));

  1460.         return 0;

  1461.     }

  1462. 

  1463.     int Write(JackChannelTransaction* trans)

  1464.     {

  1465.         CheckRes(trans->Write(&fName, sizeof(fName)));

  1466.         CheckRes(trans->Write(&fRefNum, sizeof(int)));

  1467.         CheckRes(trans->Write(&fNotify, sizeof(int)));

  1468.         CheckRes(trans->Write(&fValue1, sizeof(int)));

  1469.         CheckRes(trans->Write(&fValue2, sizeof(int)));

  1470.         CheckRes(trans->Write(&fSync, sizeof(int)));

  1471.         CheckRes(trans->Write(&fMessage, sizeof(fName)));

  1472.         return 0;

  1473.     }

  1474. 

  1475. };

  1476. 

  1477. } // end of namespace

  1478. 

  1479. #endif