falkTX
/
rtaudio
mirror of https://github.com/falkTX/rtaudio
1
0
Fork 0
Code Releases 27 Activity
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.
2 Commits
5 Branches
2.4MB
Tree: cdfd5a2d8e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cdfd5a2d8e'
${ noResults }
rtaudio/doc/rtf/refman.rtf

1781 lines
105KB
Raw Blame History 

  1. {\rtf1\ansi\ansicpg1252\uc1 \deff0\deflang1033\deflangfe1033

  2. {\fonttbl {\f0\froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}

  3. {\f1\fswiss\fcharset0\fprq2{\*\panose 020b0604020202020204}Arial;}

  4. {\f2\fmodern\fcharset0\fprq1{\*\panose 02070309020205020404}Courier New;}

  5. {\f3\froman\fcharset2\fprq2{\*\panose 05050102010706020507}Symbol;}

  6. }

  7. {\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;}

  8. {\stylesheet

  9. {\widctlpar\adjustright \fs20\cgrid \snext0 Normal;}

  10. {\s1\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs36\kerning36\cgrid \sbasedon0 \snext0 heading 1;}

  11. {\s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid \sbasedon0 \snext0 heading 2;}

  12. {\s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid \sbasedon0 \snext0 heading 3;}

  13. {\s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid \sbasedon0 \snext0 heading 4;}{\*\cs10 \additive Default Paragraph Font;}

  14. {\s15\qc\sb240\sa60\widctlpar\outlinelevel0\adjustright \b\f1\fs32\kerning28\cgrid \sbasedon0 \snext15 Title;}

  15. {\s16\qc\sa60\widctlpar\outlinelevel1\adjustright \f1\cgrid \sbasedon0 \snext16 Subtitle;}

  16. {\s17\sa60\sb30\widctlpar\qj \fs22\cgrid \sbasedon0 \snext17 BodyText;}

  17. {\s18\widctlpar\fs22\cgrid \sbasedon0 \snext18 DenseText;}

  18. {\s28\widctlpar\tqc\tx4320\tqr\tx8640\adjustright \fs20\cgrid \sbasedon0 \snext28 header;}

  19. {\s29\widctlpar\tqc\tx4320\tqr\tx8640\qr\adjustright \fs20\cgrid \sbasedon0 \snext29 footer;}

  20. {\s30\li360\sa60\sb120\keepn\widctlpar\adjustright \b\f1\fs20\cgrid \sbasedon0 \snext30 GroupHeader;}

  21. {\s40\li0\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid \sbasedon0 \snext41 Code Example 0;}

  22. {\s41\li360\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid \sbasedon0 \snext42 Code Example 1;}

  23. {\s42\li720\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid \sbasedon0 \snext43 Code Example 2;}

  24. {\s43\li1080\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid \sbasedon0 \snext44 Code Example 3;}

  25. {\s44\li1440\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid \sbasedon0 \snext45 Code Example 4;}

  26. {\s45\li1800\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid \sbasedon0 \snext46 Code Example 5;}

  27. {\s46\li2160\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid \sbasedon0 \snext47 Code Example 6;}

  28. {\s47\li2520\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid \sbasedon0 \snext48 Code Example 7;}

  29. {\s48\li2880\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid \sbasedon0 \snext49 Code Example 8;}

  30. {\s49\li3240\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid \sbasedon0 \snext49 Code Example 9;}

  31. {\s50\li0\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid \sbasedon0 \snext51 List Continue 0;}

  32. {\s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid \sbasedon0 \snext52 List Continue 1;}

  33. {\s52\li720\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid \sbasedon0 \snext53 List Continue 2;}

  34. {\s53\li1080\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid \sbasedon0 \snext54 List Continue 3;}

  35. {\s54\li1440\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid \sbasedon0 \snext55 List Continue 4;}

  36. {\s55\li1800\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid \sbasedon0 \snext56 List Continue 5;}

  37. {\s56\li2160\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid \sbasedon0 \snext57 List Continue 6;}

  38. {\s57\li2520\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid \sbasedon0 \snext58 List Continue 7;}

  39. {\s58\li2880\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid \sbasedon0 \snext59 List Continue 8;}

  40. {\s59\li3240\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid \sbasedon0 \snext59 List Continue 9;}

  41. {\s60\li0\widctlpar\ql\adjustright \fs20\cgrid \sbasedon0 \snext61 DescContinue 0;}

  42. {\s61\li360\widctlpar\ql\adjustright \fs20\cgrid \sbasedon0 \snext62 DescContinue 1;}

  43. {\s62\li720\widctlpar\ql\adjustright \fs20\cgrid \sbasedon0 \snext63 DescContinue 2;}

  44. {\s63\li1080\widctlpar\ql\adjustright \fs20\cgrid \sbasedon0 \snext64 DescContinue 3;}

  45. {\s64\li1440\widctlpar\ql\adjustright \fs20\cgrid \sbasedon0 \snext65 DescContinue 4;}

  46. {\s65\li1800\widctlpar\ql\adjustright \fs20\cgrid \sbasedon0 \snext66 DescContinue 5;}

  47. {\s66\li2160\widctlpar\ql\adjustright \fs20\cgrid \sbasedon0 \snext67 DescContinue 6;}

  48. {\s67\li2520\widctlpar\ql\adjustright \fs20\cgrid \sbasedon0 \snext68 DescContinue 7;}

  49. {\s68\li2880\widctlpar\ql\adjustright \fs20\cgrid \sbasedon0 \snext69 DescContinue 8;}

  50. {\s69\li3240\widctlpar\ql\adjustright \fs20\cgrid \sbasedon0 \snext69 DescContinue 9;}

  51. {\s70\li0\sa30\sb30\widctlpar\tqr\tldot\tx8640\adjustright \fs20\cgrid \sbasedon0 \snext81 LatexTOC 0;}

  52. {\s71\li360\sa27\sb27\widctlpar\tqr\tldot\tx8640\adjustright \fs20\cgrid \sbasedon0 \snext82 LatexTOC 1;}

  53. {\s72\li720\sa24\sb24\widctlpar\tqr\tldot\tx8640\adjustright \fs20\cgrid \sbasedon0 \snext83 LatexTOC 2;}

  54. {\s73\li1080\sa21\sb21\widctlpar\tqr\tldot\tx8640\adjustright \fs20\cgrid \sbasedon0 \snext84 LatexTOC 3;}

  55. {\s74\li1440\sa18\sb18\widctlpar\tqr\tldot\tx8640\adjustright \fs20\cgrid \sbasedon0 \snext85 LatexTOC 4;}

  56. {\s75\li1800\sa15\sb15\widctlpar\tqr\tldot\tx8640\adjustright \fs20\cgrid \sbasedon0 \snext86 LatexTOC 5;}

  57. {\s76\li2160\sa12\sb12\widctlpar\tqr\tldot\tx8640\adjustright \fs20\cgrid \sbasedon0 \snext87 LatexTOC 6;}

  58. {\s77\li2520\sa9\sb9\widctlpar\tqr\tldot\tx8640\adjustright \fs20\cgrid \sbasedon0 \snext88 LatexTOC 7;}

  59. {\s78\li2880\sa6\sb6\widctlpar\tqr\tldot\tx8640\adjustright \fs20\cgrid \sbasedon0 \snext89 LatexTOC 8;}

  60. {\s79\li3240\sa3\sb3\widctlpar\tqr\tldot\tx8640\adjustright \fs20\cgrid \sbasedon0 \snext89 LatexTOC 9;}

  61. {\s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid \sbasedon0 \snext81 \sautoupd List Bullet 0;}

  62. {\s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid \sbasedon0 \snext82 \sautoupd List Bullet 1;}

  63. {\s82\fi-360\li1080\widctlpar\jclisttab\tx1080{\*\pn \pnlvlbody\ilvl0\ls3\pnrnot0\pndec }\ls3\adjustright \fs20\cgrid \sbasedon0 \snext83 \sautoupd List Bullet 2;}

  64. {\s83\fi-360\li1440\widctlpar\jclisttab\tx1440{\*\pn \pnlvlbody\ilvl0\ls4\pnrnot0\pndec }\ls4\adjustright \fs20\cgrid \sbasedon0 \snext84 \sautoupd List Bullet 3;}

  65. {\s84\fi-360\li1800\widctlpar\jclisttab\tx1800{\*\pn \pnlvlbody\ilvl0\ls5\pnrnot0\pndec }\ls5\adjustright \fs20\cgrid \sbasedon0 \snext85 \sautoupd List Bullet 4;}

  66. {\s85\fi-360\li2160\widctlpar\jclisttab\tx2160{\*\pn \pnlvlbody\ilvl0\ls6\pnrnot0\pndec }\ls6\adjustright \fs20\cgrid \sbasedon0 \snext86 \sautoupd List Bullet 5;}

  67. {\s86\fi-360\li2520\widctlpar\jclisttab\tx2520{\*\pn \pnlvlbody\ilvl0\ls7\pnrnot0\pndec }\ls7\adjustright \fs20\cgrid \sbasedon0 \snext87 \sautoupd List Bullet 6;}

  68. {\s87\fi-360\li2880\widctlpar\jclisttab\tx2880{\*\pn \pnlvlbody\ilvl0\ls8\pnrnot0\pndec }\ls8\adjustright \fs20\cgrid \sbasedon0 \snext88 \sautoupd List Bullet 7;}

  69. {\s88\fi-360\li3240\widctlpar\jclisttab\tx3240{\*\pn \pnlvlbody\ilvl0\ls9\pnrnot0\pndec }\ls9\adjustright \fs20\cgrid \sbasedon0 \snext89 \sautoupd List Bullet 8;}

  70. {\s89\fi-360\li3600\widctlpar\jclisttab\tx3600{\*\pn \pnlvlbody\ilvl0\ls10\pnrnot0\pndec }\ls10\adjustright \fs20\cgrid \sbasedon0 \snext89 \sautoupd List Bullet 9;}

  71. {\s90\fi-360\li360\widctlpar\fs20\cgrid \sbasedon0 \snext91 \sautoupd List Enum 0;}

  72. {\s91\fi-360\li720\widctlpar\fs20\cgrid \sbasedon0 \snext92 \sautoupd List Enum 1;}

  73. {\s92\fi-360\li1080\widctlpar\fs20\cgrid \sbasedon0 \snext93 \sautoupd List Enum 2;}

  74. {\s93\fi-360\li1440\widctlpar\fs20\cgrid \sbasedon0 \snext94 \sautoupd List Enum 3;}

  75. {\s94\fi-360\li1800\widctlpar\fs20\cgrid \sbasedon0 \snext95 \sautoupd List Enum 4;}

  76. {\s95\fi-360\li2160\widctlpar\fs20\cgrid \sbasedon0 \snext96 \sautoupd List Enum 5;}

  77. {\s96\fi-360\li2520\widctlpar\fs20\cgrid \sbasedon0 \snext96 \sautoupd List Enum 5;}

  78. {\s97\fi-360\li2880\widctlpar\fs20\cgrid \sbasedon0 \snext98 \sautoupd List Enum 7;}

  79. {\s98\fi-360\li3240\widctlpar\fs20\cgrid \sbasedon0 \snext99 \sautoupd List Enum 8;}

  80. {\s99\fi-360\li3600\widctlpar\fs20\cgrid \sbasedon0 \snext99 \sautoupd List Enum 9;}

  81. }

  82. {\comment begin body}

  83. {\info 

  84. {\title {\comment RtAudio Reference Manual}RtAudio}

  85. {\comment Generated byDoxgyen. }

  86. {\creatim \yr2002\mo1\dy22\hr15\min27\sec40}

  87. }\pard\plain 

  88. \sectd\pgnlcrm

  89. {\footer \s29\widctlpar\tqc\tx4320\tqr\tx8640\qr\adjustright \fs20\cgrid {\chpgn}}

  90. \pard\plain \s16\qc\sa60\widctlpar\outlinelevel1\adjustright \f1\cgrid 

  91. \vertalc\qc\par\par\par\par\par\par\par\pard\plain \s15\qc\sb240\sa60\widctlpar\outlinelevel0\adjustright \b\f1\fs32\kerning28\cgrid 

  92. {\field\fldedit {\*\fldinst TITLE \\*MERGEFORMAT}{\fldrslt TITLE}}\par

  93. \pard\plain \s16\qc\sa60\widctlpar\outlinelevel1\adjustright \f1\cgrid 

  94. \par

  95. \par\par\par\par\par\par\par\par\par\par\par\par

  96. \pard\plain \s16\qc\sa60\widctlpar\outlinelevel1\adjustright \f1\cgrid 

  97. {\field\fldedit {\*\fldinst AUTHOR \\*MERGEFORMAT}{\fldrslt AUTHOR}}\par

  98. Version \par{\field\fldedit {\*\fldinst CREATEDATE \\*MERGEFORMAT}{\fldrslt CREATEDATE}}\par

  99. \page\page\vertalt

  100. \pard\plain 

  101. {\field\fldedit {\*\fldinst TOC \\f \\*MERGEFORMAT}{\fldrslt Table of contents}}\par

  102. \pard\plain 

  103. 

  104. \pard\plain \sect\sbkpage

  105. \s1\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs36\kerning36\cgrid 

  106. The {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) Tutorial\par \pard\plain 

  107. {\tc \v Main Page}

  108. {

  109. \pard\plain \s17\sa60\sb30\widctlpar\qj \fs22\cgrid  \par

  110. {\qc

  111.  {\b Introduction} (p.{\field\fldedit {\*\fldinst PAGEREF intro \\*MERGEFORMAT}{\fldrslt pagenum}})

  112.  \~ \~  {\b Download} (p.{\field\fldedit {\*\fldinst PAGEREF download \\*MERGEFORMAT}{\fldrslt pagenum}})

  113.  \~ \~  {\b Getting Started} (p.{\field\fldedit {\*\fldinst PAGEREF start \\*MERGEFORMAT}{\fldrslt pagenum}})

  114.  \~ \~  {\b Error Handling} (p.{\field\fldedit {\*\fldinst PAGEREF error \\*MERGEFORMAT}{\fldrslt pagenum}})

  115.  \~ \~  {\b Probing Device Capabilities} (p.{\field\fldedit {\*\fldinst PAGEREF probing \\*MERGEFORMAT}{\fldrslt pagenum}})

  116.  \~ \~  {\b Device Settings} (p.{\field\fldedit {\*\fldinst PAGEREF settings \\*MERGEFORMAT}{\fldrslt pagenum}})

  117.  \~ \~  {\b Playback (blocking functionality)} (p.{\field\fldedit {\*\fldinst PAGEREF playbackb \\*MERGEFORMAT}{\fldrslt pagenum}})

  118.  \~ \~  {\b Playback (callback functionality)} (p.{\field\fldedit {\*\fldinst PAGEREF playbackc \\*MERGEFORMAT}{\fldrslt pagenum}})

  119.  \~ \~  {\b Recording} (p.{\field\fldedit {\*\fldinst PAGEREF recording \\*MERGEFORMAT}{\fldrslt pagenum}})

  120.  \~ \~  {\b Duplex Mode} (p.{\field\fldedit {\*\fldinst PAGEREF duplex \\*MERGEFORMAT}{\fldrslt pagenum}})

  121.  \~ \~  {\b Summary of Methods} (p.{\field\fldedit {\*\fldinst PAGEREF methods \\*MERGEFORMAT}{\fldrslt pagenum}})

  122.  \~ \~  {\b Compiling} (p.{\field\fldedit {\*\fldinst PAGEREF compiling \\*MERGEFORMAT}{\fldrslt pagenum}})

  123.  \~ \~  {\b OS Notes} (p.{\field\fldedit {\*\fldinst PAGEREF osnotes \\*MERGEFORMAT}{\fldrslt pagenum}})

  124.  \~ \~  {\b Acknowledgments} (p.{\field\fldedit {\*\fldinst PAGEREF acknowledge \\*MERGEFORMAT}{\fldrslt pagenum}})

  125.  }\par

  126. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Introduction}

  127. Introduction\par

  128. {\bkmkstart intro}

  129. {\bkmkend intro}

  130. }\par

  131. {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) is a C++ class which provides a common API (Application Programming Interface) for realtime audio input/output across Linux (native ALSA and OSS), SGI, and Windows operating systems. {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) significantly simplifies the process of interacting with computer audio hardware. It was designed with the following goals:\par

  132. { \par

  133. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  134. object oriented C++ design \par

  135. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  136. simple, common API across all supported platforms \par

  137. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  138. single independent header and source file for easy inclusion in programming projects (no libraries!) \par

  139. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  140. blocking functionality \par

  141. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  142. callback functionality \par

  143. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  144. extensive audio device parameter control \par

  145. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  146. audio device capability probing \par

  147. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  148. automatic internal conversion for data format, channel number compensation, de-interleaving, and byte-swapping \par

  149. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  150. control over multiple audio streams and devices with a single instance \par

  151. }{\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) incorporates the concept of audio streams, which represent audio output (playback) and/or input (recording). Available audio devices and their capabilities can be enumerated and then specified when opening a stream. Multiple streams can run at the same time and, when allowed by the underlying audio API, a single device can serve multiple streams.\par

  152. The {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) API provides both blocking (synchronous) and callback (asynchronous) functionality. Callbacks are typically used in conjunction with graphical user interfaces (GUI). Blocking functionality is often necessary for explicit control of multiple input/output stream synchronization or when audio must be synchronized with other system events.\par

  153. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Download}

  154. Download\par

  155. {\bkmkstart download}

  156. {\bkmkend download}

  157. }\par

  158. Latest Release (22 January 2002): {\f2 Version 2.0 (111 kB tar/gzipped)}\par

  159. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Getting Started}

  160. Getting Started\par

  161. {\bkmkstart start}

  162. {\bkmkend start}

  163. }\par

  164. The first thing that must be done when using {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) is to create an instance of the class. The default constructor {\b RtAudio::RtAudio}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a0 \\*MERGEFORMAT}{\fldrslt pagenum}}}) scans the underlying audio system to verify that at least one device is available. {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) often uses C++ exceptions to report errors, necessitating try/catch blocks around most member functions. The following code example demonstrates default object construction and destruction:\par

  165. {

  166. \par

  167. \pard\plain \s40\li0\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid #include "RtAudio.h"\line

  168. \line

  169. int main()
\line

  170. \{\line

  171.   RtAudio *audio;\line

  172. \line

  173.   // Default RtAudio constructor\line

  174.   try \{\line

  175.     audio = new RtAudio();\line

  176.   \}\line

  177.   catch (RtAudioError &error) \{\line

  178.     // Handle the exception here\line

  179.   \}\line

  180. \line

  181.   // Clean up\line

  182.   delete audio;\line

  183. \}\par

  184. }

  185. Obviously, this example doesn't demonstrate any of the real functionality of {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}). However, all uses of {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) must begin with a constructor (either default or overloaded varieties) and must end with class destruction. Further, it is necessary that all class methods which can throw a C++ exception be called within a try/catch block.\par

  186. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Error Handling}

  187. Error Handling\par

  188. {\bkmkstart error}

  189. {\bkmkend error}

  190. }\par

  191. {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) uses a C++ exception handler called {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}), which is declared and defined within the {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) class files. The {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) class is quite simple but it does allow errors to be "caught" by {\b RtAudioError::TYPE} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError_s11 \\*MERGEFORMAT}{\fldrslt pagenum}}}). Almost all {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) methods can "throw" an {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}), most typically if an invalid stream identifier is supplied to a method or a driver error occurs. There are a number of cases within {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) where warning messages may be displayed but an exception is not thrown. There is a private {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) method, error(), which can be modified to globally control how these messages are handled and reported.\par

  192. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Probing Device Capabilities}

  193. Probing Device Capabilities\par

  194. {\bkmkstart probing}

  195. {\bkmkend probing}

  196. }\par

  197. A programmer may wish to query the available audio device capabilities before deciding which to use. The following example outlines how this can be done.\par

  198. {

  199. \par

  200. \pard\plain \s40\li0\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid // probe.cpp\line

  201. \line

  202. #include <iostream.h>\line

  203. #include "RtAudio.h"\line

  204. \line

  205. int main()
\line

  206. \{\line

  207.   RtAudio *audio;\line

  208. \line

  209.   // Default RtAudio constructor\line

  210.   try \{\line

  211.     audio = new RtAudio();\line

  212.   \}\line

  213.   catch (RtAudioError &error) \{\line

  214.     error.printMessage();\line

  215.     exit(EXIT_FAILURE);\line

  216.   \}\line

  217. \line

  218.   // Determine the number of devices available\line

  219.   int devices = audio->getDeviceCount();\line

  220. \line

  221.   // Scan through devices for various capabilities\line

  222.   RtAudio::RTAUDIO_DEVICE info;\line

  223.   for (int i=0; i<devices; i++) \{\line

  224. \line

  225.     try \{\line

  226.       audio->getDeviceInfo(i, &info);\line

  227.     \}\line

  228.     catch (RtAudioError &error) \{\line

  229.       error.printMessage();\line

  230.       break;\line

  231.     \}\line

  232. \line

  233.     // Print, for example, the maximum number of output channels for each device\line

  234.     cout << "device = " << i;\line

  235.     cout << ": maximum output channels = " << info.maxOutputChannels << endl;\line

  236.   \}\line

  237. \line

  238.   // Clean up\line

  239.   delete audio;\line

  240. \line

  241.   return 0;\line

  242. \}\par

  243. }

  244. The RTAUDIO_DEVICE structure is defined in {\b RtAudio.h} and provides a variety of information useful in assessing the capabilities of a device:\par

  245. {

  246. \par

  247. \pard\plain \s40\li0\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid   typedef struct \{\line

  248.     char name[128];\line

  249.     DEVICE_ID id[2];                      // No value reported by getDeviceInfo().\line

  250.     bool probed;                          // true if the device probe was successful.\line

  251.     int maxOutputChannels;\line

  252.     int maxInputChannels;\line

  253.     int maxDuplexChannels;\line

  254.     int minOutputChannels;\line

  255.     int minInputChannels;\line

  256.     int minDuplexChannels;\line

  257.     bool hasDuplexSupport;                // true if duplex supported\line

  258.     int nSampleRates;                     // Number of discrete rates, or -1 if range supported.\line

  259.     double sampleRates[MAX_SAMPLE_RATES]; // Supported sample rates, or \{min, max\} if range.\line

  260.     RTAUDIO_FORMAT nativeFormats;\line

  261.   \} RTAUDIO_DEVICE;\par

  262. }

  263. The following data formats are defined and fully supported by {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}):\par

  264. {

  265. \par

  266. \pard\plain \s40\li0\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid   typedef unsigned long RTAUDIO_FORMAT;\line

  267.   static const RTAUDIO_FORMAT  RTAUDIO_SINT8;   // Signed 8-bit integer\line

  268.   static const RTAUDIO_FORMAT  RTAUDIO_SINT16;  // Signed 16-bit integer\line

  269.   static const RTAUDIO_FORMAT  RTAUDIO_SINT24;  // Signed 24-bit integer\line

  270.   static const RTAUDIO_FORMAT  RTAUDIO_SINT32;  // Signed 32-bit integer\line

  271.   static const RTAUDIO_FORMAT  RTAUDIO_FLOAT32; // 32-bit float\line

  272.   static const RTAUDIO_FORMAT  RTAUDIO_FLOAT64; // 64-bit double\par

  273. }

  274. The {\i nativeFormats} member of the {\b RtAudio::RTAUDIO_DEVICE} ({\i p.{\field\fldedit {\*\fldinst PAGEREF structRtAudio_1_1RTAUDIO__DEVICE \\*MERGEFORMAT}{\fldrslt pagenum}}}) structure is a bit mask of the above formats which are natively supported by the device. However, {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) will automatically provide format conversion if a particular format is not natively supported. When the {\i probed} member of the RTAUDIO_DEVICE structure is false, the remaining structure members are likely unknown and the device is probably unusable.\par

  275. In general, the user need not be concerned with the minimum channel values reported in the RTAUDIO_DEVICE structure. While some audio devices may require a minimum channel value > 1, {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) will provide automatic channel number compensation when the number of channels set by the user is less than that required by the device. Channel compensation is {\i NOT} possible when the number of channels set by the user is greater than that supported by the device.\par

  276. It should be noted that the capabilities reported by a device driver or underlying audio API are not always accurate and/or may be dependent on a combination of device settings.\par

  277. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Device Settings}

  278. Device Settings\par

  279. {\bkmkstart settings}

  280. {\bkmkend settings}

  281. }\par

  282. The next step in using {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) is to open a stream with a particular set of device settings.\par

  283. {

  284. \par

  285. \pard\plain \s40\li0\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid #include "RtAudio.h"\line

  286. \line

  287. int main()
\line

  288. \{\line

  289.   int channels = 2;\line

  290.   int sample_rate = 44100;\line

  291.   int buffer_size = 256;  // 256 sample frames\line

  292.   int n_buffers = 4;      // number of internal buffers used by device\line

  293.   int device = 0;         // 0 indicates the default or first available device\line

  294.   int stream;             // our stream identifier\line

  295.   RtAudio *audio;\line

  296. \line

  297.   // Instantiate RtAudio and open a stream within a try/catch block\line

  298.   try \{\line

  299.     audio = new RtAudio();\line

  300.     stream = audio->openStream(device, channels, 0, 0, RtAudio::RTAUDIO_FLOAT32,\line

  301.                                sample_rate, &buffer_size, n_buffers);\line

  302.   \}\line

  303.   catch (RtAudioError &error) \{\line

  304.     error.printMessage();\line

  305.     exit(EXIT_FAILURE);\line

  306.   \}\line

  307. \line

  308.   // Clean up\line

  309.   delete audio;\line

  310. \line

  311.   return 0;\line

  312. \}\par

  313. }

  314. The {\b RtAudio::openStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a3 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method attempts to open a stream with a specified set of parameter values. When successful, a stream identifier is returned. In this case, we attempt to open a playback stream on device 0 with two channels, 32-bit floating point data, a sample rate of 44100 Hz, a frame rate of 256 sample frames per read/write, and 4 internal device buffers. When device = 0, {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) first attempts to open the default audio device with the given parameters. If that attempt fails, an attempt is made to find a device or set of devices which will meet the given parameters. If all attempts are unsuccessful, an {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) is thrown. When a non-zero device value is specified, an attempt is made to open that device only.\par

  315. {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) provides four signed integer and two floating point data formats which can be specified using the {\b RtAudio::RTAUDIO_FORMAT} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_s0 \\*MERGEFORMAT}{\fldrslt pagenum}}}) parameter values mentioned earlier. If the opened device does not natively support the given format, {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) will automatically perform the necessary data format conversion.\par

  316. Buffer sizes in {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) are {\i ALWAYS} given in sample frame units. For example, if you open an output stream with 4 channels and set {\i bufferSize} to 512, you will have to write 2048 samples of data to the output buffer within your callback or between calls to {\b RtAudio::tickStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a9 \\*MERGEFORMAT}{\fldrslt pagenum}}}). In this case, a single sample frame of data contains 4 samples of data.\par

  317. The {\i bufferSize} parameter specifies the desired number of sample frames which will be written to and/or read from a device per write/read operation. The {\i nBuffers} parameter is used in setting the underlying device buffer parameters. Both the {\i bufferSize} and {\i nBuffers} parameters can be used to control stream latency though there is no guarantee that the passed values will be those used by a device. In general, lower values for both parameters will produce less latency but perhaps less robust performance. Both parameters can be specified with values of zero, in which case the smallest allowable values will be used. The {\i bufferSize} parameter is passed as a pointer and the actual value used by the stream is set during the device setup procedure. {\i bufferSize} values should be a power of two. Optimal and allowable buffer values tend to vary between systems and devices. Check the {\b OS Notes} (p.{\field\fldedit {\*\fldinst PAGEREF osnotes \\*MERGEFORMAT}{\fldrslt pagenum}})

  318.  section for general guidelines.\par

  319. As noted earlier, the device capabilities reported by a driver or underlying audio API are not always accurate and/or may be dependent on a combination of device settings. Because of this, {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) does not attempt to query a device's capabilities or use previously reported values when opening a device. Instead, {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) simply attempts to set the given parameters on a specified device and then checks whether the setup is successful or not.\par

  320. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Playback (blocking functionality)}

  321. Playback (blocking functionality)\par

  322. {\bkmkstart playbackb}

  323. {\bkmkend playbackb}

  324. }\par

  325. Once the device is open for playback, there are only a few final steps necessary for realtime audio output. We'll first provide an example (blocking functionality) and then discuss the details.\par

  326. {

  327. \par

  328. \pard\plain \s40\li0\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid // playback.cpp\line

  329. \line

  330. #include "RtAudio.h"\line

  331. \line

  332. int main()
\line

  333. \{\line

  334.   int count;\line

  335.   int channels = 2;\line

  336.   int sample_rate = 44100;\line

  337.   int buffer_size = 256;  // 256 sample frames\line

  338.   int n_buffers = 4;      // number of internal buffers used by device\line

  339.   float *buffer;\line

  340.   int device = 0;         // 0 indicates the default or first available device\line

  341.   int stream;             // our stream identifier\line

  342.   RtAudio *audio;\line

  343. \line

  344.   // Open a stream during RtAudio instantiation\line

  345.   try \{\line

  346.     audio = new RtAudio(&stream, device, channels, 0, 0, RtAudio::RTAUDIO_FLOAT32,\line

  347.                         sample_rate, &buffer_size, n_buffers);\line

  348.   \}\line

  349.   catch (RtAudioError &error) \{\line

  350.     error.printMessage();\line

  351.     exit(EXIT_FAILURE);\line

  352.   \}\line

  353. \line

  354.   try \{\line

  355.     // Get a pointer to the stream buffer\line

  356.     buffer = (float *) audio->getStreamBuffer(stream);\line

  357. \line

  358.     // Start the stream\line

  359.     audio->startStream(stream);\line

  360.   \}\line

  361.   catch (RtAudioError &error) \{\line

  362.     error.printMessage();\line

  363.     goto cleanup;\line

  364.   \}\line

  365. \line

  366.   // An example loop which runs for about 40000 sample frames\line

  367.   count = 0;\line

  368.   while (count < 40000) \{\line

  369.     // Generate your samples and fill the buffer with buffer_size sample frames of data\line

  370.     ...\line

  371. \line

  372.     // Trigger the output of the data buffer\line

  373.     try \{\line

  374.       audio->tickStream(stream);\line

  375.     \}\line

  376.     catch (RtAudioError &error) \{\line

  377.       error.printMessage();\line

  378.       goto cleanup;\line

  379.     \}\line

  380. \line

  381.     count += buffer_size;\line

  382.   \}\line

  383. \line

  384.   try \{\line

  385.     // Stop and close the stream\line

  386.     audio->stopStream(stream);\line

  387.     audio->closeStream(stream);\line

  388.   \}\line

  389.   catch (RtAudioError &error) \{\line

  390.     error.printMessage();\line

  391.   \}\line

  392. \line

  393.  cleanup:\line

  394.   delete audio;\line

  395. \line

  396.   return 0;\line

  397. \}\par

  398. }

  399. The first thing to notice in this example is that we attempt to open a stream during class instantiation with an overloaded constructor. This constructor simply combines the functionality of the default constructor, used earlier, and the {\b RtAudio::openStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a3 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method. Again, we have specified a device value of 0, indicating that the default or first available device meeting the given parameters should be used. The integer identifier of the opened stream is returned via the {\i stream} pointer value. An attempt is made to open the stream with the specified {\i bufferSize} value. However, it is possible that the device will not accept this value, in which case the closest allowable size is used and returned via the pointer value. The constructor can fail if no available devices are found, or a memory allocation or device driver error occurs. Note that you should not call the {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) destructor if an exception is thrown during instantiation.\par

  400. Because {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) can be used to simultaneously control more than a single stream, it is necessary that the stream identifier be provided to nearly all public methods. Assuming the constructor is successful, it is necessary to get a pointer to the buffer, provided by {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}), for use in feeding data to/from the opened stream. Note that the user should {\i NOT} attempt to deallocate the stream buffer memory ... memory management for the stream buffer will be automatically controlled by {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}). After starting the stream with {\b RtAudio::startStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a11 \\*MERGEFORMAT}{\fldrslt pagenum}}}), one simply fills that buffer, which is of length equal to the returned {\i bufferSize} value, with interleaved audio data (in the specified format) for playback. Finally, a call to the {\b RtAudio::tickStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a9 \\*MERGEFORMAT}{\fldrslt pagenum}}}) routine triggers a blocking write call for the stream.\par

  401. In general, one should call the {\b RtAudio::stopStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a12 \\*MERGEFORMAT}{\fldrslt pagenum}}}) and {\b RtAudio::closeStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a10 \\*MERGEFORMAT}{\fldrslt pagenum}}}) methods after finishing with a stream. However, both methods will implicitly be called during object destruction if necessary.\par

  402. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Playback (callback functionality)}

  403. Playback (callback functionality)\par

  404. {\bkmkstart playbackc}

  405. {\bkmkend playbackc}

  406. }\par

  407. The primary difference in using {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) with callback functionality involves the creation of a user-defined callback function. Here is an example which produces a sawtooth waveform for playback.\par

  408. {

  409. \par

  410. \pard\plain \s40\li0\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid #include <iostream.h>\line

  411. #include "RtAudio.h"\line

  412. \line

  413. // Two-channel sawtooth wave generator.\line

  414. int sawtooth(char *buffer, int buffer_size, void *data)
\line

  415. \{\line

  416.   int i, j;\line

  417.   double *my_buffer = (double *) buffer;\line

  418.   double *my_data = (double *) data;\line

  419. \line

  420.   // Write interleaved audio data.\line

  421.   for (i=0; i<buffer_size; i++) \{\line

  422.     for (j=0; j<2; j++) \{\line

  423.       *my_buffer++ = my_data[j];\line

  424. \line

  425.       my_data[j] += 0.005 * (j+1+(j*0.1));\line

  426.       if (my_data[j] >= 1.0) my_data[j] -= 2.0;\line

  427.     \}\line

  428.   \}\line

  429. \line

  430.   return 0;\line

  431. \}\line

  432. \line

  433. int main()
\line

  434. \{\line

  435.   int channels = 2;\line

  436.   int sample_rate = 44100;\line

  437.   int buffer_size = 256;  // 256 sample frames\line

  438.   int n_buffers = 4;      // number of internal buffers used by device\line

  439.   int device = 0;         // 0 indicates the default or first available device\line

  440.   int stream;             // our stream identifier\line

  441.   double data[2];\line

  442.   char input;\line

  443.   RtAudio *audio;\line

  444. \line

  445.   // Open a stream during RtAudio instantiation\line

  446.   try \{\line

  447.     audio = new RtAudio(&stream, device, channels, 0, 0, RtAudio::RTAUDIO_FLOAT64,\line

  448.                         sample_rate, &buffer_size, n_buffers);\line

  449.   \}\line

  450.   catch (RtAudioError &error) \{\line

  451.     error.printMessage();\line

  452.     exit(EXIT_FAILURE);\line

  453.   \}\line

  454. \line

  455.   try \{\line

  456.     // Set the stream callback function\line

  457.     audio->setStreamCallback(stream, &sawtooth, (void *)data);\line

  458. \line

  459.     // Start the stream\line

  460.     audio->startStream(stream);\line

  461.   \}\line

  462.   catch (RtAudioError &error) \{\line

  463.     error.printMessage();\line

  464.     goto cleanup;\line

  465.   \}\line

  466. \line

  467.   cout << "\\nPlaying ... press <enter> to quit.\\n";\line

  468.   cin.get(input);\line

  469. \line

  470.   try \{\line

  471.     // Stop and close the stream\line

  472.     audio->stopStream(stream);\line

  473.     audio->closeStream(stream);\line

  474.   \}\line

  475.   catch (RtAudioError &error) \{\line

  476.     error.printMessage();\line

  477.   \}\line

  478. \line

  479.  cleanup:\line

  480.   delete audio;\line

  481. \line

  482.   return 0;\line

  483. \}\par

  484. }

  485. After opening the device in exactly the same way as the previous example (except with a data format change), we must set our callback function for the stream using {\b RtAudio::setStreamCallback}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a4 \\*MERGEFORMAT}{\fldrslt pagenum}}}). This method will spawn a new process (or thread) which automatically calls the callback function when more data is needed. Note that the callback function is called only when the stream is "running" (between calls to the {\b RtAudio::startStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a11 \\*MERGEFORMAT}{\fldrslt pagenum}}}) and {\b RtAudio::stopStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a12 \\*MERGEFORMAT}{\fldrslt pagenum}}}) methods). The last argument to {\b RtAudio::setStreamCallback}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a4 \\*MERGEFORMAT}{\fldrslt pagenum}}}) is a pointer to arbitrary data that you wish to access from within your callback function.\par

  486. In this example, we stop the stream with an explicit call to {\b RtAudio::stopStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a12 \\*MERGEFORMAT}{\fldrslt pagenum}}}). When using callback functionality, it is also possible to stop a stream by returning a non-zero value from the callback function.\par

  487. Once set with {\b RtAudio::setStreamCallback} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a4 \\*MERGEFORMAT}{\fldrslt pagenum}}}), the callback process will continue to run for the life of the stream (until the stream is closed with {\b RtAudio::closeStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a10 \\*MERGEFORMAT}{\fldrslt pagenum}}}) or the {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) instance is deleted). It is possible to disassociate a callback function and cancel its process for an open stream using the {\b RtAudio::cancelStreamCallback}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a5 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method. The stream can then be used with blocking functionality or a new callback can be associated with it.\par

  488. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Recording}

  489. Recording\par

  490. {\bkmkstart recording}

  491. {\bkmkend recording}

  492. }\par

  493. Using {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) for audio input is almost identical to the way it is used for playback. Here's the blocking playback example rewritten for recording:\par

  494. {

  495. \par

  496. \pard\plain \s40\li0\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid // record.cpp\line

  497. \line

  498. #include "RtAudio.h"\line

  499. \line

  500. int main()
\line

  501. \{\line

  502.   int count;\line

  503.   int channels = 2;\line

  504.   int sample_rate = 44100;\line

  505.   int buffer_size = 256;  // 256 sample frames\line

  506.   int n_buffers = 4;      // number of internal buffers used by device\line

  507.   float *buffer;\line

  508.   int device = 0;         // 0 indicates the default or first available device\line

  509.   int stream;             // our stream identifier\line

  510.   RtAudio *audio;\line

  511. \line

  512.   // Instantiate RtAudio and open a stream.\line

  513.   try \{\line

  514.     audio = new RtAudio(&stream, 0, 0, device, channels,\line

  515.                         RtAudio::RTAUDIO_FLOAT32, sample_rate, &buffer_size, n_buffers);\line

  516.   \}\line

  517.   catch (RtAudioError &error) \{\line

  518.     error.printMessage();\line

  519.     exit(EXIT_FAILURE);\line

  520.   \}\line

  521. \line

  522.   try \{\line

  523.     // Get a pointer to the stream buffer\line

  524.     buffer = (float *) audio->getStreamBuffer(stream);\line

  525. \line

  526.     // Start the stream\line

  527.     audio->startStream(stream);\line

  528.   \}\line

  529.   catch (RtAudioError &error) \{\line

  530.     error.printMessage();\line

  531.     goto cleanup;\line

  532.   \}\line

  533. \line

  534.   // An example loop which runs for about 40000 sample frames\line

  535.   count = 0;\line

  536.   while (count < 40000) \{\line

  537. \line

  538.     // Read a buffer of data\line

  539.     try \{\line

  540.       audio->tickStream(stream);\line

  541.     \}\line

  542.     catch (RtAudioError &error) \{\line

  543.       error.printMessage();\line

  544.       goto cleanup;\line

  545.     \}\line

  546. \line

  547.     // Process the input samples (buffer_size sample frames) that were read\line

  548.     ...\line

  549. \line

  550.     count += buffer_size;\line

  551.   \}\line

  552. \line

  553.   try \{\line

  554.     // Stop the stream\line

  555.     audio->stopStream(stream);\line

  556.   \}\line

  557.   catch (RtAudioError &error) \{\line

  558.     error.printMessage();\line

  559.   \}\line

  560. \line

  561.  cleanup:\line

  562.   delete audio;\line

  563. \line

  564.   return 0;\line

  565. \}\par

  566. }

  567. In this example, the stream was opened for recording with a non-zero {\i inputChannels} value. The only other difference between this example and that for playback involves the order of data processing in the loop, where it is necessary to first read a buffer of input data before manipulating it.\par

  568. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Duplex Mode}

  569. Duplex Mode\par

  570. {\bkmkstart duplex}

  571. {\bkmkend duplex}

  572. }\par

  573. Finally, it is easy to use {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) for simultaneous audio input/output, or duplex operation. In this example, we use a callback function and pass our recorded data directly through for playback.\par

  574. {

  575. \par

  576. \pard\plain \s40\li0\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid // duplex.cpp\line

  577. \line

  578. #include <iostream.h>\line

  579. #include "RtAudio.h"\line

  580. \line

  581. // Pass-through function.\line

  582. int pass(char *buffer, int buffer_size, void *)
\line

  583. \{\line

  584.   // Surprise!!  We do nothing to pass the data through.\line

  585.   return 0;\line

  586. \}\line

  587. \line

  588. int main()
\line

  589. \{\line

  590.   int channels = 2;\line

  591.   int sample_rate = 44100;\line

  592.   int buffer_size = 256;  // 256 sample frames\line

  593.   int n_buffers = 4;      // number of internal buffers used by device\line

  594.   int device = 0;         // 0 indicates the default or first available device\line

  595.   int stream;             // our stream identifier\line

  596.   double data[2];\line

  597.   char input;\line

  598.   RtAudio *audio;\line

  599. \line

  600.   // Open a stream during RtAudio instantiation\line

  601.   try \{\line

  602.     audio = new RtAudio(&stream, device, channels, device, channels, RtAudio::RTAUDIO_FLOAT64,\line

  603.                         sample_rate, &buffer_size, n_buffers);\line

  604.   \}\line

  605.   catch (RtAudioError &error) \{\line

  606.     error.printMessage();\line

  607.     exit(EXIT_FAILURE);\line

  608.   \}\line

  609. \line

  610.   try \{\line

  611.     // Set the stream callback function\line

  612.     audio->setStreamCallback(stream, &pass, NULL);\line

  613. \line

  614.     // Start the stream\line

  615.     audio->startStream(stream);\line

  616.   \}\line

  617.   catch (RtAudioError &error) \{\line

  618.     error.printMessage();\line

  619.     goto cleanup;\line

  620.   \}\line

  621. \line

  622.   cout << "\\nRunning duplex ... press <enter> to quit.\\n";\line

  623.   cin.get(input);\line

  624. \line

  625.   try \{\line

  626.     // Stop and close the stream\line

  627.     audio->stopStream(stream);\line

  628.     audio->closeStream(stream);\line

  629.   \}\line

  630.   catch (RtAudioError &error) \{\line

  631.     error.printMessage();\line

  632.   \}\line

  633. \line

  634.  cleanup:\line

  635.   delete audio;\line

  636. \line

  637.   return 0;\line

  638. \}\par

  639. }

  640. When an {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) stream is running in duplex mode (nonzero input {\i AND} output channels), the audio write (playback) operation always occurs before the audio read (record) operation. This sequence allows the use of a single buffer to store both output and input data.\par

  641. As we see with this example, the write-read sequence of operations does not preclude the use of {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) in situations where input data is first processed and then output through a duplex stream. When the stream buffer is first allocated, it is initialized with zeros, which produces no audible result when output to the device. In this example, anything recorded by the audio stream input will be played out during the next round of audio processing.\par

  642. Note that duplex operation can also be achieved by opening one output stream and one input stream using the same or different devices. However, there may be timing problems when attempting to use two different devices, due to possible device clock variations. This becomes even more difficult to achieve using two separate callback streams because it is not possible to explicitly control the calling order of the callback functions.\par

  643. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Summary of Methods}

  644. Summary of Methods\par

  645. {\bkmkstart methods}

  646. {\bkmkend methods}

  647. }\par

  648. The following is short summary of public methods (not including constructors and the destructor) provided by {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}):\par

  649. { \par

  650. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  651. {\b RtAudio::openStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a3 \\*MERGEFORMAT}{\fldrslt pagenum}}}): opens a stream with the specified parameters. \par

  652. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  653. {\b RtAudio::setStreamCallback}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a4 \\*MERGEFORMAT}{\fldrslt pagenum}}}): sets a user-defined callback function for a given stream. \par

  654. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  655. {\b RtAudio::cancelStreamCallback}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a5 \\*MERGEFORMAT}{\fldrslt pagenum}}}): cancels a callback process and function for a given stream. \par

  656. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  657. {\b RtAudio::getDeviceCount}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a6 \\*MERGEFORMAT}{\fldrslt pagenum}}}): returns the number of audio devices available. \par

  658. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  659. {\b RtAudio::getDeviceInfo}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a7 \\*MERGEFORMAT}{\fldrslt pagenum}}}): fills a user-supplied RTAUDIO_DEVICE structure for a specified device. \par

  660. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  661. {\b RtAudio::getStreamBuffer}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a8 \\*MERGEFORMAT}{\fldrslt pagenum}}}): returns a pointer to the stream buffer. \par

  662. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  663. {\b RtAudio::tickStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a9 \\*MERGEFORMAT}{\fldrslt pagenum}}}): triggers processing of input/output data for a stream (blocking). \par

  664. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  665. {\b RtAudio::closeStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a10 \\*MERGEFORMAT}{\fldrslt pagenum}}}): closes the specified stream (implicitly called during object destruction). Once a stream is closed, the stream identifier is invalid and should not be used in calling any other {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) methods. \par

  666. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  667. {\b RtAudio::startStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a11 \\*MERGEFORMAT}{\fldrslt pagenum}}}): (re)starts the specified stream, typically after it has been stopped with either stopStream() or abortStream() or after first opening the stream. \par

  668. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  669. {\b RtAudio::stopStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a12 \\*MERGEFORMAT}{\fldrslt pagenum}}}): stops the specified stream, allowing any remaining samples in the queue to be played out and/or read in. This does not implicitly call {\b RtAudio::closeStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a10 \\*MERGEFORMAT}{\fldrslt pagenum}}}). \par

  670. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  671. {\b RtAudio::abortStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a13 \\*MERGEFORMAT}{\fldrslt pagenum}}}): stops the specified stream, discarding any remaining samples in the queue. This does not implicitly call closeStream(). \par

  672. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  673. {\b RtAudio::streamWillBlock}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a14 \\*MERGEFORMAT}{\fldrslt pagenum}}}): queries a stream to determine whether a call to the {\i tickStream()} method will block. A return value of 0 indicates that the stream will NOT block. A positive return value indicates the number of sample frames that cannot yet be processed without blocking. \par

  674. }{\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Compiling}

  675. Compiling\par

  676. {\bkmkstart compiling}

  677. {\bkmkend compiling}

  678. }\par

  679. In order to compile {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) for a specific OS and audio API, it is necessary to supply the appropriate preprocessor definition and library within the compiler statement: \par

  680. \par

  681.   {\b OS:} {\b Audio API:} {\b Preprocessor Definition:} {\b Library:} {\b Example Compiler Statement:}   Linux ALSA __LINUX_ALSA_ {\f2 libasound, libpthread} {\f2 g++ -Wall -D__LINUX_ALSA_ -o probe probe.cpp RtAudio.cpp -lasound -lpthread}   Linux OSS __LINUX_OSS_ {\f2 libpthread} {\f2 g++ -Wall -D__LINUX_OSS_ -o probe probe.cpp RtAudio.cpp -lpthread}   Irix AL __IRIX_AL_ {\f2 libaudio, libpthread} {\f2 CC -Wall -D__IRIX_AL_ -o probe probe.cpp RtAudio.cpp -laudio -lpthread}   Windows Direct Sound __WINDOWS_DS_ {\f2 dsound.lib (ver. 5.0 or higher), multithreaded} {\i compiler specific}   \par

  682. \par

  683. The example compiler statements above could be used to compile the {\f2 probe.cpp} example file, assuming that {\f2 probe.cpp}, {\f2 {\b RtAudio.h}}, and {\f2 RtAudio.cpp} all exist in the same directory.\par

  684. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v OS Notes}

  685. OS Notes\par

  686. {\bkmkstart osnotes}

  687. {\bkmkend osnotes}

  688. }\par

  689. {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) is designed to provide a common API across the various supported operating systems and audio libraries. Despite that, however, some issues need to be mentioned with regard to each.\par

  690. {\pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid {\tc\tcl3 \v Linux:}

  691. Linux:\par

  692. {\bkmkstart linux}

  693. {\bkmkend linux}

  694. }\par

  695. {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) for Linux was developed under Redhat distributions 7.0 - 7.2. Two different audio APIs are supported on Linux platforms: OSS and {\f2 ALSA}. The OSS API has existed for at least 6 years and the Linux kernel is distributed with free versions of OSS audio drivers. Therefore, a generic Linux system is most likely to have OSS support. The ALSA API is relatively new and at this time is not part of the Linux kernel distribution. Work is in progress to make ALSA part of the 2.5 development kernel series. Despite that, the ALSA API offers significantly better functionality than the OSS API. {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) provides support for the 0.9 and higher versions of ALSA. Input/output latency on the order of 15-20 milliseconds can typically be achieved under both OSS or ALSA by fine-tuning the {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) buffer parameters (without kernel modifications). Latencies on the order of 5 milliseconds or less can be achieved using a low-latency kernel patch and increasing FIFO scheduling priority. The pthread library, which is used for callback functionality, is a standard component of all Linux distributions.\par

  696. The ALSA library includes OSS emulation support. That means that you can run programs compiled for the OSS API even when using the ALSA drivers and library. It should be noted however that OSS emulation under ALSA is not perfect. Specifically, channel number queries seem to consistently produce invalid results. While OSS emulation is successful for the majority of {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) tests, it is recommended that the native ALSA implementation of {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) be used on systems which have ALSA drivers installed.\par

  697. The ALSA implementation of {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) makes no use of the ALSA "plug" interface. All necessary data format conversions, channel compensation, deinterleaving, and byte-swapping is handled by internal {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) routines.\par

  698. {\pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid {\tc\tcl3 \v Irix (SGI):}

  699. Irix (SGI):\par

  700. {\bkmkstart irix}

  701. {\bkmkend irix}

  702. }\par

  703. The Irix version of {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) was written and tested on an SGI Indy running Irix version 6.5 and the newer "al" audio library. {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) does not compile under Irix version 6.3 because the C++ compiler is too old. Despite the relatively slow speed of the Indy, {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) was found to behave quite well and input/output latency was very good. No problems were found with respect to using the pthread library.\par

  704. {\pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid {\tc\tcl3 \v Windows:}

  705. Windows:\par

  706. {\bkmkstart windows}

  707. {\bkmkend windows}

  708. }\par

  709. {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) under Windows is written using the DirectSound API. In order to compile {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) under Windows, you must have the header and source files for DirectSound version 0.5 or higher. As far as I know, you cannot compile {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) for Windows NT because there is not sufficient DirectSound support. Audio output latency with DirectSound can be reasonably good (on the order of 20 milliseconds). On the other hand, input audio latency tends to be terrible (100 milliseconds or more). Further, DirectSound drivers tend to crash easily when experimenting with buffer parameters. On my system, I found it necessary to use values around nBuffers = 8 and bufferSize = 512 to avoid crashing my system. {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) was developed with Visual C++ version 6.0. I was forced in several instances to modify code in order to get it to compile under the non-standard version of C++ that Microsoft so unprofessionally implemented. We can only hope that the developers of Visual C++ 7.0 will have time to read the C++ standard.\par

  710. {\pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid {\tc\tcl2 \v Acknowledgments}

  711. Acknowledgments\par

  712. {\bkmkstart acknowledge}

  713. {\bkmkend acknowledge}

  714. }\par

  715. The {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) API incorporates many of the concepts developed in the {\f2 PortAudio} project by Phil Burk and Ross Bencina. Early development also incorporated ideas from Bill Schottstaedt's {\f2 sndlib}. The CCRMA {\f2 SoundWire group} provided valuable feedback during the API proposal stages.\par

  716. {\b RtAudio} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}}) was slowly developed over the course of many months while in residence at the {\f2 Institut Universitari de L'Audiovisual (IUA)} in Barcelona, Spain, the {\f2 Laboratory of Acoustics and Audio Signal Processing} at the Helsinki University of Technology, Finland, and the {\f2 Center for Computer Research in Music and Acoustics (CCRMA)} at {\f2 Stanford University}. This work was supported in part by the United States Air Force Office of Scientific Research (grant #F49620-99-1-0293).\par

  717. These documentation files were generated using {\f2 doxygen} by Dimitri van Heesch.\par

  718. \par

  719. }

  720. 

  721. \pard\plain \sect\sbkpage

  722. \s1\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs36\kerning36\cgrid 

  723. RtAudio Compound Index\par \pard\plain 

  724. {\tc \v Compound Index}

  725. \pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid 

  726. RtAudio Compound List\par \pard\plain 

  727. {

  728. \pard\plain \s17\sa60\sb30\widctlpar\qj \fs22\cgrid Here are the classes, structs, unions and interfaces with brief descriptions:\par

  729. }

  730. {

  731. \pard\plain \s71\li360\sa27\sb27\widctlpar\tqr\tldot\tx8640\adjustright \fs20\cgrid 

  732. {\b RtAudio} \tab {\field\fldedit {\*\fldinst PAGEREF classRtAudio \\*MERGEFORMAT}{\fldrslt pagenum}}

  733. \par

  734. {\b RtAudio::RTAUDIO_DEVICE} \tab {\field\fldedit {\*\fldinst PAGEREF structRtAudio_1_1RTAUDIO__DEVICE \\*MERGEFORMAT}{\fldrslt pagenum}}

  735. \par

  736. {\b RtAudioError} \tab {\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}

  737. \par

  738. \par

  739. }

  740. \pard\plain \sect\sbkpage

  741. \s1\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs36\kerning36\cgrid 

  742. RtAudio File Index\par \pard\plain 

  743. {\tc \v File Index}

  744. \pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid 

  745. RtAudio File List\par \pard\plain 

  746. {

  747. \pard\plain \s17\sa60\sb30\widctlpar\qj \fs22\cgrid Here is a list of all files with brief descriptions:\par

  748. }

  749. {

  750. \pard\plain \s71\li360\sa27\sb27\widctlpar\tqr\tldot\tx8640\adjustright \fs20\cgrid 

  751. {\b RtAudio.h} \tab {\field\fldedit {\*\fldinst PAGEREF RtAudio_8h \\*MERGEFORMAT}{\fldrslt pagenum}}

  752. \par

  753. \par

  754. }\sect \sbkpage \pgnrestart

  755. \sect \sectd \sbknone \pgndec

  756. {\footer \s29\widctlpar\tqc\tx4320\tqr\tx8640\qr\adjustright \fs20\cgrid {\chpgn}}

  757. 

  758. \pard\plain \sect\sbkpage

  759. \s1\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs36\kerning36\cgrid 

  760. RtAudio Class Documentation{\tc \v Class Documentation}

  761. \par \pard\plain 

  762. \pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid 

  763. RtAudio  Class Reference\par \pard\plain 

  764. {\tc\tcl2 \v RtAudio}

  765. {\xe \v RtAudio}

  766. {\bkmkstart classRtAudio}

  767. {\bkmkend }

  768. {

  769. \pard\plain \s17\sa60\sb30\widctlpar\qj \fs22\cgrid {\f2 #include <RtAudio.h>}\par

  770. \par

  771. }

  772. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  773. Public Types\par

  774. \pard\plain 

  775. 

  776. {

  777. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  778. typedef unsigned long {\b RTAUDIO_FORMAT}\par

  779. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  780. typedef int (* {\b RTAUDIO_CALLBACK} )(char *buffer, int bufferSize, void *userData)\par

  781. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  782. enum \{ {\b MAX_SAMPLE_RATES} =  14 

  783.  \}\par

  784. }

  785. \par

  786. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  787. Public Methods\par

  788. \pard\plain 

  789. 

  790. {

  791. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  792. {\b RtAudio} ()\par

  793. {

  794. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i The default constructor.}\par

  795. \par}

  796. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  797. {\b RtAudio} (int *streamID, int outputDevice, int outputChannels, int inputDevice, int inputChannels, {\b RTAUDIO_FORMAT} format, int sampleRate, int *bufferSize, int numberOfBuffers)\par

  798. {

  799. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i A constructor which can be used to open a stream during instantiation.}\par

  800. \par}

  801. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  802. {\b ~RtAudio} ()\par

  803. {

  804. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i The destructor.}\par

  805. \par}

  806. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  807. int {\b openStream} (int outputDevice, int outputChannels, int inputDevice, int inputChannels, {\b RTAUDIO_FORMAT} format, int sampleRate, int *bufferSize, int numberOfBuffers)\par

  808. {

  809. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i A public method for opening a stream with the specified parameters.}\par

  810. \par}

  811. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  812. void {\b setStreamCallback} (int streamID, {\b RTAUDIO_CALLBACK} callback, void *userData)\par

  813. {

  814. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i A public method which sets a user-defined callback function for a given stream.}\par

  815. \par}

  816. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  817. void {\b cancelStreamCallback} (int streamID)\par

  818. {

  819. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i A public method which cancels a callback process and function for a given stream.}\par

  820. \par}

  821. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  822. int {\b getDeviceCount} (void)\par

  823. {

  824. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i A public method which returns the number of audio devices found.}\par

  825. \par}

  826. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  827. void {\b getDeviceInfo} (int device, {\b RTAUDIO_DEVICE} *info)\par

  828. {

  829. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i Fill a user-supplied {\b RTAUDIO_DEVICE} ({\i p.{\field\fldedit {\*\fldinst PAGEREF structRtAudio_1_1RTAUDIO__DEVICE \\*MERGEFORMAT}{\fldrslt pagenum}}}) structure for a specified device.}\par

  830. \par}

  831. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  832. char* const {\b getStreamBuffer} (int streamID)\par

  833. {

  834. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i A public method which returns a pointer to the buffer for an open stream.}\par

  835. \par}

  836. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  837. void {\b tickStream} (int streamID)\par

  838. {

  839. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i Public method used to trigger processing of input/output data for a stream.}\par

  840. \par}

  841. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  842. void {\b closeStream} (int streamID)\par

  843. {

  844. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i Public method which closes a stream and frees any associated buffers.}\par

  845. \par}

  846. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  847. void {\b startStream} (int streamID)\par

  848. {

  849. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i Public method which starts a stream.}\par

  850. \par}

  851. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  852. void {\b stopStream} (int streamID)\par

  853. {

  854. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i Stop a stream, allowing any samples remaining in the queue to be played out and/or read in.}\par

  855. \par}

  856. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  857. void {\b abortStream} (int streamID)\par

  858. {

  859. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i Stop a stream, discarding any samples remaining in the input/output queue.}\par

  860. \par}

  861. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  862. int {\b streamWillBlock} (int streamID)\par

  863. {

  864. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i Queries a stream to determine whether a call to the {\b tickStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a9 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method will block.}\par

  865. \par}

  866. }

  867. \par

  868. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  869. Static Public Attributes\par

  870. \pard\plain 

  871. 

  872. {

  873. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  874. const {\b RTAUDIO_FORMAT} {\b RTAUDIO_SINT8}\par

  875. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  876. const {\b RTAUDIO_FORMAT} {\b RTAUDIO_SINT16}\par

  877. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  878. const {\b RTAUDIO_FORMAT} {\b RTAUDIO_SINT24}\par

  879. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  880. const {\b RTAUDIO_FORMAT} {\b RTAUDIO_SINT32}\par

  881. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  882. const {\b RTAUDIO_FORMAT} {\b RTAUDIO_FLOAT32}\par

  883. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  884. const {\b RTAUDIO_FORMAT} {\b RTAUDIO_FLOAT64}\par

  885. }

  886. {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  887. \par

  888. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  889. Member Typedef Documentation\par

  890. \pard\plain 

  891. {\xe \v RTAUDIO_FORMAT\:RtAudio}

  892. {\xe \v RtAudio\:RTAUDIO_FORMAT}

  893. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  894. {\b 

  895. typedef unsigned long RtAudio::RTAUDIO_FORMAT}

  896. }\par

  897. {\bkmkstart classRtAudio_s0}

  898. {\bkmkend classRtAudio_s0}

  899. {

  900. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  901. }

  902. {\xe \v RTAUDIO_CALLBACK\:RtAudio}

  903. {\xe \v RtAudio\:RTAUDIO_CALLBACK}

  904. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  905. {\b 

  906. typedef int(* RtAudio::RTAUDIO_CALLBACK)(char *buffer, int bufferSize, void *userData)}

  907. }\par

  908. {\bkmkstart classRtAudio_s1}

  909. {\bkmkend classRtAudio_s1}

  910. {

  911. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  912. }

  913. {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  914. \par

  915. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  916. Member Enumeration Documentation\par

  917. \pard\plain 

  918. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  919. {\b 

  920. anonymous enum}

  921. }\par

  922. {\bkmkstart classRtAudio_s3}

  923. {\bkmkend classRtAudio_s3}

  924. {

  925. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  926. {\par

  927. {\b Enumeration values:}\par

  928. \pard\plain \s62\li720\widctlpar\ql\adjustright \fs20\cgrid {

  929. {\xe \v MAX_SAMPLE_RATES\:RtAudio}

  930. {\xe \v RtAudio\:MAX_SAMPLE_RATES}

  931. {\b {\i MAX_SAMPLE_RATES}{\bkmkstart classRtAudio_s3s2}

  932. {\bkmkend classRtAudio_s3s2}

  933. }  \par

  934. }

  935. \par

  936. }

  937. }

  938. {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  939. \par

  940. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  941. Constructor & Destructor Documentation\par

  942. \pard\plain 

  943. {\xe \v RtAudio\:RtAudio}

  944. {\xe \v RtAudio\:RtAudio}

  945. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  946. {\b 

  947. RtAudio::RtAudio ()}

  948. }\par

  949. {\bkmkstart classRtAudio_a0}

  950. {\bkmkend classRtAudio_a0}

  951. {

  952. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  953. The default constructor.\par

  954. Probes the system to make sure at least one audio input/output device is available and determines the api-specific identifier for each device found. An {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) error can be thrown if no devices are found or if a memory allocation error occurs. \par

  955. }

  956. {\xe \v RtAudio\:RtAudio}

  957. {\xe \v RtAudio\:RtAudio}

  958. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  959. {\b 

  960. RtAudio::RtAudio (int * {\i streamID}, int {\i outputDevice}, int {\i outputChannels}, int {\i inputDevice}, int {\i inputChannels}, {\b RTAUDIO_FORMAT} {\i format}, int {\i sampleRate}, int * {\i bufferSize}, int {\i numberOfBuffers})}

  961. }\par

  962. {\bkmkstart classRtAudio_a1}

  963. {\bkmkend classRtAudio_a1}

  964. {

  965. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  966. A constructor which can be used to open a stream during instantiation.\par

  967. The specified output and/or input device identifiers correspond to those enumerated via the {\b getDeviceInfo}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a7 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method. If device = 0, the default or first available devices meeting the given parameters is selected. If an output or input channel value is zero, the corresponding device value is ignored. When a stream is successfully opened, its identifier is returned via the "streamID" pointer. An {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) can be thrown if no devices are found for the given parameters, if a memory allocation error occurs, or if a driver error occurs. {\par

  968. {\b See also: }\par

  969. \pard\plain \s62\li720\widctlpar\ql\adjustright \fs20\cgrid {\b openStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a3 \\*MERGEFORMAT}{\fldrslt pagenum}}}) \par

  970. }}

  971. {\xe \v ~RtAudio\:RtAudio}

  972. {\xe \v RtAudio\:~RtAudio}

  973. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  974. {\b 

  975. RtAudio::~RtAudio ()}

  976. }\par

  977. {\bkmkstart classRtAudio_a2}

  978. {\bkmkend classRtAudio_a2}

  979. {

  980. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  981. The destructor.\par

  982. Stops and closes any open streams and devices and deallocates buffer and structure memory. \par

  983. }

  984. {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  985. \par

  986. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  987. Member Function Documentation\par

  988. \pard\plain 

  989. {\xe \v openStream\:RtAudio}

  990. {\xe \v RtAudio\:openStream}

  991. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  992. {\b 

  993. int RtAudio::openStream (int {\i outputDevice}, int {\i outputChannels}, int {\i inputDevice}, int {\i inputChannels}, {\b RTAUDIO_FORMAT} {\i format}, int {\i sampleRate}, int * {\i bufferSize}, int {\i numberOfBuffers})}

  994. }\par

  995. {\bkmkstart classRtAudio_a3}

  996. {\bkmkend classRtAudio_a3}

  997. {

  998. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  999. A public method for opening a stream with the specified parameters.\par

  1000. If successful, the opened stream ID is returned. Otherwise, an {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) is thrown.{\par

  1001. {\b Parameters: }\par

  1002. \pard\plain \s62\li720\widctlpar\ql\adjustright \fs20\cgrid {

  1003. {\b {\i outputDevice:}}  If equal to 0, the default or first device found meeting the given parameters is opened. Otherwise, the device number should correspond to one of those enumerated via the {\b getDeviceInfo}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a7 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method. \par

  1004. {\b {\i outputChannels:}}  The desired number of output channels. If equal to zero, the outputDevice identifier is ignored. \par

  1005. {\b {\i inputDevice:}}  If equal to 0, the default or first device found meeting the given parameters is opened. Otherwise, the device number should correspond to one of those enumerated via the {\b getDeviceInfo}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a7 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method. \par

  1006. {\b {\i inputChannels:}}  The desired number of input channels. If equal to zero, the inputDevice identifier is ignored. \par

  1007. {\b {\i format:}}  An RTAUDIO_FORMAT specifying the desired sample data format. \par

  1008. {\b {\i sampleRate:}}  The desired sample rate (sample frames per second). \par

  1009. {\b {\i bufferSize:}}  A pointer value indicating the desired internal buffer size in sample frames. The actual value used by the device is returned via the same pointer. A value of zero can be specified, in which case the lowest allowable value is determined. \par

  1010. {\b {\i numberOfBuffers:}}  A value which can be used to help control device latency. More buffers typically result in more robust performance, though at a cost of greater latency. A value of zero can be specified, in which case the lowest allowable value is used. \par

  1011. }

  1012. \par

  1013. }}

  1014. {\xe \v setStreamCallback\:RtAudio}

  1015. {\xe \v RtAudio\:setStreamCallback}

  1016. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1017. {\b 

  1018. void RtAudio::setStreamCallback (int {\i streamID}, {\b RTAUDIO_CALLBACK} {\i callback}, void * {\i userData})}

  1019. }\par

  1020. {\bkmkstart classRtAudio_a4}

  1021. {\bkmkend classRtAudio_a4}

  1022. {

  1023. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1024. A public method which sets a user-defined callback function for a given stream.\par

  1025. This method assigns a callback function to a specific, previously opened stream for non-blocking stream functionality. A separate process is initiated, though the user function is called only when the stream is "running" (between calls to the {\b startStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a11 \\*MERGEFORMAT}{\fldrslt pagenum}}}) and {\b stopStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a12 \\*MERGEFORMAT}{\fldrslt pagenum}}}) methods, respectively). The callback process remains active for the duration of the stream and is automatically shutdown when the stream is closed (via the {\b closeStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a10 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method or by object destruction). The callback process can also be shutdown and the user function de-referenced through an explicit call to the {\b cancelStreamCallback}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a5 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method. Note that a single stream can use only blocking or callback functionality at the same time, though it is possible to alternate modes on the same stream through the use of the {\b setStreamCallback}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a4 \\*MERGEFORMAT}{\fldrslt pagenum}}}) and {\b cancelStreamCallback}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a5 \\*MERGEFORMAT}{\fldrslt pagenum}}}) methods (the blocking {\b tickStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a9 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method can be used before a callback is set and/or after a callback is cancelled). An {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) will be thrown for an invalid device argument. \par

  1026. }

  1027. {\xe \v cancelStreamCallback\:RtAudio}

  1028. {\xe \v RtAudio\:cancelStreamCallback}

  1029. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1030. {\b 

  1031. void RtAudio::cancelStreamCallback (int {\i streamID})}

  1032. }\par

  1033. {\bkmkstart classRtAudio_a5}

  1034. {\bkmkend classRtAudio_a5}

  1035. {

  1036. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1037. A public method which cancels a callback process and function for a given stream.\par

  1038. This method shuts down a callback process and de-references the user function for a specific stream. Callback functionality can subsequently be restarted on the stream via the {\b setStreamCallback}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a4 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method. An {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) will be thrown for an invalid device argument. \par

  1039. }

  1040. {\xe \v getDeviceCount\:RtAudio}

  1041. {\xe \v RtAudio\:getDeviceCount}

  1042. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1043. {\b 

  1044. int RtAudio::getDeviceCount (void)}

  1045. }\par

  1046. {\bkmkstart classRtAudio_a6}

  1047. {\bkmkend classRtAudio_a6}

  1048. {

  1049. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1050. A public method which returns the number of audio devices found.\par

  1051. }

  1052. {\xe \v getDeviceInfo\:RtAudio}

  1053. {\xe \v RtAudio\:getDeviceInfo}

  1054. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1055. {\b 

  1056. void RtAudio::getDeviceInfo (int {\i device}, {\b RTAUDIO_DEVICE} * {\i info})}

  1057. }\par

  1058. {\bkmkstart classRtAudio_a7}

  1059. {\bkmkend classRtAudio_a7}

  1060. {

  1061. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1062. Fill a user-supplied {\b RTAUDIO_DEVICE} ({\i p.{\field\fldedit {\*\fldinst PAGEREF structRtAudio_1_1RTAUDIO__DEVICE \\*MERGEFORMAT}{\fldrslt pagenum}}}) structure for a specified device.\par

  1063. Any device between 0 and {\b getDeviceCount}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a6 \\*MERGEFORMAT}{\fldrslt pagenum}}})-1 is valid. If a device is busy or otherwise unavailable, the structure member "probed" has a value of "false". The system default input and output devices are referenced by device identifier = 0. On systems which allow dynamic default device settings, the default devices are not identified by name (specific device enumerations are assigned device identifiers > 0). An {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) will be thrown for an invalid device argument. \par

  1064. }

  1065. {\xe \v getStreamBuffer\:RtAudio}

  1066. {\xe \v RtAudio\:getStreamBuffer}

  1067. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1068. {\b 

  1069. char *const RtAudio::getStreamBuffer (int {\i streamID})}

  1070. }\par

  1071. {\bkmkstart classRtAudio_a8}

  1072. {\bkmkend classRtAudio_a8}

  1073. {

  1074. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1075. A public method which returns a pointer to the buffer for an open stream.\par

  1076. The user should fill and/or read the buffer data in interleaved format and then call the {\b tickStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a9 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method. An {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) will be thrown for an invalid stream identifier. \par

  1077. }

  1078. {\xe \v tickStream\:RtAudio}

  1079. {\xe \v RtAudio\:tickStream}

  1080. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1081. {\b 

  1082. void RtAudio::tickStream (int {\i streamID})}

  1083. }\par

  1084. {\bkmkstart classRtAudio_a9}

  1085. {\bkmkend classRtAudio_a9}

  1086. {

  1087. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1088. Public method used to trigger processing of input/output data for a stream.\par

  1089. This method blocks until all buffer data is read/written. An {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) will be thrown for an invalid stream identifier or if a driver error occurs. \par

  1090. }

  1091. {\xe \v closeStream\:RtAudio}

  1092. {\xe \v RtAudio\:closeStream}

  1093. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1094. {\b 

  1095. void RtAudio::closeStream (int {\i streamID})}

  1096. }\par

  1097. {\bkmkstart classRtAudio_a10}

  1098. {\bkmkend classRtAudio_a10}

  1099. {

  1100. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1101. Public method which closes a stream and frees any associated buffers.\par

  1102. If an invalid stream identifier is specified, this method issues a warning and returns (an {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) is not thrown). \par

  1103. }

  1104. {\xe \v startStream\:RtAudio}

  1105. {\xe \v RtAudio\:startStream}

  1106. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1107. {\b 

  1108. void RtAudio::startStream (int {\i streamID})}

  1109. }\par

  1110. {\bkmkstart classRtAudio_a11}

  1111. {\bkmkend classRtAudio_a11}

  1112. {

  1113. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1114. Public method which starts a stream.\par

  1115. An {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) will be thrown for an invalid stream identifier or if a driver error occurs. \par

  1116. }

  1117. {\xe \v stopStream\:RtAudio}

  1118. {\xe \v RtAudio\:stopStream}

  1119. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1120. {\b 

  1121. void RtAudio::stopStream (int {\i streamID})}

  1122. }\par

  1123. {\bkmkstart classRtAudio_a12}

  1124. {\bkmkend classRtAudio_a12}

  1125. {

  1126. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1127. Stop a stream, allowing any samples remaining in the queue to be played out and/or read in.\par

  1128. An {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) will be thrown for an invalid stream identifier or if a driver error occurs. \par

  1129. }

  1130. {\xe \v abortStream\:RtAudio}

  1131. {\xe \v RtAudio\:abortStream}

  1132. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1133. {\b 

  1134. void RtAudio::abortStream (int {\i streamID})}

  1135. }\par

  1136. {\bkmkstart classRtAudio_a13}

  1137. {\bkmkend classRtAudio_a13}

  1138. {

  1139. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1140. Stop a stream, discarding any samples remaining in the input/output queue.\par

  1141. An {\b RtAudioError} ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudioError \\*MERGEFORMAT}{\fldrslt pagenum}}}) will be thrown for an invalid stream identifier or if a driver error occurs. \par

  1142. }

  1143. {\xe \v streamWillBlock\:RtAudio}

  1144. {\xe \v RtAudio\:streamWillBlock}

  1145. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1146. {\b 

  1147. int RtAudio::streamWillBlock (int {\i streamID})}

  1148. }\par

  1149. {\bkmkstart classRtAudio_a14}

  1150. {\bkmkend classRtAudio_a14}

  1151. {

  1152. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1153. Queries a stream to determine whether a call to the {\b tickStream}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a9 \\*MERGEFORMAT}{\fldrslt pagenum}}}) method will block.\par

  1154. A return value of 0 indicates that the stream will NOT block. A positive return value indicates the number of sample frames that cannot yet be processed without blocking. \par

  1155. }

  1156. {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  1157. \par

  1158. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1159. Member Data Documentation\par

  1160. \pard\plain 

  1161. {\xe \v RTAUDIO_SINT8\:RtAudio}

  1162. {\xe \v RtAudio\:RTAUDIO_SINT8}

  1163. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1164. {\b 

  1165. const {\b RTAUDIO_FORMAT} RtAudio::RTAUDIO_SINT8{\f2  [static]}}

  1166. }\par

  1167. {\bkmkstart classRtAudio_p0}

  1168. {\bkmkend classRtAudio_p0}

  1169. {

  1170. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1171. }

  1172. {\xe \v RTAUDIO_SINT16\:RtAudio}

  1173. {\xe \v RtAudio\:RTAUDIO_SINT16}

  1174. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1175. {\b 

  1176. const {\b RTAUDIO_FORMAT} RtAudio::RTAUDIO_SINT16{\f2  [static]}}

  1177. }\par

  1178. {\bkmkstart classRtAudio_p1}

  1179. {\bkmkend classRtAudio_p1}

  1180. {

  1181. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1182. }

  1183. {\xe \v RTAUDIO_SINT24\:RtAudio}

  1184. {\xe \v RtAudio\:RTAUDIO_SINT24}

  1185. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1186. {\b 

  1187. const {\b RTAUDIO_FORMAT} RtAudio::RTAUDIO_SINT24{\f2  [static]}}

  1188. }\par

  1189. {\bkmkstart classRtAudio_p2}

  1190. {\bkmkend classRtAudio_p2}

  1191. {

  1192. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1193. Upper 3 bytes of 32-bit integer. \par

  1194. }

  1195. {\xe \v RTAUDIO_SINT32\:RtAudio}

  1196. {\xe \v RtAudio\:RTAUDIO_SINT32}

  1197. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1198. {\b 

  1199. const {\b RTAUDIO_FORMAT} RtAudio::RTAUDIO_SINT32{\f2  [static]}}

  1200. }\par

  1201. {\bkmkstart classRtAudio_p3}

  1202. {\bkmkend classRtAudio_p3}

  1203. {

  1204. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1205. }

  1206. {\xe \v RTAUDIO_FLOAT32\:RtAudio}

  1207. {\xe \v RtAudio\:RTAUDIO_FLOAT32}

  1208. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1209. {\b 

  1210. const {\b RTAUDIO_FORMAT} RtAudio::RTAUDIO_FLOAT32{\f2  [static]}}

  1211. }\par

  1212. {\bkmkstart classRtAudio_p4}

  1213. {\bkmkend classRtAudio_p4}

  1214. {

  1215. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1216. Normalized between plus/minus 1.0. \par

  1217. }

  1218. {\xe \v RTAUDIO_FLOAT64\:RtAudio}

  1219. {\xe \v RtAudio\:RTAUDIO_FLOAT64}

  1220. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1221. {\b 

  1222. const {\b RTAUDIO_FORMAT} RtAudio::RTAUDIO_FLOAT64{\f2  [static]}}

  1223. }\par

  1224. {\bkmkstart classRtAudio_p5}

  1225. {\bkmkend classRtAudio_p5}

  1226. {

  1227. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1228. Normalized between plus/minus 1.0. \par

  1229. }

  1230. {

  1231. \pard\plain \s17\sa60\sb30\widctlpar\qj \fs22\cgrid {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  1232. The documentation for this class was generated from the following file:{\par

  1233. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  1234. {\b RtAudio.h}\par

  1235. }}

  1236. \par \pard\plain 

  1237. 

  1238. \pard\plain \sect\sbkpage

  1239. \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid 

  1240. \pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid 

  1241. RtAudio::RTAUDIO_DEVICE  Struct Reference\par \pard\plain 

  1242. {\tc\tcl2 \v RtAudio::RTAUDIO_DEVICE}

  1243. {\xe \v RtAudio::RTAUDIO_DEVICE}

  1244. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE}

  1245. {\bkmkend }

  1246. {

  1247. \pard\plain \s17\sa60\sb30\widctlpar\qj \fs22\cgrid {\f2 #include <RtAudio.h>}\par

  1248. \par

  1249. }

  1250. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1251. Public Attributes\par

  1252. \pard\plain 

  1253. 

  1254. {

  1255. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1256. char {\b name} [128]\par

  1257. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1258. DEVICE_ID {\b id} [2]\par

  1259. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1260. bool {\b probed}\par

  1261. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1262. int {\b maxOutputChannels}\par

  1263. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1264. int {\b maxInputChannels}\par

  1265. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1266. int {\b maxDuplexChannels}\par

  1267. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1268. int {\b minOutputChannels}\par

  1269. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1270. int {\b minInputChannels}\par

  1271. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1272. int {\b minDuplexChannels}\par

  1273. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1274. bool {\b hasDuplexSupport}\par

  1275. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1276. int {\b nSampleRates}\par

  1277. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1278. int {\b sampleRates} [MAX_SAMPLE_RATES]\par

  1279. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1280. {\b RTAUDIO_FORMAT} {\b nativeFormats}\par

  1281. }

  1282. {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  1283. \par

  1284. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1285. Member Data Documentation\par

  1286. \pard\plain 

  1287. {\xe \v name\:RtAudio::RTAUDIO_DEVICE}

  1288. {\xe \v RtAudio::RTAUDIO_DEVICE\:name}

  1289. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1290. {\b 

  1291. char RtAudio::RTAUDIO_DEVICE::name}

  1292. }\par

  1293. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m0}

  1294. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m0}

  1295. {

  1296. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1297. }

  1298. {\xe \v id\:RtAudio::RTAUDIO_DEVICE}

  1299. {\xe \v RtAudio::RTAUDIO_DEVICE\:id}

  1300. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1301. {\b 

  1302. DEVICE_ID RtAudio::RTAUDIO_DEVICE::id}

  1303. }\par

  1304. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m1}

  1305. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m1}

  1306. {

  1307. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1308. No value reported by {\b getDeviceInfo}() ({\i p.{\field\fldedit {\*\fldinst PAGEREF classRtAudio_a7 \\*MERGEFORMAT}{\fldrslt pagenum}}}). \par

  1309. }

  1310. {\xe \v probed\:RtAudio::RTAUDIO_DEVICE}

  1311. {\xe \v RtAudio::RTAUDIO_DEVICE\:probed}

  1312. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1313. {\b 

  1314. bool RtAudio::RTAUDIO_DEVICE::probed}

  1315. }\par

  1316. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m2}

  1317. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m2}

  1318. {

  1319. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1320. true if the device capabilities were successfully probed. \par

  1321. }

  1322. {\xe \v maxOutputChannels\:RtAudio::RTAUDIO_DEVICE}

  1323. {\xe \v RtAudio::RTAUDIO_DEVICE\:maxOutputChannels}

  1324. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1325. {\b 

  1326. int RtAudio::RTAUDIO_DEVICE::maxOutputChannels}

  1327. }\par

  1328. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m3}

  1329. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m3}

  1330. {

  1331. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1332. }

  1333. {\xe \v maxInputChannels\:RtAudio::RTAUDIO_DEVICE}

  1334. {\xe \v RtAudio::RTAUDIO_DEVICE\:maxInputChannels}

  1335. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1336. {\b 

  1337. int RtAudio::RTAUDIO_DEVICE::maxInputChannels}

  1338. }\par

  1339. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m4}

  1340. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m4}

  1341. {

  1342. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1343. }

  1344. {\xe \v maxDuplexChannels\:RtAudio::RTAUDIO_DEVICE}

  1345. {\xe \v RtAudio::RTAUDIO_DEVICE\:maxDuplexChannels}

  1346. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1347. {\b 

  1348. int RtAudio::RTAUDIO_DEVICE::maxDuplexChannels}

  1349. }\par

  1350. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m5}

  1351. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m5}

  1352. {

  1353. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1354. }

  1355. {\xe \v minOutputChannels\:RtAudio::RTAUDIO_DEVICE}

  1356. {\xe \v RtAudio::RTAUDIO_DEVICE\:minOutputChannels}

  1357. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1358. {\b 

  1359. int RtAudio::RTAUDIO_DEVICE::minOutputChannels}

  1360. }\par

  1361. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m6}

  1362. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m6}

  1363. {

  1364. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1365. }

  1366. {\xe \v minInputChannels\:RtAudio::RTAUDIO_DEVICE}

  1367. {\xe \v RtAudio::RTAUDIO_DEVICE\:minInputChannels}

  1368. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1369. {\b 

  1370. int RtAudio::RTAUDIO_DEVICE::minInputChannels}

  1371. }\par

  1372. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m7}

  1373. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m7}

  1374. {

  1375. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1376. }

  1377. {\xe \v minDuplexChannels\:RtAudio::RTAUDIO_DEVICE}

  1378. {\xe \v RtAudio::RTAUDIO_DEVICE\:minDuplexChannels}

  1379. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1380. {\b 

  1381. int RtAudio::RTAUDIO_DEVICE::minDuplexChannels}

  1382. }\par

  1383. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m8}

  1384. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m8}

  1385. {

  1386. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1387. }

  1388. {\xe \v hasDuplexSupport\:RtAudio::RTAUDIO_DEVICE}

  1389. {\xe \v RtAudio::RTAUDIO_DEVICE\:hasDuplexSupport}

  1390. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1391. {\b 

  1392. bool RtAudio::RTAUDIO_DEVICE::hasDuplexSupport}

  1393. }\par

  1394. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m9}

  1395. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m9}

  1396. {

  1397. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1398. true if device supports duplex mode. \par

  1399. }

  1400. {\xe \v nSampleRates\:RtAudio::RTAUDIO_DEVICE}

  1401. {\xe \v RtAudio::RTAUDIO_DEVICE\:nSampleRates}

  1402. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1403. {\b 

  1404. int RtAudio::RTAUDIO_DEVICE::nSampleRates}

  1405. }\par

  1406. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m10}

  1407. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m10}

  1408. {

  1409. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1410. Number of discrete rates or -1 if range supported. \par

  1411. }

  1412. {\xe \v sampleRates\:RtAudio::RTAUDIO_DEVICE}

  1413. {\xe \v RtAudio::RTAUDIO_DEVICE\:sampleRates}

  1414. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1415. {\b 

  1416. int RtAudio::RTAUDIO_DEVICE::sampleRates}

  1417. }\par

  1418. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m11}

  1419. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m11}

  1420. {

  1421. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1422. Supported rates or (min, max) if range. \par

  1423. }

  1424. {\xe \v nativeFormats\:RtAudio::RTAUDIO_DEVICE}

  1425. {\xe \v RtAudio::RTAUDIO_DEVICE\:nativeFormats}

  1426. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1427. {\b 

  1428. {\b RTAUDIO_FORMAT} RtAudio::RTAUDIO_DEVICE::nativeFormats}

  1429. }\par

  1430. {\bkmkstart structRtAudio_1_1RTAUDIO__DEVICE_m12}

  1431. {\bkmkend structRtAudio_1_1RTAUDIO__DEVICE_m12}

  1432. {

  1433. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1434. Bit mask of supported data formats. \par

  1435. }

  1436. {

  1437. \pard\plain \s17\sa60\sb30\widctlpar\qj \fs22\cgrid {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  1438. The documentation for this struct was generated from the following file:{\par

  1439. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  1440. {\b RtAudio.h}\par

  1441. }}

  1442. \par \pard\plain 

  1443. 

  1444. \pard\plain \sect\sbkpage

  1445. \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid 

  1446. \pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid 

  1447. RtAudioError  Class Reference\par \pard\plain 

  1448. {\tc\tcl2 \v RtAudioError}

  1449. {\xe \v RtAudioError}

  1450. {\bkmkstart classRtAudioError}

  1451. {\bkmkend }

  1452. {

  1453. \pard\plain \s17\sa60\sb30\widctlpar\qj \fs22\cgrid {\f2 #include <RtAudio.h>}\par

  1454. \par

  1455. }

  1456. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1457. Public Types\par

  1458. \pard\plain 

  1459. 

  1460. {

  1461. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1462. enum {\b TYPE} \{ {\b WARNING}, 

  1463. {\b DEBUG_WARNING}, 

  1464. {\b UNSPECIFIED}, 

  1465. {\b NO_DEVICES_FOUND}, 

  1466. {\b INVALID_DEVICE}, 

  1467. {\b INVALID_STREAM}, 

  1468. {\b MEMORY_ERROR}, 

  1469. {\b INVALID_PARAMETER}, 

  1470. {\b DRIVER_ERROR}, 

  1471. {\b SYSTEM_ERROR}, 

  1472. {\b THREAD_ERROR}

  1473.  \}\par

  1474. }

  1475. \par

  1476. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1477. Public Methods\par

  1478. \pard\plain 

  1479. 

  1480. {

  1481. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1482. {\b RtAudioError} (const char *p, {\b TYPE} tipe=RtAudioError::UNSPECIFIED)\par

  1483. {

  1484. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i The constructor.}\par

  1485. \par}

  1486. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1487. virtual {\b ~RtAudioError} (void)\par

  1488. {

  1489. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i The destructor.}\par

  1490. \par}

  1491. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1492. virtual void {\b printMessage} (void)\par

  1493. {

  1494. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i Prints "thrown" error message to stdout.}\par

  1495. \par}

  1496. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1497. virtual const {\b TYPE}& {\b getType} (void)\par

  1498. {

  1499. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i Returns the "thrown" error message TYPE.}\par

  1500. \par}

  1501. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1502. virtual const char* {\b getMessage} (void)\par

  1503. {

  1504. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid {\i Returns the "thrown" error message string.}\par

  1505. \par}

  1506. }

  1507. \par

  1508. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1509. Protected Attributes\par

  1510. \pard\plain 

  1511. 

  1512. {

  1513. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1514. char {\b error_message} [256]\par

  1515. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1516. {\b TYPE} {\b type}\par

  1517. }

  1518. {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  1519. \par

  1520. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1521. Member Enumeration Documentation\par

  1522. \pard\plain 

  1523. {\xe \v TYPE\:RtAudioError}

  1524. {\xe \v RtAudioError\:TYPE}

  1525. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1526. {\b 

  1527. enum RtAudioError::TYPE}

  1528. }\par

  1529. {\bkmkstart classRtAudioError_s11}

  1530. {\bkmkend classRtAudioError_s11}

  1531. {

  1532. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1533. {\par

  1534. {\b Enumeration values:}\par

  1535. \pard\plain \s62\li720\widctlpar\ql\adjustright \fs20\cgrid {

  1536. {\xe \v WARNING\:RtAudioError}

  1537. {\xe \v RtAudioError\:WARNING}

  1538. {\b {\i WARNING}{\bkmkstart classRtAudioError_s11s0}

  1539. {\bkmkend classRtAudioError_s11s0}

  1540. }  \par

  1541. {\xe \v DEBUG_WARNING\:RtAudioError}

  1542. {\xe \v RtAudioError\:DEBUG_WARNING}

  1543. {\b {\i DEBUG_WARNING}{\bkmkstart classRtAudioError_s11s1}

  1544. {\bkmkend classRtAudioError_s11s1}

  1545. }  \par

  1546. {\xe \v UNSPECIFIED\:RtAudioError}

  1547. {\xe \v RtAudioError\:UNSPECIFIED}

  1548. {\b {\i UNSPECIFIED}{\bkmkstart classRtAudioError_s11s2}

  1549. {\bkmkend classRtAudioError_s11s2}

  1550. }  \par

  1551. {\xe \v NO_DEVICES_FOUND\:RtAudioError}

  1552. {\xe \v RtAudioError\:NO_DEVICES_FOUND}

  1553. {\b {\i NO_DEVICES_FOUND}{\bkmkstart classRtAudioError_s11s3}

  1554. {\bkmkend classRtAudioError_s11s3}

  1555. }  \par

  1556. {\xe \v INVALID_DEVICE\:RtAudioError}

  1557. {\xe \v RtAudioError\:INVALID_DEVICE}

  1558. {\b {\i INVALID_DEVICE}{\bkmkstart classRtAudioError_s11s4}

  1559. {\bkmkend classRtAudioError_s11s4}

  1560. }  \par

  1561. {\xe \v INVALID_STREAM\:RtAudioError}

  1562. {\xe \v RtAudioError\:INVALID_STREAM}

  1563. {\b {\i INVALID_STREAM}{\bkmkstart classRtAudioError_s11s5}

  1564. {\bkmkend classRtAudioError_s11s5}

  1565. }  \par

  1566. {\xe \v MEMORY_ERROR\:RtAudioError}

  1567. {\xe \v RtAudioError\:MEMORY_ERROR}

  1568. {\b {\i MEMORY_ERROR}{\bkmkstart classRtAudioError_s11s6}

  1569. {\bkmkend classRtAudioError_s11s6}

  1570. }  \par

  1571. {\xe \v INVALID_PARAMETER\:RtAudioError}

  1572. {\xe \v RtAudioError\:INVALID_PARAMETER}

  1573. {\b {\i INVALID_PARAMETER}{\bkmkstart classRtAudioError_s11s7}

  1574. {\bkmkend classRtAudioError_s11s7}

  1575. }  \par

  1576. {\xe \v DRIVER_ERROR\:RtAudioError}

  1577. {\xe \v RtAudioError\:DRIVER_ERROR}

  1578. {\b {\i DRIVER_ERROR}{\bkmkstart classRtAudioError_s11s8}

  1579. {\bkmkend classRtAudioError_s11s8}

  1580. }  \par

  1581. {\xe \v SYSTEM_ERROR\:RtAudioError}

  1582. {\xe \v RtAudioError\:SYSTEM_ERROR}

  1583. {\b {\i SYSTEM_ERROR}{\bkmkstart classRtAudioError_s11s9}

  1584. {\bkmkend classRtAudioError_s11s9}

  1585. }  \par

  1586. {\xe \v THREAD_ERROR\:RtAudioError}

  1587. {\xe \v RtAudioError\:THREAD_ERROR}

  1588. {\b {\i THREAD_ERROR}{\bkmkstart classRtAudioError_s11s10}

  1589. {\bkmkend classRtAudioError_s11s10}

  1590. }  \par

  1591. }

  1592. \par

  1593. }

  1594. }

  1595. {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  1596. \par

  1597. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1598. Constructor & Destructor Documentation\par

  1599. \pard\plain 

  1600. {\xe \v RtAudioError\:RtAudioError}

  1601. {\xe \v RtAudioError\:RtAudioError}

  1602. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1603. {\b 

  1604. RtAudioError::RtAudioError (const char * {\i p}, {\b TYPE} {\i tipe} = RtAudioError::UNSPECIFIED)}

  1605. }\par

  1606. {\bkmkstart classRtAudioError_a0}

  1607. {\bkmkend classRtAudioError_a0}

  1608. {

  1609. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1610. The constructor.\par

  1611. }

  1612. {\xe \v ~RtAudioError\:RtAudioError}

  1613. {\xe \v RtAudioError\:~RtAudioError}

  1614. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1615. {\b 

  1616. RtAudioError::~RtAudioError (void){\f2  [virtual]}}

  1617. }\par

  1618. {\bkmkstart classRtAudioError_a1}

  1619. {\bkmkend classRtAudioError_a1}

  1620. {

  1621. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1622. The destructor.\par

  1623. }

  1624. {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  1625. \par

  1626. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1627. Member Function Documentation\par

  1628. \pard\plain 

  1629. {\xe \v printMessage\:RtAudioError}

  1630. {\xe \v RtAudioError\:printMessage}

  1631. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1632. {\b 

  1633. void RtAudioError::printMessage (void){\f2  [virtual]}}

  1634. }\par

  1635. {\bkmkstart classRtAudioError_a2}

  1636. {\bkmkend classRtAudioError_a2}

  1637. {

  1638. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1639. Prints "thrown" error message to stdout.\par

  1640. }

  1641. {\xe \v getType\:RtAudioError}

  1642. {\xe \v RtAudioError\:getType}

  1643. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1644. {\b 

  1645. const {\b TYPE} & RtAudioError::getType (void){\f2  [inline, virtual]}}

  1646. }\par

  1647. {\bkmkstart classRtAudioError_a3}

  1648. {\bkmkend classRtAudioError_a3}

  1649. {

  1650. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1651. Returns the "thrown" error message TYPE.\par

  1652. }

  1653. {\xe \v getMessage\:RtAudioError}

  1654. {\xe \v RtAudioError\:getMessage}

  1655. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1656. {\b 

  1657. const char * RtAudioError::getMessage (void){\f2  [inline, virtual]}}

  1658. }\par

  1659. {\bkmkstart classRtAudioError_a4}

  1660. {\bkmkend classRtAudioError_a4}

  1661. {

  1662. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1663. Returns the "thrown" error message string.\par

  1664. }

  1665. {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  1666. \par

  1667. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1668. Member Data Documentation\par

  1669. \pard\plain 

  1670. {\xe \v error_message\:RtAudioError}

  1671. {\xe \v RtAudioError\:error_message}

  1672. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1673. {\b 

  1674. char RtAudioError::error_message{\f2  [protected]}}

  1675. }\par

  1676. {\bkmkstart classRtAudioError_n0}

  1677. {\bkmkend classRtAudioError_n0}

  1678. {

  1679. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1680. }

  1681. {\xe \v type\:RtAudioError}

  1682. {\xe \v RtAudioError\:type}

  1683. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1684. {\b 

  1685. {\b TYPE} RtAudioError::type{\f2  [protected]}}

  1686. }\par

  1687. {\bkmkstart classRtAudioError_n1}

  1688. {\bkmkend classRtAudioError_n1}

  1689. {

  1690. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1691. }

  1692. {

  1693. \pard\plain \s17\sa60\sb30\widctlpar\qj \fs22\cgrid {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  1694. The documentation for this class was generated from the following file:{\par

  1695. \pard\plain \s81\fi-360\li720\widctlpar\jclisttab\tx720{\*\pn \pnlvlbody\ilvl0\ls2\pnrnot0\pndec }\ls2\adjustright \fs20\cgrid 

  1696. {\b RtAudio.h}\par

  1697. }}

  1698. 

  1699. \pard\plain \sect\sbkpage

  1700. \s1\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs36\kerning36\cgrid 

  1701. RtAudio File Documentation{\tc \v File Documentation}

  1702. \par \pard\plain 

  1703. \pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid 

  1704. RtAudio.h File Reference\par \pard\plain 

  1705. {\tc\tcl2 \v RtAudio.h}

  1706. {\xe \v RtAudio.h}

  1707. {\bkmkstart RtAudio_8h}

  1708. {\bkmkend }

  1709. {

  1710. \pard\plain \s17\sa60\sb30\widctlpar\qj \fs22\cgrid {

  1711. \pard\plain \s18\widctlpar\fs22\cgrid {\f2 #include <map>}\par

  1712. \par

  1713. }

  1714. }

  1715. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1716. Compounds\par

  1717. \pard\plain 

  1718. 

  1719. {

  1720. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1721. class {\b RtAudioError}\par

  1722. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1723. class {\b RtAudio}\par

  1724. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1725. struct {\b RtAudio::RTAUDIO_DEVICE}\par

  1726. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1727. struct {\b RtAudio::RTAUDIO_STREAM}\par

  1728. }

  1729. \par

  1730. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1731. Defines\par

  1732. \pard\plain 

  1733. 

  1734. {

  1735. \pard\plain \s80\fi-360\li360\widctlpar\jclisttab\tx360{\*\pn \pnlvlbody\ilvl0\ls1\pnrnot0\pndec }\ls1\adjustright \fs20\cgrid 

  1736. #define {\b __RtAudio_h}\par

  1737. }

  1738. {\pard\widctlpar\brdrb\brdrs\brdrw5\brsp20 \adjustright \par}

  1739. \par

  1740. \pard\plain \s3\sb240\sa60\keepn\widctlpar\adjustright \b\f1\cgrid 

  1741. Define Documentation\par

  1742. \pard\plain 

  1743. {\xe \v __RtAudio_h\:RtAudio.h}

  1744. {\xe \v RtAudio.h\:__RtAudio_h}

  1745. \pard\plain \s4\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs20\cgrid {

  1746. {\b 

  1747. #define __RtAudio_h}

  1748. }\par

  1749. {\bkmkstart RtAudio_8h_a0}

  1750. {\bkmkend RtAudio_8h_a0}

  1751. {

  1752. \pard\plain \s51\li360\sa60\sb30\qj\widctlpar\qj\adjustright \fs20\cgrid 

  1753. {\b Value:}{

  1754. \par

  1755. \pard\plain \s41\li360\widctlpar\adjustright \shading1000\cbpat8 \f2\fs16\cgrid \line

  1756. \par

  1757. }

  1758. }

  1759. \par \pard\plain 

  1760. 

  1761. \pard\plain \sect\sbkpage

  1762. \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid 

  1763. \pard\plain \s2\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs28\kerning28\cgrid 

  1764. tutorial.txt File Reference\par \pard\plain 

  1765. {\tc\tcl2 \v tutorial.txt}

  1766. {\xe \v tutorial.txt}

  1767. {\bkmkstart tutorial_8txt}

  1768. {\bkmkend }

  1769. {

  1770. \pard\plain \s17\sa60\sb30\widctlpar\qj \fs22\cgrid {

  1771. \pard\plain \s18\widctlpar\fs22\cgrid \par

  1772. }

  1773. }

  1774. 

  1775. \pard\plain \sect\sbkpage

  1776. \s1\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs36\kerning36\cgrid 

  1777. \s1\sb240\sa60\keepn\widctlpar\adjustright \b\f1\fs36\kerning36\cgrid Index\par 

  1778. \pard\plain 

  1779. {\tc \v Index}

  1780. {\field\fldedit {\*\fldinst INDEX \\c2 \\*MERGEFORMAT}{\fldrslt INDEX}}

  1781. }