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

699 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.     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.         kClientOpen = 22,

  61.         kClientClose = 23,

  62.         kConnectNamePorts = 24,

  63.         kDisconnectNamePorts = 25,

  64. 

  65.         kNotification = 26

  66.     };

  67. 

  68.     RequestType fType;

  69. 

  70.     JackRequest()

  71.     {}

  72. 

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

  74.     {}

  75. 

  76.   	virtual ~JackRequest()

  77.     {}

  78. 

  79.  	virtual int Read(JackChannelTransaction* trans)

  80.     {

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

  82.     }

  83. 

  84.  	virtual int Write(JackChannelTransaction* trans)

  85.     {

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

  87.     }

  88. 

  89. };

  90. 

  91. /*!

  92. \brief Result from the server.

  93. */

  94. 

  95. struct JackResult

  96. {

  97. 

  98.     int	fResult;

  99. 

  100.     JackResult(): fResult( -1)

  101.     {}

  102.     JackResult(int status): fResult(status)

  103.     {}

  104.     virtual ~JackResult()

  105.     {}

  106. 

  107.     virtual int Read(JackChannelTransaction* trans)

  108.     {

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

  110.     }

  111. 

  112.     virtual int Write(JackChannelTransaction* trans)

  113.     {

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

  115.     }

  116. };

  117. 

  118. /*!

  119. \brief NewClient request.

  120. */

  121. 

  122. struct JackClientOpenRequest : public JackRequest

  123. {

  124. 

  125.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  126. 

  127.     JackClientOpenRequest()

  128.     {}

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

  130.     {

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

  132.     }

  133. 

  134.     int Read(JackChannelTransaction* trans)

  135.     {

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

  137.     }

  138. 

  139.     int Write(JackChannelTransaction* trans)

  140.     {

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

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

  143.     }

  144. };

  145. 

  146. /*!

  147. \brief NewClient result.

  148. */

  149. 

  150. struct JackClientOpenResult : public JackResult

  151. {

  152. 

  153.     int fSharedEngine;

  154.     int fSharedClient;

  155.     int fSharedGraph;

  156.     uint32_t fProtocolVersion;

  157. 

  158.     JackClientOpenResult()

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

  160.     {}

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

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

  163.     {}

  164. 

  165.    int Read(JackChannelTransaction* trans)

  166.     {

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

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

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

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

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

  172. 		return 0;

  173.     }

  174. 

  175.     int Write(JackChannelTransaction* trans)

  176.     {

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

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

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

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

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

  182. 		return 0;

  183.     }

  184. };

  185. 

  186. /*!

  187. \brief CloseClient request.

  188. */

  189. 

  190. struct JackClientCloseRequest : public JackRequest

  191. {

  192. 

  193.     int fRefNum;

  194. 

  195.     JackClientCloseRequest()

  196.     {}

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

  198.     {}

  199. 

  200.     int Read(JackChannelTransaction* trans)

  201.     {

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

  203.     }

  204. 

  205.     int Write(JackChannelTransaction* trans)

  206.     {

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

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

  209.     }

  210. };

  211. 

  212. /*!

  213. \brief Activate request.

  214. */

  215. 

  216. struct JackActivateRequest : public JackRequest

  217. {

  218. 

  219.     int fRefNum;

  220. 

  221.     JackActivateRequest()

  222.     {}

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

  224.     {}

  225. 

  226.     int Read(JackChannelTransaction* trans)

  227.     {

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

  229.     }

  230. 

  231.     int Write(JackChannelTransaction* trans)

  232.     {

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

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

  235.     }

  236. 

  237. };

  238. 

  239. /*!

  240. \brief Deactivate request.

  241. */

  242. 

  243. struct JackDeactivateRequest : public JackRequest

  244. {

  245. 

  246.     int fRefNum;

  247. 

  248.     JackDeactivateRequest()

  249.     {}

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

  251.     {}

  252. 

  253.     int Read(JackChannelTransaction* trans)

  254.     {

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

  256.     }

  257. 

  258.     int Write(JackChannelTransaction* trans)

  259.     {

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

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

  262.     }

  263. 

  264. };

  265. 

  266. /*!

  267. \brief PortRegister request.

  268. */

  269. 

  270. struct JackPortRegisterRequest : public JackRequest

  271. {

  272. 

  273.     int fRefNum;

  274.     char fName[JACK_PORT_NAME_SIZE + 1];

  275.     char fPortType[JACK_PORT_TYPE_SIZE + 1];

  276.     unsigned int fFlags;

  277.     unsigned int fBufferSize;

  278. 

  279.     JackPortRegisterRequest()

  280.     {}

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

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

  283.     {

  284.         strcpy(fName, name);

  285.         strcpy(fPortType, port_type);

  286.     }

  287. 

  288.     int Read(JackChannelTransaction* trans)

  289.     {

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

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

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

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

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

  295. 		return 0;

  296.     }

  297. 

  298.     int Write(JackChannelTransaction* trans)

  299.     {

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

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

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

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

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

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

  306. 		return 0;

  307.     }

  308. };

  309. 

  310. /*!

  311. \brief PortRegister result.

  312. */

  313. 

  314. struct JackPortRegisterResult : public JackResult

  315. {

  316. 

  317.     jack_port_id_t fPortIndex;

  318. 

  319.     JackPortRegisterResult(): fPortIndex(NO_PORT)

  320.     {}

  321. 

  322.     int Read(JackChannelTransaction* trans)

  323.     {

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

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

  326.     }

  327. 

  328.     int Write(JackChannelTransaction* trans)

  329.     {

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

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

  332.     }

  333. };

  334. 

  335. /*!

  336. \brief PortUnregister request.

  337. */

  338. 

  339. struct JackPortUnRegisterRequest : public JackRequest

  340. {

  341. 

  342.     int fRefNum;

  343.     int fPortIndex;

  344. 

  345.     JackPortUnRegisterRequest()

  346.     {}

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

  348.     {}

  349. 

  350.     int Read(JackChannelTransaction* trans)

  351.     {

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

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

  354. 		return 0;

  355.     }

  356. 

  357.     int Write(JackChannelTransaction* trans)

  358.     {

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

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

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

  362. 		return 0;

  363.     }

  364. };

  365. 

  366. /*!

  367. \brief PortConnectName request.

  368. */

  369. 

  370. struct JackPortConnectNameRequest : public JackRequest

  371. {

  372. 	

  373.     int fRefNum;

  374.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  375.     char fDst[JACK_PORT_NAME_SIZE + 1];

  376. 

  377.     JackPortConnectNameRequest()

  378.     {}

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

  380.     {

  381.         strcpy(fSrc, src_name);

  382.         strcpy(fDst, dst_name);

  383.     }

  384. 

  385.     int Read(JackChannelTransaction* trans)

  386.     {

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

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

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

  390. 		return 0;

  391. 

  392.     }

  393. 

  394.     int Write(JackChannelTransaction* trans)

  395.     {

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

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

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

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

  400. 		return 0;

  401.     }

  402. };

  403. 

  404. /*!

  405. \brief PortDisconnectName request.

  406. */

  407. 

  408. struct JackPortDisconnectNameRequest : public JackRequest

  409. {

  410. 

  411.     int fRefNum;

  412.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  413.     char fDst[JACK_PORT_NAME_SIZE + 1];

  414. 

  415.     JackPortDisconnectNameRequest()

  416.     {}

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

  418.     {

  419.         strcpy(fSrc, src_name);

  420.         strcpy(fDst, dst_name);

  421.     }

  422. 

  423.     int Read(JackChannelTransaction* trans)

  424.     {

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

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

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

  428. 		return 0;

  429.     }

  430. 

  431.     int Write(JackChannelTransaction* trans)

  432.     {

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

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

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

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

  437. 		return 0;

  438.     }

  439. };

  440. 

  441. /*!

  442. \brief PortConnect request.

  443. */

  444. 

  445. struct JackPortConnectRequest : public JackRequest

  446. {

  447. 

  448.     int fRefNum;

  449.     jack_port_id_t fSrc;

  450.     jack_port_id_t fDst;

  451. 

  452.     JackPortConnectRequest()

  453.     {}

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

  455.     {}

  456. 

  457.     int Read(JackChannelTransaction* trans)

  458.     {

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

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

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

  462. 		return 0;

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

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

  471. 		return 0;

  472.     }

  473. };

  474. 

  475. 

  476. /*!

  477. \brief PortDisconnect request.

  478. */

  479. 

  480. struct JackPortDisconnectRequest : public JackRequest

  481. {

  482. 

  483.     int fRefNum;

  484.     jack_port_id_t fSrc;

  485.     jack_port_id_t fDst;

  486. 

  487.     JackPortDisconnectRequest()

  488.     {}

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

  490.     {}

  491. 

  492.     int Read(JackChannelTransaction* trans)

  493.     {

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

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

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

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

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

  506. 		return 0;

  507. 

  508.     }

  509. };

  510. 

  511. /*!

  512. \brief SetBufferSize request.

  513. */

  514. 

  515. struct JackSetBufferSizeRequest : public JackRequest

  516. {

  517. 

  518.     jack_nframes_t fBufferSize;

  519. 

  520.     JackSetBufferSizeRequest()

  521.     {}

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

  523.     {}

  524. 

  525.     int Read(JackChannelTransaction* trans)

  526.     {

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

  528.     }

  529. 

  530.     int Write(JackChannelTransaction* trans)

  531.     {

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

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

  534.     }

  535. };

  536. 

  537. /*!

  538. \brief SetFreeWheel request.

  539. */

  540. 

  541. struct JackSetFreeWheelRequest : public JackRequest

  542. {

  543. 

  544.     int fOnOff;

  545. 

  546.     JackSetFreeWheelRequest()

  547.     {}

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

  549.     {}

  550. 

  551.     int Read(JackChannelTransaction* trans)

  552.     {

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

  554.     }

  555. 

  556.     int Write(JackChannelTransaction* trans)

  557.     {

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

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

  560.     }

  561. };

  562. 

  563. /*!

  564. \brief ReleaseTimebase request.

  565. */

  566. 

  567. struct JackReleaseTimebaseRequest : public JackRequest

  568. {

  569. 

  570.     int fRefNum;

  571. 

  572.     JackReleaseTimebaseRequest()

  573.     {}

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

  575.     {}

  576. 

  577.     int Read(JackChannelTransaction* trans)

  578.     {

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

  580.     }

  581. 

  582.     int Write(JackChannelTransaction* trans)

  583.     {

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

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

  586.     }

  587. };

  588. 

  589. /*!

  590. \brief SetTimebaseCallback request.

  591. */

  592. 

  593. struct JackSetTimebaseCallbackRequest : public JackRequest

  594. {

  595. 

  596.     int fRefNum;

  597.     int fConditionnal;

  598. 

  599.     JackSetTimebaseCallbackRequest()

  600.     {}

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

  602.     {}

  603. 

  604.     int Read(JackChannelTransaction* trans)

  605.     {

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

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

  608.     }

  609. 

  610.     int Write(JackChannelTransaction* trans)

  611.     {

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

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

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

  615.     }

  616. };

  617. 

  618. /*!

  619. \brief ClientNotification request.

  620. */

  621. 

  622. struct JackClientNotificationRequest : public JackRequest

  623. {

  624. 	

  625.     int fRefNum;

  626.     int fNotify;

  627.     int fValue;

  628. 

  629.     JackClientNotificationRequest()

  630.     {}

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

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

  633.     {}

  634. 

  635.     int Read(JackChannelTransaction* trans)

  636.     {

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

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

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

  640. 		return 0;

  641.     }

  642. 

  643.     int Write(JackChannelTransaction* trans)

  644.     {

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

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

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

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

  649. 		return 0;

  650.     }

  651. 

  652. };

  653. 

  654. /*!

  655. \brief ClientNotification.

  656. */

  657. 

  658. struct JackClientNotification

  659. {

  660.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  661.     int fRefNum;

  662.     int fNotify;

  663.     int fValue;

  664.     int fSync;

  665. 

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

  667.     {}

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

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

  670.     {

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

  672.     }

  673. 

  674.     int Read(JackChannelTransaction* trans)

  675.     {

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

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

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

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

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

  681. 		return 0;

  682.     }

  683. 

  684.     int Write(JackChannelTransaction* trans)

  685.     {

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

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

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

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

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

  691. 		return 0;

  692.     }

  693. 

  694. };

  695. 

  696. } // end of namespace

  697. 

  698. #endif