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.
595 Commits
8 Branches
67MB
Tree: ecb8da58c7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ecb8da58c7'
${ noResults }
jack2/common/JackRequest.h

1039 lines
25KB
Raw Blame History 

  1. 

  2. 

  3. /*

  4.     Copyright (C) 2001 Paul Davis

  5. 

  6.     This program is free software; you can redistribute it and/or modify

  7.     it under the terms of the GNU General Public License as published by

  8.     the Free Software Foundation; either version 2 of the License, or

  9.     (at your option) any later version.

  10. 

  11.     This program is distributed in the hope that it will be useful,

  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  14.     GNU General Public License for more details.

  15. 

  16.     You should have received a copy of the GNU General Public License

  17.     along with this program; if not, write to the Free Software

  18.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  19. 

  20. */

  21. 

  22. #ifndef __JackRequest__

  23. #define __JackRequest__

  24. 

  25. #include "JackConstants.h"

  26. #include "JackChannelTransaction.h"

  27. #include "JackError.h"

  28. #include <stdio.h>

  29. 

  30. namespace Jack

  31. {

  32. 

  33. #define CheckRes(res) {if (res < 0) return res;}

  34. 

  35. /*!

  36. \brief Request from client to server.

  37. */

  38. 

  39. struct JackRequest

  40. {

  41. 

  42.     enum RequestType {

  43.         kRegisterPort = 1,

  44.         kUnRegisterPort = 2,

  45.         kConnectPorts = 3,

  46.         kDisconnectPorts = 4,

  47.         kSetTimeBaseClient = 5,

  48.         kActivateClient = 6,

  49.         kDeactivateClient = 7,

  50.         kDisconnectPort = 8,

  51.         kSetClientCapabilities = 9,

  52.         kGetPortConnections = 10,

  53.         kGetPortNConnections = 11,

  54.         kReleaseTimebase = 12,

  55.         kSetTimebaseCallback = 13,

  56.         kSetBufferSize = 20,

  57.         kSetFreeWheel = 21,

  58.         kClientCheck = 22,

  59.         kClientOpen = 23,

  60.         kClientClose = 24,

  61.         kConnectNamePorts = 25,

  62.         kDisconnectNamePorts = 26,

  63.         kGetInternalClientName = 27,

  64.         kInternalClientHandle = 28,

  65.         kInternalClientLoad = 29,

  66.         kInternalClientUnload = 30,

  67.         kNotification = 31

  68.     };

  69. 

  70.     RequestType fType;

  71. 

  72.     JackRequest()

  73.     {}

  74. 

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

  76.     {}

  77. 

  78.     virtual ~JackRequest()

  79.     {}

  80. 

  81.     virtual int Read(JackChannelTransaction* trans)

  82.     {

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

  84.     }

  85. 

  86.     virtual int Write(JackChannelTransaction* trans)

  87.     {

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

  89.     }

  90. 

  91. };

  92. 

  93. /*!

  94. \brief Result from the server.

  95. */

  96. 

  97. struct JackResult

  98. {

  99. 

  100.     int	fResult;

  101. 

  102.     JackResult(): fResult( -1)

  103.     {}

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

  105.     {}

  106.     virtual ~JackResult()

  107.     {}

  108. 

  109.     virtual int Read(JackChannelTransaction* trans)

  110.     {

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

  112.     }

  113. 

  114.     virtual int Write(JackChannelTransaction* trans)

  115.     {

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

  117.     }

  118. };

  119. 

  120. /*!

  121. \brief CheckClient request.

  122. */

  123. 

  124. struct JackClientCheckRequest : public JackRequest

  125. {

  126. 

  127.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  128.     int fProtocol;

  129.     int fOptions;

  130. 

  131.     JackClientCheckRequest()

  132.     {}

  133.     JackClientCheckRequest(const char* name, int protocol, int options): JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options)

  134.     {

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

  136.     }

  137. 

  138.     int Read(JackChannelTransaction* trans)

  139.     {

  140.         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));

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

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

  143.     }

  144. 

  145.     int Write(JackChannelTransaction* trans)

  146.     {

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

  148.         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));

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

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

  151.     }

  152. };

  153. 

  154. /*!

  155. \brief CheckClient result.

  156. */

  157. 

  158. struct JackClientCheckResult : public JackResult

  159. {

  160. 

  161.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  162.     int fStatus;

  163. 

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

  165.     {}

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

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

  168.     {

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

  170.     }

  171. 

  172.     int Read(JackChannelTransaction* trans)

  173.     {

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

  175.         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));

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

  177.         return 0;

  178.     }

  179. 

  180.     int Write(JackChannelTransaction* trans)

  181.     {

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

  183.         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));

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

  185.         return 0;

  186.     }

  187. };

  188. 

  189. /*!

  190. \brief NewClient request.

  191. */

  192. 

  193. struct JackClientOpenRequest : public JackRequest

  194. {

  195. 

  196.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  197. 

  198.     JackClientOpenRequest()

  199.     {}

  200.     JackClientOpenRequest(const char* name): JackRequest(JackRequest::kClientOpen)

  201.     {

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

  203.     }

  204. 

  205.     int Read(JackChannelTransaction* trans)

  206.     {

  207.         return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);

  208.     }

  209. 

  210.     int Write(JackChannelTransaction* trans)

  211.     {

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

  213.         return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);

  214.     }

  215. };

  216. 

  217. /*!

  218. \brief NewClient result.

  219. */

  220. 

  221. struct JackClientOpenResult : public JackResult

  222. {

  223. 

  224.     int fSharedEngine;

  225.     int fSharedClient;

  226.     int fSharedGraph;

  227.     uint32_t fProtocolVersion;

  228. 

  229.     JackClientOpenResult()

  230.             : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1), fProtocolVersion(0)

  231.     {}

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

  233.             : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3), fProtocolVersion(0)

  234.     {}

  235. 

  236.     int Read(JackChannelTransaction* trans)

  237.     {

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

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

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

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

  242.         CheckRes(trans->Read(&fProtocolVersion, sizeof(uint32_t)));

  243.         return 0;

  244.     }

  245. 

  246.     int Write(JackChannelTransaction* trans)

  247.     {

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

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

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

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

  252.         CheckRes(trans->Write(&fProtocolVersion, sizeof(uint32_t)));

  253.         return 0;

  254.     }

  255. };

  256. 

  257. /*!

  258. \brief CloseClient request.

  259. */

  260. 

  261. struct JackClientCloseRequest : public JackRequest

  262. {

  263. 

  264.     int fRefNum;

  265. 

  266.     JackClientCloseRequest()

  267.     {}

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

  269.     {}

  270. 

  271.     int Read(JackChannelTransaction* trans)

  272.     {

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

  274.     }

  275. 

  276.     int Write(JackChannelTransaction* trans)

  277.     {

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

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

  280.     }

  281. };

  282. 

  283. /*!

  284. \brief Activate request.

  285. */

  286. 

  287. struct JackActivateRequest : public JackRequest

  288. {

  289. 

  290.     int fRefNum;

  291. 

  292.     JackActivateRequest()

  293.     {}

  294.     JackActivateRequest(int refnum): JackRequest(JackRequest::kActivateClient), 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 Deactivate request.

  312. */

  313. 

  314. struct JackDeactivateRequest : public JackRequest

  315. {

  316. 

  317.     int fRefNum;

  318. 

  319.     JackDeactivateRequest()

  320.     {}

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

  322.     {}

  323. 

  324.     int Read(JackChannelTransaction* trans)

  325.     {

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

  327.     }

  328. 

  329.     int Write(JackChannelTransaction* trans)

  330.     {

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

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

  333.     }

  334. 

  335. };

  336. 

  337. /*!

  338. \brief PortRegister request.

  339. */

  340. 

  341. struct JackPortRegisterRequest : public JackRequest

  342. {

  343. 

  344.     int fRefNum;

  345.     char fName[JACK_PORT_NAME_SIZE + 1];

  346.     char fPortType[JACK_PORT_TYPE_SIZE + 1];

  347.     unsigned int fFlags;

  348.     unsigned int fBufferSize;

  349. 

  350.     JackPortRegisterRequest()

  351.     {}

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

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

  354.     {

  355.         strcpy(fName, name);

  356.         strcpy(fPortType, port_type);

  357.     }

  358. 

  359.     int Read(JackChannelTransaction* trans)

  360.     {

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

  362.         CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));

  363.         CheckRes(trans->Read(&fPortType, JACK_PORT_TYPE_SIZE + 1));

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

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

  366.         return 0;

  367.     }

  368. 

  369.     int Write(JackChannelTransaction* trans)

  370.     {

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

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

  373.         CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));

  374.         CheckRes(trans->Write(&fPortType, JACK_PORT_TYPE_SIZE + 1));

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

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

  377.         return 0;

  378.     }

  379. };

  380. 

  381. /*!

  382. \brief PortRegister result.

  383. */

  384. 

  385. struct JackPortRegisterResult : public JackResult

  386. {

  387. 

  388.     unsigned int fPortIndex;

  389. 

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

  391.     {}

  392. 

  393.     int Read(JackChannelTransaction* trans)

  394.     {

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

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

  397.     }

  398. 

  399.     int Write(JackChannelTransaction* trans)

  400.     {

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

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

  403.     }

  404. };

  405. 

  406. /*!

  407. \brief PortUnregister request.

  408. */

  409. 

  410. struct JackPortUnRegisterRequest : public JackRequest

  411. {

  412. 

  413.     int fRefNum;

  414.     int fPortIndex;

  415. 

  416.     JackPortUnRegisterRequest()

  417.     {}

  418.     JackPortUnRegisterRequest(int refnum, int index): JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)

  419.     {}

  420. 

  421.     int Read(JackChannelTransaction* trans)

  422.     {

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

  424.         CheckRes(trans->Read(&fPortIndex, sizeof(int)));

  425.         return 0;

  426.     }

  427. 

  428.     int Write(JackChannelTransaction* trans)

  429.     {

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

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

  432.         CheckRes(trans->Write(&fPortIndex, sizeof(int)));

  433.         return 0;

  434.     }

  435. };

  436. 

  437. /*!

  438. \brief PortConnectName request.

  439. */

  440. 

  441. struct JackPortConnectNameRequest : public JackRequest

  442. {

  443. 

  444.     int fRefNum;

  445.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  446.     char fDst[JACK_PORT_NAME_SIZE + 1];

  447. 

  448.     JackPortConnectNameRequest()

  449.     {}

  450.     JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)

  451.     {

  452.         strcpy(fSrc, src_name);

  453.         strcpy(fDst, dst_name);

  454.     }

  455. 

  456.     int Read(JackChannelTransaction* trans)

  457.     {

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

  459.         CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));

  460.         CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));

  461.         return 0;

  462. 

  463.     }

  464. 

  465.     int Write(JackChannelTransaction* trans)

  466.     {

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

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

  469.         CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));

  470.         CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));

  471.         return 0;

  472.     }

  473. };

  474. 

  475. /*!

  476. \brief PortDisconnectName request.

  477. */

  478. 

  479. struct JackPortDisconnectNameRequest : public JackRequest

  480. {

  481. 

  482.     int fRefNum;

  483.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  484.     char fDst[JACK_PORT_NAME_SIZE + 1];

  485. 

  486.     JackPortDisconnectNameRequest()

  487.     {}

  488.     JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)

  489.     {

  490.         strcpy(fSrc, src_name);

  491.         strcpy(fDst, dst_name);

  492.     }

  493. 

  494.     int Read(JackChannelTransaction* trans)

  495.     {

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

  497.         CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));

  498.         CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));

  499.         return 0;

  500.     }

  501. 

  502.     int Write(JackChannelTransaction* trans)

  503.     {

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

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

  506.         CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));

  507.         CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));

  508.         return 0;

  509.     }

  510. };

  511. 

  512. /*!

  513. \brief PortConnect request.

  514. */

  515. 

  516. struct JackPortConnectRequest : public JackRequest

  517. {

  518. 

  519.     int fRefNum;

  520.     jack_port_id_t fSrc;

  521.     jack_port_id_t fDst;

  522. 

  523.     JackPortConnectRequest()

  524.     {}

  525.     JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)

  526.     {}

  527. 

  528.     int Read(JackChannelTransaction* trans)

  529.     {

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

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

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

  533.         return 0;

  534.     }

  535. 

  536.     int Write(JackChannelTransaction* trans)

  537.     {

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

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

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

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

  542.         return 0;

  543.     }

  544. };

  545. 

  546. 

  547. /*!

  548. \brief PortDisconnect request.

  549. */

  550. 

  551. struct JackPortDisconnectRequest : public JackRequest

  552. {

  553. 

  554.     int fRefNum;

  555.     jack_port_id_t fSrc;

  556.     jack_port_id_t fDst;

  557. 

  558.     JackPortDisconnectRequest()

  559.     {}

  560.     JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)

  561.     {}

  562. 

  563.     int Read(JackChannelTransaction* trans)

  564.     {

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

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

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

  568.         return 0;

  569.     }

  570. 

  571.     int Write(JackChannelTransaction* trans)

  572.     {

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

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

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

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

  577.         return 0;

  578. 

  579.     }

  580. };

  581. 

  582. /*!

  583. \brief SetBufferSize request.

  584. */

  585. 

  586. struct JackSetBufferSizeRequest : public JackRequest

  587. {

  588. 

  589.     jack_nframes_t fBufferSize;

  590. 

  591.     JackSetBufferSizeRequest()

  592.     {}

  593.     JackSetBufferSizeRequest(jack_nframes_t buffer_size): JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)

  594.     {}

  595. 

  596.     int Read(JackChannelTransaction* trans)

  597.     {

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

  599.     }

  600. 

  601.     int Write(JackChannelTransaction* trans)

  602.     {

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

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

  605.     }

  606. };

  607. 

  608. /*!

  609. \brief SetFreeWheel request.

  610. */

  611. 

  612. struct JackSetFreeWheelRequest : public JackRequest

  613. {

  614. 

  615.     int fOnOff;

  616. 

  617.     JackSetFreeWheelRequest()

  618.     {}

  619.     JackSetFreeWheelRequest(int onoff): JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)

  620.     {}

  621. 

  622.     int Read(JackChannelTransaction* trans)

  623.     {

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

  625.     }

  626. 

  627.     int Write(JackChannelTransaction* trans)

  628.     {

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

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

  631.     }

  632. };

  633. 

  634. /*!

  635. \brief ReleaseTimebase request.

  636. */

  637. 

  638. struct JackReleaseTimebaseRequest : public JackRequest

  639. {

  640. 

  641.     int fRefNum;

  642. 

  643.     JackReleaseTimebaseRequest()

  644.     {}

  645.     JackReleaseTimebaseRequest(int refnum): JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)

  646.     {}

  647. 

  648.     int Read(JackChannelTransaction* trans)

  649.     {

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

  651.     }

  652. 

  653.     int Write(JackChannelTransaction* trans)

  654.     {

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

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

  657.     }

  658. };

  659. 

  660. /*!

  661. \brief SetTimebaseCallback request.

  662. */

  663. 

  664. struct JackSetTimebaseCallbackRequest : public JackRequest

  665. {

  666. 

  667.     int fRefNum;

  668.     int fConditionnal;

  669. 

  670.     JackSetTimebaseCallbackRequest()

  671.     {}

  672.     JackSetTimebaseCallbackRequest(int refnum, int conditional): JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)

  673.     {}

  674. 

  675.     int Read(JackChannelTransaction* trans)

  676.     {

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

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

  679.     }

  680. 

  681.     int Write(JackChannelTransaction* trans)

  682.     {

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

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

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

  686.     }

  687. };

  688. 

  689. /*!

  690. \brief GetInternalClientName request.

  691. */

  692. 

  693. struct JackGetInternalClientNameRequest : public JackRequest

  694. {

  695. 

  696.     int fRefNum;

  697.     int fIntRefNum;

  698. 

  699.     JackGetInternalClientNameRequest()

  700.     {}

  701.     JackGetInternalClientNameRequest(int refnum, int int_ref)

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

  703.     {}

  704. 

  705.     int Read(JackChannelTransaction* trans)

  706.     {

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

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

  709.     }

  710. 

  711.     int Write(JackChannelTransaction* trans)

  712.     {

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

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

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

  716.     }

  717. };

  718. 

  719. /*!

  720. \brief GetInternalClient result.

  721. */

  722. 

  723. struct JackGetInternalClientNameResult : public JackResult

  724. {

  725. 

  726.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  727. 

  728.     JackGetInternalClientNameResult(): JackResult()

  729.     {}

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

  731.             : JackResult(result)

  732.     {

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

  734.     }

  735. 

  736.     int Read(JackChannelTransaction* trans)

  737.     {

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

  739.         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));

  740.         return 0;

  741.     }

  742. 

  743.     int Write(JackChannelTransaction* trans)

  744.     {

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

  746.         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));

  747.         return 0;

  748.     }

  749. };

  750. 

  751. /*!

  752. \brief InternalClientHandle request.

  753. */

  754. 

  755. struct JackInternalClientHandleRequest : public JackRequest

  756. {

  757. 

  758.     int fRefNum;

  759.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  760. 

  761.     JackInternalClientHandleRequest()

  762.     {}

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

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

  765.     {

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

  767.     }

  768. 

  769.     int Read(JackChannelTransaction* trans)

  770.     {

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

  772.         return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);

  773.     }

  774. 

  775.     int Write(JackChannelTransaction* trans)

  776.     {

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

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

  779.         return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);

  780.     }

  781. };

  782. 

  783. /*!

  784. \brief InternalClientHandle result.

  785. */

  786. 

  787. struct JackInternalClientHandleResult : public JackResult

  788. {

  789. 

  790.     int fStatus;

  791.     int fIntRefNum;

  792. 

  793.     JackInternalClientHandleResult(): JackResult()

  794.     {}

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

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

  797.     {}

  798. 

  799.     int Read(JackChannelTransaction* trans)

  800.     {

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

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

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

  804.         return 0;

  805.     }

  806. 

  807.     int Write(JackChannelTransaction* trans)

  808.     {

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

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

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

  812.         return 0;

  813.     }

  814. };

  815. 

  816. /*!

  817. \brief InternalClientLoad request.

  818. */

  819. 

  820. struct JackInternalClientLoadRequest : public JackRequest

  821. {

  822. 

  823. #define MAX_PATH 256

  824. 

  825.     int fRefNum;

  826.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  827.     char fDllName[MAX_PATH + 1];

  828.     char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];

  829.     int fOptions;

  830. 

  831.     JackInternalClientLoadRequest()

  832.     {}

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

  834.             : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options)

  835.     {

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

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

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

  839.     }

  840. 

  841.     int Read(JackChannelTransaction* trans)

  842.     {

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

  844.         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));

  845.         CheckRes(trans->Read(&fDllName, MAX_PATH + 1));

  846.         CheckRes(trans->Read(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));

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

  848.     }

  849. 

  850.     int Write(JackChannelTransaction* trans)

  851.     {

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

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

  854.         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));

  855.         CheckRes(trans->Write(&fDllName, MAX_PATH + 1));

  856.         CheckRes(trans->Write(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));

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

  858.     }

  859. };

  860. 

  861. /*!

  862. \brief InternalClientLoad result.

  863. */

  864. 

  865. struct JackInternalClientLoadResult : public JackResult

  866. {

  867. 

  868.     int fStatus;

  869.     int fIntRefNum;

  870. 

  871.     JackInternalClientLoadResult(): JackResult()

  872.     {}

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

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

  875.     {}

  876. 

  877.     int Read(JackChannelTransaction* trans)

  878.     {

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

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

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

  882.         return 0;

  883.     }

  884. 

  885.     int Write(JackChannelTransaction* trans)

  886.     {

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

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

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

  890.         return 0;

  891.     }

  892. };

  893. 

  894. /*!

  895. \brief InternalClientUnload request.

  896. */

  897. 

  898. struct JackInternalClientUnloadRequest : public JackRequest

  899. {

  900. 

  901.     int fRefNum;

  902.     int fIntRefNum;

  903. 

  904.     JackInternalClientUnloadRequest()

  905.     {}

  906.     JackInternalClientUnloadRequest(int refnum, int int_ref)

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

  908.     {}

  909. 

  910.     int Read(JackChannelTransaction* trans)

  911.     {

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

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

  914.     }

  915. 

  916.     int Write(JackChannelTransaction* trans)

  917.     {

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

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

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

  921.     }

  922. };

  923. 

  924. 

  925. /*!

  926. \brief InternalClientLoad result.

  927. */

  928. 

  929. struct JackInternalClientUnloadResult : public JackResult

  930. {

  931. 

  932.     int fStatus;

  933. 

  934.     JackInternalClientUnloadResult(): JackResult()

  935.     {}

  936.     JackInternalClientUnloadResult(int32_t result, int status)

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

  938.     {}

  939. 

  940.     int Read(JackChannelTransaction* trans)

  941.     {

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

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

  944.         return 0;

  945.     }

  946. 

  947.     int Write(JackChannelTransaction* trans)

  948.     {

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

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

  951.         return 0;

  952.     }

  953. };

  954. 

  955. /*!

  956. \brief ClientNotification request.

  957. */

  958. 

  959. struct JackClientNotificationRequest : public JackRequest

  960. {

  961. 

  962.     int fRefNum;

  963.     int fNotify;

  964.     int fValue;

  965. 

  966.     JackClientNotificationRequest()

  967.     {}

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

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

  970.     {}

  971. 

  972.     int Read(JackChannelTransaction* trans)

  973.     {

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

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

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

  977.         return 0;

  978.     }

  979. 

  980.     int Write(JackChannelTransaction* trans)

  981.     {

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

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

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

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

  986.         return 0;

  987.     }

  988. 

  989. };

  990. 

  991. /*!

  992. \brief ClientNotification.

  993. */

  994. 

  995. struct JackClientNotification

  996. {

  997.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  998.     int fRefNum;

  999.     int fNotify;

  1000.     int fValue1;

  1001.     int fValue2;

  1002.     int fSync;

  1003. 

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

  1005.     {}

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

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

  1008.     {

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

  1010.     }

  1011. 

  1012.     int Read(JackChannelTransaction* trans)

  1013.     {

  1014.         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));

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

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

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

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

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

  1020.         return 0;

  1021.     }

  1022. 

  1023.     int Write(JackChannelTransaction* trans)

  1024.     {

  1025.         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));

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

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

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

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

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

  1031.         return 0;

  1032.     }

  1033. 

  1034. };

  1035. 

  1036. } // end of namespace

  1037. 

  1038. #endif