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

768 lines
17KB
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 "JackPort.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. 

  55.         kReleaseTimebase = 12,

  56.         kSetTimebaseCallback = 13,

  57. 

  58.         kSetBufferSize = 20,

  59.         kSetFreeWheel = 21,

  60. 		kClientCheck = 22,

  61.         kClientOpen = 23,

  62.         kClientClose = 24,

  63.         kConnectNamePorts = 25,

  64.         kDisconnectNamePorts = 26,

  65. 

  66.         kNotification = 27

  67.     };

  68. 

  69.     RequestType fType;

  70. 

  71.     JackRequest()

  72.     {}

  73. 

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

  75.     {}

  76. 

  77.   	virtual ~JackRequest()

  78.     {}

  79. 

  80.  	virtual int Read(JackChannelTransaction* trans)

  81.     {

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

  83.     }

  84. 

  85.  	virtual int Write(JackChannelTransaction* trans)

  86.     {

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

  88.     }

  89. 

  90. };

  91. 

  92. /*!

  93. \brief Result from the server.

  94. */

  95. 

  96. struct JackResult

  97. {

  98. 

  99.     int	fResult;

  100. 

  101.     JackResult(): fResult( -1)

  102.     {}

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

  104.     {}

  105.     virtual ~JackResult()

  106.     {}

  107. 

  108.     virtual int Read(JackChannelTransaction* trans)

  109.     {

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

  111.     }

  112. 

  113.     virtual int Write(JackChannelTransaction* trans)

  114.     {

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

  116.     }

  117. };

  118. 

  119. /*!

  120. \brief CheckClient request.

  121. */

  122. 

  123. struct JackClientCheckRequest : public JackRequest

  124. {

  125. 

  126.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  127. 	int fOptions;

  128. 

  129.     JackClientCheckRequest()

  130.     {}

  131.     JackClientCheckRequest(const char* name, int options): JackRequest(JackRequest::kClientCheck),fOptions(options)

  132.     {

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

  134.     }

  135. 

  136.     int Read(JackChannelTransaction* trans)

  137.     {

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

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

  140.     }

  141. 

  142.     int Write(JackChannelTransaction* trans)

  143.     {

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

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

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

  147.     }

  148. };

  149. 

  150. 

  151. /*!

  152. \brief CheckClient result.

  153. */

  154. 

  155. struct JackClientCheckResult : public JackResult

  156. {

  157. 

  158. 	char fName[JACK_CLIENT_NAME_SIZE + 1];

  159. 	int fStatus;

  160. 

  161.     JackClientCheckResult():fStatus(0)

  162.     {}

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

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

  165.     {

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

  167. 	}

  168. 

  169. 	int Read(JackChannelTransaction* trans)

  170.     {

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

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

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

  174. 		return 0;

  175.     }

  176. 

  177.     int Write(JackChannelTransaction* trans)

  178.     {

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

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

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

  182. 		return 0;

  183.     }

  184. };

  185. 

  186. 

  187. /*!

  188. \brief NewClient request.

  189. */

  190. 

  191. struct JackClientOpenRequest : public JackRequest

  192. {

  193. 

  194.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  195. 

  196.     JackClientOpenRequest()

  197.     {}

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

  199.     {

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

  201.     }

  202. 

  203.     int Read(JackChannelTransaction* trans)

  204.     {

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

  206.     }

  207. 

  208.     int Write(JackChannelTransaction* trans)

  209.     {

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

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

  212.     }

  213. };

  214. 

  215. /*!

  216. \brief NewClient result.

  217. */

  218. 

  219. struct JackClientOpenResult : public JackResult

  220. {

  221. 

  222.     int fSharedEngine;

  223.     int fSharedClient;

  224.     int fSharedGraph;

  225.     uint32_t fProtocolVersion;

  226. 

  227.     JackClientOpenResult()

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

  229.     {}

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

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

  232.     {}

  233. 

  234.    int Read(JackChannelTransaction* trans)

  235.     {

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

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

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

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

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

  241. 		return 0;

  242.     }

  243. 

  244.     int Write(JackChannelTransaction* trans)

  245.     {

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

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

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

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

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

  251. 		return 0;

  252.     }

  253. };

  254. 

  255. /*!

  256. \brief CloseClient request.

  257. */

  258. 

  259. struct JackClientCloseRequest : public JackRequest

  260. {

  261. 

  262.     int fRefNum;

  263. 

  264.     JackClientCloseRequest()

  265.     {}

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

  267.     {}

  268. 

  269.     int Read(JackChannelTransaction* trans)

  270.     {

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

  272.     }

  273. 

  274.     int Write(JackChannelTransaction* trans)

  275.     {

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

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

  278.     }

  279. };

  280. 

  281. /*!

  282. \brief Activate request.

  283. */

  284. 

  285. struct JackActivateRequest : public JackRequest

  286. {

  287. 

  288.     int fRefNum;

  289. 

  290.     JackActivateRequest()

  291.     {}

  292.     JackActivateRequest(int refnum): JackRequest(JackRequest::kActivateClient), fRefNum(refnum)

  293.     {}

  294. 

  295.     int Read(JackChannelTransaction* trans)

  296.     {

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

  298.     }

  299. 

  300.     int Write(JackChannelTransaction* trans)

  301.     {

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

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

  304.     }

  305. 

  306. };

  307. 

  308. /*!

  309. \brief Deactivate request.

  310. */

  311. 

  312. struct JackDeactivateRequest : public JackRequest

  313. {

  314. 

  315.     int fRefNum;

  316. 

  317.     JackDeactivateRequest()

  318.     {}

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

  320.     {}

  321. 

  322.     int Read(JackChannelTransaction* trans)

  323.     {

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

  325.     }

  326. 

  327.     int Write(JackChannelTransaction* trans)

  328.     {

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

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

  331.     }

  332. 

  333. };

  334. 

  335. /*!

  336. \brief PortRegister request.

  337. */

  338. 

  339. struct JackPortRegisterRequest : public JackRequest

  340. {

  341. 

  342.     int fRefNum;

  343.     char fName[JACK_PORT_NAME_SIZE + 1];

  344.     char fPortType[JACK_PORT_TYPE_SIZE + 1];

  345.     unsigned int fFlags;

  346.     unsigned int fBufferSize;

  347. 

  348.     JackPortRegisterRequest()

  349.     {}

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

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

  352.     {

  353.         strcpy(fName, name);

  354.         strcpy(fPortType, port_type);

  355.     }

  356. 

  357.     int Read(JackChannelTransaction* trans)

  358.     {

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

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

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

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

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

  364. 		return 0;

  365.     }

  366. 

  367.     int Write(JackChannelTransaction* trans)

  368.     {

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

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

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

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

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

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

  375. 		return 0;

  376.     }

  377. };

  378. 

  379. /*!

  380. \brief PortRegister result.

  381. */

  382. 

  383. struct JackPortRegisterResult : public JackResult

  384. {

  385. 

  386.     jack_port_id_t fPortIndex;

  387. 

  388.     JackPortRegisterResult(): fPortIndex(NO_PORT)

  389.     {}

  390. 

  391.     int Read(JackChannelTransaction* trans)

  392.     {

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

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

  395.     }

  396. 

  397.     int Write(JackChannelTransaction* trans)

  398.     {

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

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

  401.     }

  402. };

  403. 

  404. /*!

  405. \brief PortUnregister request.

  406. */

  407. 

  408. struct JackPortUnRegisterRequest : public JackRequest

  409. {

  410. 

  411.     int fRefNum;

  412.     int fPortIndex;

  413. 

  414.     JackPortUnRegisterRequest()

  415.     {}

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

  417.     {}

  418. 

  419.     int Read(JackChannelTransaction* trans)

  420.     {

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

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

  423. 		return 0;

  424.     }

  425. 

  426.     int Write(JackChannelTransaction* trans)

  427.     {

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

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

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

  431. 		return 0;

  432.     }

  433. };

  434. 

  435. /*!

  436. \brief PortConnectName request.

  437. */

  438. 

  439. struct JackPortConnectNameRequest : public JackRequest

  440. {

  441. 	

  442.     int fRefNum;

  443.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  444.     char fDst[JACK_PORT_NAME_SIZE + 1];

  445. 

  446.     JackPortConnectNameRequest()

  447.     {}

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

  449.     {

  450.         strcpy(fSrc, src_name);

  451.         strcpy(fDst, dst_name);

  452.     }

  453. 

  454.     int Read(JackChannelTransaction* trans)

  455.     {

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

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

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

  459. 		return 0;

  460. 

  461.     }

  462. 

  463.     int Write(JackChannelTransaction* trans)

  464.     {

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

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

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

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

  469. 		return 0;

  470.     }

  471. };

  472. 

  473. /*!

  474. \brief PortDisconnectName request.

  475. */

  476. 

  477. struct JackPortDisconnectNameRequest : public JackRequest

  478. {

  479. 

  480.     int fRefNum;

  481.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  482.     char fDst[JACK_PORT_NAME_SIZE + 1];

  483. 

  484.     JackPortDisconnectNameRequest()

  485.     {}

  486.     JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(JackRequest::kDisconnectNamePorts), 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, JACK_PORT_NAME_SIZE + 1));

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

  497. 		return 0;

  498.     }

  499. 

  500.     int Write(JackChannelTransaction* trans)

  501.     {

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

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

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

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

  506. 		return 0;

  507.     }

  508. };

  509. 

  510. /*!

  511. \brief PortConnect request.

  512. */

  513. 

  514. struct JackPortConnectRequest : public JackRequest

  515. {

  516. 

  517.     int fRefNum;

  518.     jack_port_id_t fSrc;

  519.     jack_port_id_t fDst;

  520. 

  521.     JackPortConnectRequest()

  522.     {}

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

  524.     {}

  525. 

  526.     int Read(JackChannelTransaction* trans)

  527.     {

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

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

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

  531. 		return 0;

  532.     }

  533. 

  534.     int Write(JackChannelTransaction* trans)

  535.     {

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

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

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

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

  540. 		return 0;

  541.     }

  542. };

  543. 

  544. 

  545. /*!

  546. \brief PortDisconnect request.

  547. */

  548. 

  549. struct JackPortDisconnectRequest : public JackRequest

  550. {

  551. 

  552.     int fRefNum;

  553.     jack_port_id_t fSrc;

  554.     jack_port_id_t fDst;

  555. 

  556.     JackPortDisconnectRequest()

  557.     {}

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

  559.     {}

  560. 

  561.     int Read(JackChannelTransaction* trans)

  562.     {

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

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

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

  566. 		return 0;

  567.     }

  568. 

  569.     int Write(JackChannelTransaction* trans)

  570.     {

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

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

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

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

  575. 		return 0;

  576. 

  577.     }

  578. };

  579. 

  580. /*!

  581. \brief SetBufferSize request.

  582. */

  583. 

  584. struct JackSetBufferSizeRequest : public JackRequest

  585. {

  586. 

  587.     jack_nframes_t fBufferSize;

  588. 

  589.     JackSetBufferSizeRequest()

  590.     {}

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

  592.     {}

  593. 

  594.     int Read(JackChannelTransaction* trans)

  595.     {

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

  597.     }

  598. 

  599.     int Write(JackChannelTransaction* trans)

  600.     {

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

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

  603.     }

  604. };

  605. 

  606. /*!

  607. \brief SetFreeWheel request.

  608. */

  609. 

  610. struct JackSetFreeWheelRequest : public JackRequest

  611. {

  612. 

  613.     int fOnOff;

  614. 

  615.     JackSetFreeWheelRequest()

  616.     {}

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

  618.     {}

  619. 

  620.     int Read(JackChannelTransaction* trans)

  621.     {

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

  623.     }

  624. 

  625.     int Write(JackChannelTransaction* trans)

  626.     {

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

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

  629.     }

  630. };

  631. 

  632. /*!

  633. \brief ReleaseTimebase request.

  634. */

  635. 

  636. struct JackReleaseTimebaseRequest : public JackRequest

  637. {

  638. 

  639.     int fRefNum;

  640. 

  641.     JackReleaseTimebaseRequest()

  642.     {}

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

  644.     {}

  645. 

  646.     int Read(JackChannelTransaction* trans)

  647.     {

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

  649.     }

  650. 

  651.     int Write(JackChannelTransaction* trans)

  652.     {

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

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

  655.     }

  656. };

  657. 

  658. /*!

  659. \brief SetTimebaseCallback request.

  660. */

  661. 

  662. struct JackSetTimebaseCallbackRequest : public JackRequest

  663. {

  664. 

  665.     int fRefNum;

  666.     int fConditionnal;

  667. 

  668.     JackSetTimebaseCallbackRequest()

  669.     {}

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

  671.     {}

  672. 

  673.     int Read(JackChannelTransaction* trans)

  674.     {

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

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

  677.     }

  678. 

  679.     int Write(JackChannelTransaction* trans)

  680.     {

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

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

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

  684.     }

  685. };

  686. 

  687. /*!

  688. \brief ClientNotification request.

  689. */

  690. 

  691. struct JackClientNotificationRequest : public JackRequest

  692. {

  693. 	

  694.     int fRefNum;

  695.     int fNotify;

  696.     int fValue;

  697. 

  698.     JackClientNotificationRequest()

  699.     {}

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

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

  702.     {}

  703. 

  704.     int Read(JackChannelTransaction* trans)

  705.     {

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

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

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

  709. 		return 0;

  710.     }

  711. 

  712.     int Write(JackChannelTransaction* trans)

  713.     {

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

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

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

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

  718. 		return 0;

  719.     }

  720. 

  721. };

  722. 

  723. /*!

  724. \brief ClientNotification.

  725. */

  726. 

  727. struct JackClientNotification

  728. {

  729.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  730.     int fRefNum;

  731.     int fNotify;

  732.     int fValue;

  733.     int fSync;

  734. 

  735.     JackClientNotification(): fNotify( -1), fValue( -1)

  736.     {}

  737.     JackClientNotification(const char* name, int refnum, int notify, int sync, int value)

  738.             : fRefNum(refnum), fNotify(notify), fValue(value), fSync(sync)

  739.     {

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

  741.     }

  742. 

  743.     int Read(JackChannelTransaction* trans)

  744.     {

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

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

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

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

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

  750. 		return 0;

  751.     }

  752. 

  753.     int Write(JackChannelTransaction* trans)

  754.     {

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

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

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

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

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

  760. 		return 0;

  761.     }

  762. 

  763. };

  764. 

  765. } // end of namespace

  766. 

  767. #endif