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

701 lines
16KB
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. public:

  43. 

  44.     typedef enum {

  45.         kRegisterPort = 1,

  46.         kUnRegisterPort = 2,

  47.         kConnectPorts = 3,

  48.         kDisconnectPorts = 4,

  49.         kSetTimeBaseClient = 5,

  50.         kActivateClient = 6,

  51.         kDeactivateClient = 7,

  52.         kDisconnectPort = 8,

  53.         kSetClientCapabilities = 9,

  54.         kGetPortConnections = 10,

  55.         kGetPortNConnections = 11,

  56. 

  57.         kReleaseTimebase = 12,

  58.         kSetTimebaseCallback = 13,

  59. 

  60.         kSetBufferSize = 20,

  61.         kSetFreeWheel = 21,

  62.         kClientOpen = 22,

  63.         kClientClose = 23,

  64.         kConnectNamePorts = 24,

  65.         kDisconnectNamePorts = 25,

  66. 

  67.         kNotification = 26

  68.     } RequestType;

  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 status): fResult(status)

  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 NewClient request.

  122. */

  123. 

  124. struct JackClientOpenRequest : public JackRequest

  125. {

  126. 

  127.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  128. 

  129.     JackClientOpenRequest()

  130.     {}

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

  132.     {

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

  134.     }

  135. 

  136.     int Read(JackChannelTransaction* trans)

  137.     {

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

  139.     }

  140. 

  141.     int Write(JackChannelTransaction* trans)

  142.     {

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

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

  145.     }

  146. };

  147. 

  148. /*!

  149. \brief NewClient result.

  150. */

  151. 

  152. struct JackClientOpenResult : public JackResult

  153. {

  154. 

  155.     int fSharedEngine;

  156.     int fSharedClient;

  157.     int fSharedGraph;

  158.     uint32_t fProtocolVersion;

  159. 

  160.     JackClientOpenResult()

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

  162.     {}

  163.     JackClientOpenResult(int32_t status, int index1, int index2, int index3)

  164.          : JackResult(status), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3), fProtocolVersion(0)

  165.     {}

  166. 

  167.    int Read(JackChannelTransaction* trans)

  168.     {

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

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

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

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

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

  174. 		return 0;

  175.     }

  176. 

  177.     int Write(JackChannelTransaction* trans)

  178.     {

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

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

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

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

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

  184. 		return 0;

  185.     }

  186. };

  187. 

  188. /*!

  189. \brief CloseClient request.

  190. */

  191. 

  192. struct JackClientCloseRequest : public JackRequest

  193. {

  194. 

  195.     int fRefNum;

  196. 

  197.     JackClientCloseRequest()

  198.     {}

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

  200.     {}

  201. 

  202.     int Read(JackChannelTransaction* trans)

  203.     {

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

  205.     }

  206. 

  207.     int Write(JackChannelTransaction* trans)

  208.     {

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

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

  211.     }

  212. };

  213. 

  214. /*!

  215. \brief Activate request.

  216. */

  217. 

  218. struct JackActivateRequest : public JackRequest

  219. {

  220. 

  221.     int fRefNum;

  222. 

  223.     JackActivateRequest()

  224.     {}

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

  226.     {}

  227. 

  228.     int Read(JackChannelTransaction* trans)

  229.     {

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

  231.     }

  232. 

  233.     int Write(JackChannelTransaction* trans)

  234.     {

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

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

  237.     }

  238. 

  239. };

  240. 

  241. /*!

  242. \brief Deactivate request.

  243. */

  244. 

  245. struct JackDeactivateRequest : public JackRequest

  246. {

  247. 

  248.     int fRefNum;

  249. 

  250.     JackDeactivateRequest()

  251.     {}

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

  253.     {}

  254. 

  255.     int Read(JackChannelTransaction* trans)

  256.     {

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

  258.     }

  259. 

  260.     int Write(JackChannelTransaction* trans)

  261.     {

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

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

  264.     }

  265. 

  266. };

  267. 

  268. /*!

  269. \brief PortRegister request.

  270. */

  271. 

  272. struct JackPortRegisterRequest : public JackRequest

  273. {

  274. 

  275.     int fRefNum;

  276.     char fName[JACK_PORT_NAME_SIZE + 1];

  277.     char fPortType[JACK_PORT_TYPE_SIZE + 1];

  278.     unsigned int fFlags;

  279.     unsigned int fBufferSize;

  280. 

  281.     JackPortRegisterRequest()

  282.     {}

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

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

  285.     {

  286.         strcpy(fName, name);

  287.         strcpy(fPortType, port_type);

  288.     }

  289. 

  290.     int Read(JackChannelTransaction* trans)

  291.     {

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

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

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

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

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

  297. 		return 0;

  298.     }

  299. 

  300.     int Write(JackChannelTransaction* trans)

  301.     {

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

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

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

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

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

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

  308. 		return 0;

  309.     }

  310. };

  311. 

  312. /*!

  313. \brief PortRegister result.

  314. */

  315. 

  316. struct JackPortRegisterResult : public JackResult

  317. {

  318. 

  319.     jack_port_id_t fPortIndex;

  320. 

  321.     JackPortRegisterResult(): fPortIndex(NO_PORT)

  322.     {}

  323. 

  324.     int Read(JackChannelTransaction* trans)

  325.     {

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

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

  328.     }

  329. 

  330.     int Write(JackChannelTransaction* trans)

  331.     {

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

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

  334.     }

  335. };

  336. 

  337. /*!

  338. \brief PortUnregister request.

  339. */

  340. 

  341. struct JackPortUnRegisterRequest : public JackRequest

  342. {

  343. 

  344.     int fRefNum;

  345.     int fPortIndex;

  346. 

  347.     JackPortUnRegisterRequest()

  348.     {}

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

  350.     {}

  351. 

  352.     int Read(JackChannelTransaction* trans)

  353.     {

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

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

  356. 		return 0;

  357.     }

  358. 

  359.     int Write(JackChannelTransaction* trans)

  360.     {

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

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

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

  364. 		return 0;

  365.     }

  366. };

  367. 

  368. /*!

  369. \brief PortConnectName request.

  370. */

  371. 

  372. struct JackPortConnectNameRequest : public JackRequest

  373. {

  374. 	

  375.     int fRefNum;

  376.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  377.     char fDst[JACK_PORT_NAME_SIZE + 1];

  378. 

  379.     JackPortConnectNameRequest()

  380.     {}

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

  382.     {

  383.         strcpy(fSrc, src_name);

  384.         strcpy(fDst, dst_name);

  385.     }

  386. 

  387.     int Read(JackChannelTransaction* trans)

  388.     {

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

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

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

  392. 		return 0;

  393. 

  394.     }

  395. 

  396.     int Write(JackChannelTransaction* trans)

  397.     {

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

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

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

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

  402. 		return 0;

  403.     }

  404. };

  405. 

  406. /*!

  407. \brief PortDisconnectName request.

  408. */

  409. 

  410. struct JackPortDisconnectNameRequest : public JackRequest

  411. {

  412. 

  413.     int fRefNum;

  414.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  415.     char fDst[JACK_PORT_NAME_SIZE + 1];

  416. 

  417.     JackPortDisconnectNameRequest()

  418.     {}

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

  420.     {

  421.         strcpy(fSrc, src_name);

  422.         strcpy(fDst, dst_name);

  423.     }

  424. 

  425.     int Read(JackChannelTransaction* trans)

  426.     {

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

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

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

  430. 		return 0;

  431.     }

  432. 

  433.     int Write(JackChannelTransaction* trans)

  434.     {

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

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

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

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

  439. 		return 0;

  440.     }

  441. };

  442. 

  443. /*!

  444. \brief PortConnect request.

  445. */

  446. 

  447. struct JackPortConnectRequest : public JackRequest

  448. {

  449. 

  450.     int fRefNum;

  451.     jack_port_id_t fSrc;

  452.     jack_port_id_t fDst;

  453. 

  454.     JackPortConnectRequest()

  455.     {}

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

  457.     {}

  458. 

  459.     int Read(JackChannelTransaction* trans)

  460.     {

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

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

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

  464. 		return 0;

  465.     }

  466. 

  467.     int Write(JackChannelTransaction* trans)

  468.     {

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

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

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

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

  473. 		return 0;

  474.     }

  475. };

  476. 

  477. 

  478. /*!

  479. \brief PortDisconnect request.

  480. */

  481. 

  482. struct JackPortDisconnectRequest : public JackRequest

  483. {

  484. 

  485.     int fRefNum;

  486.     jack_port_id_t fSrc;

  487.     jack_port_id_t fDst;

  488. 

  489.     JackPortDisconnectRequest()

  490.     {}

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

  492.     {}

  493. 

  494.     int Read(JackChannelTransaction* trans)

  495.     {

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

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

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

  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, sizeof(jack_port_id_t)));

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

  508. 		return 0;

  509. 

  510.     }

  511. };

  512. 

  513. /*!

  514. \brief SetBufferSize request.

  515. */

  516. 

  517. struct JackSetBufferSizeRequest : public JackRequest

  518. {

  519. 

  520.     jack_nframes_t fBufferSize;

  521. 

  522.     JackSetBufferSizeRequest()

  523.     {}

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

  525.     {}

  526. 

  527.     int Read(JackChannelTransaction* trans)

  528.     {

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

  530.     }

  531. 

  532.     int Write(JackChannelTransaction* trans)

  533.     {

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

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

  536.     }

  537. };

  538. 

  539. /*!

  540. \brief SetFreeWheel request.

  541. */

  542. 

  543. struct JackSetFreeWheelRequest : public JackRequest

  544. {

  545. 

  546.     int fOnOff;

  547. 

  548.     JackSetFreeWheelRequest()

  549.     {}

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

  551.     {}

  552. 

  553.     int Read(JackChannelTransaction* trans)

  554.     {

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

  556.     }

  557. 

  558.     int Write(JackChannelTransaction* trans)

  559.     {

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

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

  562.     }

  563. };

  564. 

  565. /*!

  566. \brief ReleaseTimebase request.

  567. */

  568. 

  569. struct JackReleaseTimebaseRequest : public JackRequest

  570. {

  571. 

  572.     int fRefNum;

  573. 

  574.     JackReleaseTimebaseRequest()

  575.     {}

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

  577.     {}

  578. 

  579.     int Read(JackChannelTransaction* trans)

  580.     {

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

  582.     }

  583. 

  584.     int Write(JackChannelTransaction* trans)

  585.     {

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

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

  588.     }

  589. };

  590. 

  591. /*!

  592. \brief SetTimebaseCallback request.

  593. */

  594. 

  595. struct JackSetTimebaseCallbackRequest : public JackRequest

  596. {

  597. 

  598.     int fRefNum;

  599.     int fConditionnal;

  600. 

  601.     JackSetTimebaseCallbackRequest()

  602.     {}

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

  604.     {}

  605. 

  606.     int Read(JackChannelTransaction* trans)

  607.     {

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

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

  610.     }

  611. 

  612.     int Write(JackChannelTransaction* trans)

  613.     {

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

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

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

  617.     }

  618. };

  619. 

  620. /*!

  621. \brief ClientNotification request.

  622. */

  623. 

  624. struct JackClientNotificationRequest : public JackRequest

  625. {

  626. 	

  627.     int fRefNum;

  628.     int fNotify;

  629.     int fValue;

  630. 

  631.     JackClientNotificationRequest()

  632.     {}

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

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

  635.     {}

  636. 

  637.     int Read(JackChannelTransaction* trans)

  638.     {

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

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

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

  642. 		return 0;

  643.     }

  644. 

  645.     int Write(JackChannelTransaction* trans)

  646.     {

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

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

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

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

  651. 		return 0;

  652.     }

  653. 

  654. };

  655. 

  656. /*!

  657. \brief ClientNotification.

  658. */

  659. 

  660. struct JackClientNotification

  661. {

  662.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  663.     int fRefNum;

  664.     int fNotify;

  665.     int fValue;

  666.     int fSync;

  667. 

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

  669.     {}

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

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

  672.     {

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

  674.     }

  675. 

  676.     int Read(JackChannelTransaction* trans)

  677.     {

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

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

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

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

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

  683. 		return 0;

  684.     }

  685. 

  686.     int Write(JackChannelTransaction* trans)

  687.     {

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

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

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

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

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

  693. 		return 0;

  694.     }

  695. 

  696. };

  697. 

  698. } // end of namespace

  699. 

  700. #endif