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

769 lines
18KB
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 fProtocol;

  128.     int fOptions;

  129. 

  130.     JackClientCheckRequest()

  131.     {}

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

  133.     {

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

  135.     }

  136. 

  137.     int Read(JackChannelTransaction* trans)

  138.     {

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

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

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

  142.     }

  143. 

  144.     int Write(JackChannelTransaction* trans)

  145.     {

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

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

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

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

  150.     }

  151. };

  152. 

  153. /*!

  154. \brief CheckClient result.

  155. */

  156. 

  157. struct JackClientCheckResult : public JackResult

  158. {

  159. 

  160. 	char fName[JACK_CLIENT_NAME_SIZE + 1];

  161. 	int fStatus;

  162. 

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

  164.     {}

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

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

  167.     {

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

  169. 	}

  170. 

  171. 	int Read(JackChannelTransaction* trans)

  172.     {

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

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

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

  176. 		return 0;

  177.     }

  178. 

  179.     int Write(JackChannelTransaction* trans)

  180.     {

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

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

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

  184. 		return 0;

  185.     }

  186. };

  187. 

  188. /*!

  189. \brief NewClient request.

  190. */

  191. 

  192. struct JackClientOpenRequest : public JackRequest

  193. {

  194. 

  195.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  196. 

  197.     JackClientOpenRequest()

  198.     {}

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

  200.     {

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

  202.     }

  203. 

  204.     int Read(JackChannelTransaction* trans)

  205.     {

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

  207.     }

  208. 

  209.     int Write(JackChannelTransaction* trans)

  210.     {

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

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

  213.     }

  214. };

  215. 

  216. /*!

  217. \brief NewClient result.

  218. */

  219. 

  220. struct JackClientOpenResult : public JackResult

  221. {

  222. 

  223.     int fSharedEngine;

  224.     int fSharedClient;

  225.     int fSharedGraph;

  226.     uint32_t fProtocolVersion;

  227. 

  228.     JackClientOpenResult()

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

  230.     {}

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

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

  233.     {}

  234. 

  235.    int Read(JackChannelTransaction* trans)

  236.     {

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

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

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

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

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

  242. 		return 0;

  243.     }

  244. 

  245.     int Write(JackChannelTransaction* trans)

  246.     {

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

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

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

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

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

  252. 		return 0;

  253.     }

  254. };

  255. 

  256. /*!

  257. \brief CloseClient request.

  258. */

  259. 

  260. struct JackClientCloseRequest : public JackRequest

  261. {

  262. 

  263.     int fRefNum;

  264. 

  265.     JackClientCloseRequest()

  266.     {}

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

  268.     {}

  269. 

  270.     int Read(JackChannelTransaction* trans)

  271.     {

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

  273.     }

  274. 

  275.     int Write(JackChannelTransaction* trans)

  276.     {

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

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

  279.     }

  280. };

  281. 

  282. /*!

  283. \brief Activate request.

  284. */

  285. 

  286. struct JackActivateRequest : public JackRequest

  287. {

  288. 

  289.     int fRefNum;

  290. 

  291.     JackActivateRequest()

  292.     {}

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

  294.     {}

  295. 

  296.     int Read(JackChannelTransaction* trans)

  297.     {

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

  299.     }

  300. 

  301.     int Write(JackChannelTransaction* trans)

  302.     {

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

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

  305.     }

  306. 

  307. };

  308. 

  309. /*!

  310. \brief Deactivate request.

  311. */

  312. 

  313. struct JackDeactivateRequest : public JackRequest

  314. {

  315. 

  316.     int fRefNum;

  317. 

  318.     JackDeactivateRequest()

  319.     {}

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

  321.     {}

  322. 

  323.     int Read(JackChannelTransaction* trans)

  324.     {

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

  326.     }

  327. 

  328.     int Write(JackChannelTransaction* trans)

  329.     {

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

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

  332.     }

  333. 

  334. };

  335. 

  336. /*!

  337. \brief PortRegister request.

  338. */

  339. 

  340. struct JackPortRegisterRequest : public JackRequest

  341. {

  342. 

  343.     int fRefNum;

  344.     char fName[JACK_PORT_NAME_SIZE + 1];

  345.     char fPortType[JACK_PORT_TYPE_SIZE + 1];

  346.     unsigned int fFlags;

  347.     unsigned int fBufferSize;

  348. 

  349.     JackPortRegisterRequest()

  350.     {}

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

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

  353.     {

  354.         strcpy(fName, name);

  355.         strcpy(fPortType, port_type);

  356.     }

  357. 

  358.     int Read(JackChannelTransaction* trans)

  359.     {

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

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

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

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

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

  365. 		return 0;

  366.     }

  367. 

  368.     int Write(JackChannelTransaction* trans)

  369.     {

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

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

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

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

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

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

  376. 		return 0;

  377.     }

  378. };

  379. 

  380. /*!

  381. \brief PortRegister result.

  382. */

  383. 

  384. struct JackPortRegisterResult : public JackResult

  385. {

  386. 

  387.     jack_port_id_t fPortIndex;

  388. 

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

  390.     {}

  391. 

  392.     int Read(JackChannelTransaction* trans)

  393.     {

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

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

  396.     }

  397. 

  398.     int Write(JackChannelTransaction* trans)

  399.     {

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

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

  402.     }

  403. };

  404. 

  405. /*!

  406. \brief PortUnregister request.

  407. */

  408. 

  409. struct JackPortUnRegisterRequest : public JackRequest

  410. {

  411. 

  412.     int fRefNum;

  413.     int fPortIndex;

  414. 

  415.     JackPortUnRegisterRequest()

  416.     {}

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

  418.     {}

  419. 

  420.     int Read(JackChannelTransaction* trans)

  421.     {

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

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

  424. 		return 0;

  425.     }

  426. 

  427.     int Write(JackChannelTransaction* trans)

  428.     {

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

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

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

  432. 		return 0;

  433.     }

  434. };

  435. 

  436. /*!

  437. \brief PortConnectName request.

  438. */

  439. 

  440. struct JackPortConnectNameRequest : public JackRequest

  441. {

  442. 	

  443.     int fRefNum;

  444.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  445.     char fDst[JACK_PORT_NAME_SIZE + 1];

  446. 

  447.     JackPortConnectNameRequest()

  448.     {}

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

  450.     {

  451.         strcpy(fSrc, src_name);

  452.         strcpy(fDst, dst_name);

  453.     }

  454. 

  455.     int Read(JackChannelTransaction* trans)

  456.     {

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

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

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

  460. 		return 0;

  461. 

  462.     }

  463. 

  464.     int Write(JackChannelTransaction* trans)

  465.     {

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

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

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

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

  470. 		return 0;

  471.     }

  472. };

  473. 

  474. /*!

  475. \brief PortDisconnectName request.

  476. */

  477. 

  478. struct JackPortDisconnectNameRequest : public JackRequest

  479. {

  480. 

  481.     int fRefNum;

  482.     char fSrc[JACK_PORT_NAME_SIZE + 1];

  483.     char fDst[JACK_PORT_NAME_SIZE + 1];

  484. 

  485.     JackPortDisconnectNameRequest()

  486.     {}

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

  488.     {

  489.         strcpy(fSrc, src_name);

  490.         strcpy(fDst, dst_name);

  491.     }

  492. 

  493.     int Read(JackChannelTransaction* trans)

  494.     {

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

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

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

  498. 		return 0;

  499.     }

  500. 

  501.     int Write(JackChannelTransaction* trans)

  502.     {

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

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

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

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

  507. 		return 0;

  508.     }

  509. };

  510. 

  511. /*!

  512. \brief PortConnect request.

  513. */

  514. 

  515. struct JackPortConnectRequest : public JackRequest

  516. {

  517. 

  518.     int fRefNum;

  519.     jack_port_id_t fSrc;

  520.     jack_port_id_t fDst;

  521. 

  522.     JackPortConnectRequest()

  523.     {}

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

  525.     {}

  526. 

  527.     int Read(JackChannelTransaction* trans)

  528.     {

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

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

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

  532. 		return 0;

  533.     }

  534. 

  535.     int Write(JackChannelTransaction* trans)

  536.     {

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

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

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

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

  541. 		return 0;

  542.     }

  543. };

  544. 

  545. 

  546. /*!

  547. \brief PortDisconnect request.

  548. */

  549. 

  550. struct JackPortDisconnectRequest : public JackRequest

  551. {

  552. 

  553.     int fRefNum;

  554.     jack_port_id_t fSrc;

  555.     jack_port_id_t fDst;

  556. 

  557.     JackPortDisconnectRequest()

  558.     {}

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

  560.     {}

  561. 

  562.     int Read(JackChannelTransaction* trans)

  563.     {

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

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

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

  567. 		return 0;

  568.     }

  569. 

  570.     int Write(JackChannelTransaction* trans)

  571.     {

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

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

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

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

  576. 		return 0;

  577. 

  578.     }

  579. };

  580. 

  581. /*!

  582. \brief SetBufferSize request.

  583. */

  584. 

  585. struct JackSetBufferSizeRequest : public JackRequest

  586. {

  587. 

  588.     jack_nframes_t fBufferSize;

  589. 

  590.     JackSetBufferSizeRequest()

  591.     {}

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

  593.     {}

  594. 

  595.     int Read(JackChannelTransaction* trans)

  596.     {

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

  598.     }

  599. 

  600.     int Write(JackChannelTransaction* trans)

  601.     {

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

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

  604.     }

  605. };

  606. 

  607. /*!

  608. \brief SetFreeWheel request.

  609. */

  610. 

  611. struct JackSetFreeWheelRequest : public JackRequest

  612. {

  613. 

  614.     int fOnOff;

  615. 

  616.     JackSetFreeWheelRequest()

  617.     {}

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

  619.     {}

  620. 

  621.     int Read(JackChannelTransaction* trans)

  622.     {

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

  624.     }

  625. 

  626.     int Write(JackChannelTransaction* trans)

  627.     {

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

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

  630.     }

  631. };

  632. 

  633. /*!

  634. \brief ReleaseTimebase request.

  635. */

  636. 

  637. struct JackReleaseTimebaseRequest : public JackRequest

  638. {

  639. 

  640.     int fRefNum;

  641. 

  642.     JackReleaseTimebaseRequest()

  643.     {}

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

  645.     {}

  646. 

  647.     int Read(JackChannelTransaction* trans)

  648.     {

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

  650.     }

  651. 

  652.     int Write(JackChannelTransaction* trans)

  653.     {

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

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

  656.     }

  657. };

  658. 

  659. /*!

  660. \brief SetTimebaseCallback request.

  661. */

  662. 

  663. struct JackSetTimebaseCallbackRequest : public JackRequest

  664. {

  665. 

  666.     int fRefNum;

  667.     int fConditionnal;

  668. 

  669.     JackSetTimebaseCallbackRequest()

  670.     {}

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

  672.     {}

  673. 

  674.     int Read(JackChannelTransaction* trans)

  675.     {

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

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

  678.     }

  679. 

  680.     int Write(JackChannelTransaction* trans)

  681.     {

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

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

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

  685.     }

  686. };

  687. 

  688. /*!

  689. \brief ClientNotification request.

  690. */

  691. 

  692. struct JackClientNotificationRequest : public JackRequest

  693. {

  694. 	

  695.     int fRefNum;

  696.     int fNotify;

  697.     int fValue;

  698. 

  699.     JackClientNotificationRequest()

  700.     {}

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

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

  703.     {}

  704. 

  705.     int Read(JackChannelTransaction* trans)

  706.     {

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

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

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

  710. 		return 0;

  711.     }

  712. 

  713.     int Write(JackChannelTransaction* trans)

  714.     {

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

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

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

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

  719. 		return 0;

  720.     }

  721. 

  722. };

  723. 

  724. /*!

  725. \brief ClientNotification.

  726. */

  727. 

  728. struct JackClientNotification

  729. {

  730.     char fName[JACK_CLIENT_NAME_SIZE + 1];

  731.     int fRefNum;

  732.     int fNotify;

  733.     int fValue;

  734.     int fSync;

  735. 

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

  737.     {}

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

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

  740.     {

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

  742.     }

  743. 

  744.     int Read(JackChannelTransaction* trans)

  745.     {

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

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

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

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

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

  751. 		return 0;

  752.     }

  753. 

  754.     int Write(JackChannelTransaction* trans)

  755.     {

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

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

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

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

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

  761. 		return 0;

  762.     }

  763. 

  764. };

  765. 

  766. } // end of namespace

  767. 

  768. #endif