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

702 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. /*!

  34. \brief Request from client to server.

  35. */

  36. 

  37. struct JackRequest

  38. {

  39. 

  40. public:

  41. 

  42.     typedef enum {

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

  61.         kClientClose = 23,

  62.         kConnectNamePorts = 24,

  63.         kDisconnectNamePorts = 25,

  64. 

  65.         kNotification = 26

  66.     } RequestType;

  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. #define CheckRes(res) {if (res < 0) return res;}

  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 JackClientNewRequest : public JackRequest

  125. {

  126. 

  127.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  128. 

  129.     JackClientNewRequest()

  130.     {}

  131.     JackClientNewRequest(const char* name): JackRequest(JackRequest::kClientNew)

  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 JackClientNewResult : public JackResult

  153. {

  154. 

  155.     int fSharedEngine;

  156.     int fSharedClient;

  157.     int fSharedGraph;

  158.     uint32_t fProtocolVersion;

  159. 

  160.     JackClientNewResult()

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

  162.     {}

  163.     JackClientNewResult(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. 		JackLog("JackClientNewResult::Write  result = %ld\n", fResult);

  185. 		return 0;

  186.     }

  187. };

  188. 

  189. /*!

  190. \brief CloseClient request.

  191. */

  192. 

  193. struct JackClientCloseRequest : public JackRequest

  194. {

  195. 

  196.     int fRefNum;

  197. 

  198.     JackClientCloseRequest()

  199.     {}

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

  201.     {}

  202. 

  203.     int Read(JackChannelTransaction* trans)

  204.     {

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

  206.     }

  207. 

  208.     int Write(JackChannelTransaction* trans)

  209.     {

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

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

  212.     }

  213. };

  214. 

  215. /*!

  216. \brief Activate request.

  217. */

  218. 

  219. struct JackActivateRequest : public JackRequest

  220. {

  221. 

  222.     int fRefNum;

  223. 

  224.     JackActivateRequest()

  225.     {}

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

  227.     {}

  228. 

  229.     int Read(JackChannelTransaction* trans)

  230.     {

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

  232.     }

  233. 

  234.     int Write(JackChannelTransaction* trans)

  235.     {

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

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

  238.     }

  239. 

  240. };

  241. 

  242. /*!

  243. \brief Deactivate request.

  244. */

  245. 

  246. struct JackDeactivateRequest : public JackRequest

  247. {

  248. 

  249.     int fRefNum;

  250. 

  251.     JackDeactivateRequest()

  252.     {}

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

  254.     {}

  255. 

  256.     int Read(JackChannelTransaction* trans)

  257.     {

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

  259.     }

  260. 

  261.     int Write(JackChannelTransaction* trans)

  262.     {

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

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

  265.     }

  266. 

  267. };

  268. 

  269. /*!

  270. \brief PortRegister request.

  271. */

  272. 

  273. struct JackPortRegisterRequest : public JackRequest

  274. {

  275. 

  276.     int fRefNum;

  277.     char fName[JACK_PORT_NAME_SIZE + 1];

  278.     char fPortType[JACK_PORT_TYPE_SIZE + 1];

  279.     unsigned int fFlags;

  280.     unsigned int fBufferSize;

  281. 

  282.     JackPortRegisterRequest()

  283.     {}

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

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

  286.     {

  287.         strcpy(fName, name);

  288.         strcpy(fPortType, port_type);

  289.     }

  290. 

  291.     int Read(JackChannelTransaction* trans)

  292.     {

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

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

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

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

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

  298. 		return 0;

  299.     }

  300. 

  301.     int Write(JackChannelTransaction* trans)

  302.     {

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

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

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

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

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

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

  309. 		return 0;

  310.     }

  311. };

  312. 

  313. /*!

  314. \brief PortRegister result.

  315. */

  316. 

  317. struct JackPortRegisterResult : public JackResult

  318. {

  319. 

  320.     jack_port_id_t fPortIndex;

  321. 

  322.     JackPortRegisterResult(): fPortIndex(NO_PORT)

  323.     {}

  324. 

  325.     int Read(JackChannelTransaction* trans)

  326.     {

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

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

  329.     }

  330. 

  331.     int Write(JackChannelTransaction* trans)

  332.     {

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

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

  335.     }

  336. };

  337. 

  338. /*!

  339. \brief PortUnregister request.

  340. */

  341. 

  342. struct JackPortUnRegisterRequest : public JackRequest

  343. {

  344. 

  345.     int fRefNum;

  346.     int fPortIndex;

  347. 

  348.     JackPortUnRegisterRequest()

  349.     {}

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

  351.     {}

  352. 

  353.     int Read(JackChannelTransaction* trans)

  354.     {

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

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

  357. 		return 0;

  358.     }

  359. 

  360.     int Write(JackChannelTransaction* trans)

  361.     {

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

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

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

  365. 		return 0;

  366.     }

  367. };

  368. 

  369. /*!

  370. \brief PortConnectName request.

  371. */

  372. 

  373. struct JackPortConnectNameRequest : public JackRequest

  374. {

  375. 	

  376.     int fRefNum;

  377.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  378.     char fDst[JACK_PORT_NAME_SIZE + 1];

  379. 

  380.     JackPortConnectNameRequest()

  381.     {}

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

  383.     {

  384.         strcpy(fSrc, src_name);

  385.         strcpy(fDst, dst_name);

  386.     }

  387. 

  388.     int Read(JackChannelTransaction* trans)

  389.     {

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

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

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

  393. 		return 0;

  394. 

  395.     }

  396. 

  397.     int Write(JackChannelTransaction* trans)

  398.     {

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

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

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

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

  403. 		return 0;

  404.     }

  405. };

  406. 

  407. /*!

  408. \brief PortDisconnectName request.

  409. */

  410. 

  411. struct JackPortDisconnectNameRequest : public JackRequest

  412. {

  413. 

  414.     int fRefNum;

  415.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  416.     char fDst[JACK_PORT_NAME_SIZE + 1];

  417. 

  418.     JackPortDisconnectNameRequest()

  419.     {}

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

  421.     {

  422.         strcpy(fSrc, src_name);

  423.         strcpy(fDst, dst_name);

  424.     }

  425. 

  426.     int Read(JackChannelTransaction* trans)

  427.     {

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

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

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

  431. 		return 0;

  432.     }

  433. 

  434.     int Write(JackChannelTransaction* trans)

  435.     {

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

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

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

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

  440. 		return 0;

  441.     }

  442. };

  443. 

  444. /*!

  445. \brief PortConnect request.

  446. */

  447. 

  448. struct JackPortConnectRequest : public JackRequest

  449. {

  450. 

  451.     int fRefNum;

  452.     jack_port_id_t fSrc;

  453.     jack_port_id_t fDst;

  454. 

  455.     JackPortConnectRequest()

  456.     {}

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

  458.     {}

  459. 

  460.     int Read(JackChannelTransaction* trans)

  461.     {

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

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

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

  465. 		return 0;

  466.     }

  467. 

  468.     int Write(JackChannelTransaction* trans)

  469.     {

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

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

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

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

  474. 		return 0;

  475.     }

  476. };

  477. 

  478. 

  479. /*!

  480. \brief PortDisconnect request.

  481. */

  482. 

  483. struct JackPortDisconnectRequest : public JackRequest

  484. {

  485. 

  486.     int fRefNum;

  487.     jack_port_id_t fSrc;

  488.     jack_port_id_t fDst;

  489. 

  490.     JackPortDisconnectRequest()

  491.     {}

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

  493.     {}

  494. 

  495.     int Read(JackChannelTransaction* trans)

  496.     {

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

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

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

  500. 		return 0;

  501.     }

  502. 

  503.     int Write(JackChannelTransaction* trans)

  504.     {

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

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

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

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

  509. 		return 0;

  510. 

  511.     }

  512. };

  513. 

  514. /*!

  515. \brief SetBufferSize request.

  516. */

  517. 

  518. struct JackSetBufferSizeRequest : public JackRequest

  519. {

  520. 

  521.     jack_nframes_t fBufferSize;

  522. 

  523.     JackSetBufferSizeRequest()

  524.     {}

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

  526.     {}

  527. 

  528.     int Read(JackChannelTransaction* trans)

  529.     {

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

  531.     }

  532. 

  533.     int Write(JackChannelTransaction* trans)

  534.     {

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

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

  537.     }

  538. };

  539. 

  540. /*!

  541. \brief SetFreeWheel request.

  542. */

  543. 

  544. struct JackSetFreeWheelRequest : public JackRequest

  545. {

  546. 

  547.     int fOnOff;

  548. 

  549.     JackSetFreeWheelRequest()

  550.     {}

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

  552.     {}

  553. 

  554.     int Read(JackChannelTransaction* trans)

  555.     {

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

  557.     }

  558. 

  559.     int Write(JackChannelTransaction* trans)

  560.     {

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

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

  563.     }

  564. };

  565. 

  566. /*!

  567. \brief ReleaseTimebase request.

  568. */

  569. 

  570. struct JackReleaseTimebaseRequest : public JackRequest

  571. {

  572. 

  573.     int fRefNum;

  574. 

  575.     JackReleaseTimebaseRequest()

  576.     {}

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

  578.     {}

  579. 

  580.     int Read(JackChannelTransaction* trans)

  581.     {

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

  583.     }

  584. 

  585.     int Write(JackChannelTransaction* trans)

  586.     {

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

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

  589.     }

  590. };

  591. 

  592. /*!

  593. \brief SetTimebaseCallback request.

  594. */

  595. 

  596. struct JackSetTimebaseCallbackRequest : public JackRequest

  597. {

  598. 

  599.     int fRefNum;

  600.     int fConditionnal;

  601. 

  602.     JackSetTimebaseCallbackRequest()

  603.     {}

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

  605.     {}

  606. 

  607.     int Read(JackChannelTransaction* trans)

  608.     {

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

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

  611.     }

  612. 

  613.     int Write(JackChannelTransaction* trans)

  614.     {

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

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

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

  618.     }

  619. };

  620. 

  621. /*!

  622. \brief ClientNotification request.

  623. */

  624. 

  625. struct JackClientNotificationRequest : public JackRequest

  626. {

  627. 	

  628.     int fRefNum;

  629.     int fNotify;

  630.     int fValue;

  631. 

  632.     JackClientNotificationRequest()

  633.     {}

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

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

  636.     {}

  637. 

  638.     int Read(JackChannelTransaction* trans)

  639.     {

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

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

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

  643. 		return 0;

  644.     }

  645. 

  646.     int Write(JackChannelTransaction* trans)

  647.     {

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

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

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

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

  652. 		return 0;

  653.     }

  654. 

  655. };

  656. 

  657. /*!

  658. \brief ClientNotification.

  659. */

  660. 

  661. struct JackClientNotification

  662. {

  663.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  664.     int fRefNum;

  665.     int fNotify;

  666.     int fValue;

  667.     int fSync;

  668. 

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

  670.     {}

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

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

  673.     {

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

  675.     }

  676. 

  677.     int Read(JackChannelTransaction* trans)

  678.     {

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

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

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

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

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

  684. 		return 0;

  685.     }

  686. 

  687.     int Write(JackChannelTransaction* trans)

  688.     {

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

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

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

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

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

  694. 		return 0;

  695.     }

  696. 

  697. };

  698. 

  699. } // end of namespace

  700. 

  701. #endif