gosu 0.15.2 → 1.0.0.pre1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (234) hide show
  1. checksums.yaml +4 -4
  2. data/dependencies/SDL/include/SDL.h +138 -0
  3. data/dependencies/SDL/include/SDL_assert.h +293 -0
  4. data/dependencies/SDL/include/SDL_atomic.h +295 -0
  5. data/dependencies/SDL/include/SDL_audio.h +859 -0
  6. data/dependencies/SDL/include/SDL_bits.h +121 -0
  7. data/dependencies/SDL/include/SDL_blendmode.h +123 -0
  8. data/dependencies/SDL/include/SDL_clipboard.h +71 -0
  9. data/dependencies/SDL/include/SDL_config.h +55 -0
  10. data/dependencies/SDL/include/SDL_config_android.h +182 -0
  11. data/dependencies/SDL/include/SDL_config_iphoneos.h +207 -0
  12. data/dependencies/SDL/include/SDL_config_macosx.h +266 -0
  13. data/dependencies/SDL/include/SDL_config_minimal.h +85 -0
  14. data/dependencies/SDL/include/SDL_config_os2.h +188 -0
  15. data/dependencies/SDL/include/SDL_config_pandora.h +135 -0
  16. data/dependencies/SDL/include/SDL_config_psp.h +165 -0
  17. data/dependencies/SDL/include/SDL_config_windows.h +288 -0
  18. data/dependencies/SDL/include/SDL_config_winrt.h +243 -0
  19. data/dependencies/SDL/include/SDL_config_wiz.h +149 -0
  20. data/dependencies/SDL/include/SDL_copying.h +20 -0
  21. data/dependencies/SDL/include/SDL_cpuinfo.h +299 -0
  22. data/dependencies/SDL/include/SDL_egl.h +1676 -0
  23. data/dependencies/SDL/include/SDL_endian.h +263 -0
  24. data/dependencies/SDL/include/SDL_error.h +112 -0
  25. data/dependencies/SDL/include/SDL_events.h +827 -0
  26. data/dependencies/SDL/include/SDL_filesystem.h +136 -0
  27. data/dependencies/SDL/include/SDL_gamecontroller.h +541 -0
  28. data/dependencies/SDL/include/SDL_gesture.h +87 -0
  29. data/dependencies/SDL/include/SDL_haptic.h +1247 -0
  30. data/dependencies/SDL/include/SDL_hints.h +1578 -0
  31. data/dependencies/SDL/include/SDL_joystick.h +499 -0
  32. data/dependencies/SDL/include/SDL_keyboard.h +217 -0
  33. data/dependencies/SDL/include/SDL_keycode.h +351 -0
  34. data/dependencies/SDL/include/SDL_loadso.h +81 -0
  35. data/dependencies/SDL/include/SDL_locale.h +101 -0
  36. data/dependencies/SDL/include/SDL_log.h +211 -0
  37. data/dependencies/SDL/include/SDL_main.h +180 -0
  38. data/dependencies/SDL/include/SDL_messagebox.h +146 -0
  39. data/dependencies/SDL/include/SDL_metal.h +117 -0
  40. data/dependencies/SDL/include/SDL_misc.h +75 -0
  41. data/dependencies/SDL/include/SDL_mouse.h +302 -0
  42. data/dependencies/SDL/include/SDL_mutex.h +251 -0
  43. data/dependencies/SDL/include/SDL_name.h +33 -0
  44. data/dependencies/SDL/include/SDL_opengl.h +2183 -0
  45. data/dependencies/SDL/include/SDL_opengl_glext.h +11180 -0
  46. data/dependencies/SDL/include/SDL_opengles.h +39 -0
  47. data/dependencies/SDL/include/SDL_opengles2.h +52 -0
  48. data/dependencies/SDL/include/SDL_opengles2_gl2.h +621 -0
  49. data/dependencies/SDL/include/SDL_opengles2_gl2ext.h +2050 -0
  50. data/dependencies/SDL/include/SDL_opengles2_gl2platform.h +30 -0
  51. data/dependencies/SDL/include/SDL_opengles2_khrplatform.h +282 -0
  52. data/dependencies/SDL/include/SDL_pixels.h +479 -0
  53. data/dependencies/SDL/include/SDL_platform.h +198 -0
  54. data/dependencies/SDL/include/SDL_power.h +75 -0
  55. data/dependencies/SDL/include/SDL_quit.h +58 -0
  56. data/dependencies/SDL/include/SDL_rect.h +174 -0
  57. data/dependencies/SDL/include/SDL_render.h +1158 -0
  58. data/dependencies/SDL/include/SDL_revision.h +2 -0
  59. data/dependencies/SDL/include/SDL_rwops.h +283 -0
  60. data/dependencies/SDL/include/SDL_scancode.h +413 -0
  61. data/dependencies/SDL/include/SDL_sensor.h +267 -0
  62. data/dependencies/SDL/include/SDL_shape.h +144 -0
  63. data/dependencies/SDL/include/SDL_stdinc.h +647 -0
  64. data/dependencies/SDL/include/SDL_surface.h +563 -0
  65. data/dependencies/SDL/include/SDL_system.h +325 -0
  66. data/dependencies/SDL/include/SDL_syswm.h +354 -0
  67. data/dependencies/SDL/include/SDL_test.h +69 -0
  68. data/dependencies/SDL/include/SDL_test_assert.h +105 -0
  69. data/dependencies/SDL/include/SDL_test_common.h +218 -0
  70. data/dependencies/SDL/include/SDL_test_compare.h +69 -0
  71. data/dependencies/SDL/include/SDL_test_crc32.h +124 -0
  72. data/dependencies/SDL/include/SDL_test_font.h +81 -0
  73. data/dependencies/SDL/include/SDL_test_fuzzer.h +384 -0
  74. data/dependencies/SDL/include/SDL_test_harness.h +134 -0
  75. data/dependencies/SDL/include/SDL_test_images.h +78 -0
  76. data/dependencies/SDL/include/SDL_test_log.h +67 -0
  77. data/dependencies/SDL/include/SDL_test_md5.h +129 -0
  78. data/dependencies/SDL/include/SDL_test_memory.h +63 -0
  79. data/dependencies/SDL/include/SDL_test_random.h +115 -0
  80. data/dependencies/SDL/include/SDL_thread.h +366 -0
  81. data/dependencies/SDL/include/SDL_timer.h +115 -0
  82. data/dependencies/SDL/include/SDL_touch.h +102 -0
  83. data/dependencies/SDL/include/SDL_types.h +29 -0
  84. data/dependencies/SDL/include/SDL_version.h +162 -0
  85. data/dependencies/SDL/include/SDL_video.h +1282 -0
  86. data/dependencies/SDL/include/SDL_vulkan.h +276 -0
  87. data/dependencies/SDL/include/begin_code.h +166 -0
  88. data/dependencies/SDL/include/close_code.h +40 -0
  89. data/dependencies/SDL/lib/x64/libSDL2.dll.a +0 -0
  90. data/dependencies/SDL/lib/x86/libSDL2.dll.a +0 -0
  91. data/dependencies/SDL_sound/SDL_sound.c +795 -0
  92. data/dependencies/SDL_sound/SDL_sound.h +725 -0
  93. data/dependencies/SDL_sound/SDL_sound_aiff.c +537 -0
  94. data/dependencies/SDL_sound/SDL_sound_au.c +352 -0
  95. data/dependencies/SDL_sound/SDL_sound_coreaudio.c +747 -0
  96. data/dependencies/SDL_sound/SDL_sound_flac.c +182 -0
  97. data/dependencies/SDL_sound/SDL_sound_internal.h +304 -0
  98. data/dependencies/SDL_sound/SDL_sound_modplug.c +228 -0
  99. data/dependencies/SDL_sound/SDL_sound_mp3.c +184 -0
  100. data/dependencies/SDL_sound/SDL_sound_raw.c +164 -0
  101. data/dependencies/SDL_sound/SDL_sound_shn.c +1309 -0
  102. data/dependencies/SDL_sound/SDL_sound_voc.c +550 -0
  103. data/dependencies/SDL_sound/SDL_sound_vorbis.c +223 -0
  104. data/dependencies/SDL_sound/SDL_sound_wav.c +783 -0
  105. data/dependencies/SDL_sound/dr_flac.h +5906 -0
  106. data/dependencies/SDL_sound/dr_mp3.h +2832 -0
  107. data/dependencies/SDL_sound/libmodplug/fastmix.c +1748 -0
  108. data/dependencies/SDL_sound/libmodplug/libmodplug.h +1001 -0
  109. data/dependencies/SDL_sound/libmodplug/load_669.c +188 -0
  110. data/dependencies/SDL_sound/libmodplug/load_abc.c +4725 -0
  111. data/dependencies/SDL_sound/libmodplug/load_amf.c +403 -0
  112. data/dependencies/SDL_sound/libmodplug/load_ams.c +587 -0
  113. data/dependencies/SDL_sound/libmodplug/load_dbm.c +357 -0
  114. data/dependencies/SDL_sound/libmodplug/load_dmf.c +531 -0
  115. data/dependencies/SDL_sound/libmodplug/load_dsm.c +232 -0
  116. data/dependencies/SDL_sound/libmodplug/load_far.c +253 -0
  117. data/dependencies/SDL_sound/libmodplug/load_it.c +796 -0
  118. data/dependencies/SDL_sound/libmodplug/load_mdl.c +488 -0
  119. data/dependencies/SDL_sound/libmodplug/load_med.c +757 -0
  120. data/dependencies/SDL_sound/libmodplug/load_mid.c +1405 -0
  121. data/dependencies/SDL_sound/libmodplug/load_mod.c +269 -0
  122. data/dependencies/SDL_sound/libmodplug/load_mt2.c +546 -0
  123. data/dependencies/SDL_sound/libmodplug/load_mtm.c +142 -0
  124. data/dependencies/SDL_sound/libmodplug/load_okt.c +192 -0
  125. data/dependencies/SDL_sound/libmodplug/load_pat.c +1143 -0
  126. data/dependencies/SDL_sound/libmodplug/load_pat.h +25 -0
  127. data/dependencies/SDL_sound/libmodplug/load_psm.c +350 -0
  128. data/dependencies/SDL_sound/libmodplug/load_ptm.c +204 -0
  129. data/dependencies/SDL_sound/libmodplug/load_s3m.c +325 -0
  130. data/dependencies/SDL_sound/libmodplug/load_stm.c +180 -0
  131. data/dependencies/SDL_sound/libmodplug/load_ult.c +206 -0
  132. data/dependencies/SDL_sound/libmodplug/load_umx.c +51 -0
  133. data/dependencies/SDL_sound/libmodplug/load_xm.c +554 -0
  134. data/dependencies/SDL_sound/libmodplug/mmcmp.c +382 -0
  135. data/dependencies/SDL_sound/libmodplug/modplug.c +170 -0
  136. data/dependencies/SDL_sound/libmodplug/modplug.h +90 -0
  137. data/dependencies/SDL_sound/libmodplug/snd_dsp.c +301 -0
  138. data/dependencies/SDL_sound/libmodplug/snd_flt.c +63 -0
  139. data/dependencies/SDL_sound/libmodplug/snd_fx.c +2350 -0
  140. data/dependencies/SDL_sound/libmodplug/sndfile.c +1169 -0
  141. data/dependencies/SDL_sound/libmodplug/sndmix.c +1034 -0
  142. data/dependencies/SDL_sound/libmodplug/tables.h +371 -0
  143. data/{src/stb_vorbis.c → dependencies/SDL_sound/stb_vorbis.h} +143 -78
  144. data/dependencies/al_soft/AL/al.h +655 -0
  145. data/dependencies/al_soft/AL/alc.h +270 -0
  146. data/dependencies/al_soft/AL/alext.h +585 -0
  147. data/dependencies/al_soft/AL/efx-creative.h +3 -0
  148. data/dependencies/al_soft/AL/efx-presets.h +402 -0
  149. data/dependencies/al_soft/AL/efx.h +762 -0
  150. data/dependencies/al_soft/x64/libOpenAL32.dll.a +0 -0
  151. data/dependencies/al_soft/x86/libOpenAL32.dll.a +0 -0
  152. data/{src → dependencies/stb}/stb_image.h +330 -127
  153. data/{src → dependencies/stb}/stb_image_write.h +156 -85
  154. data/{src → dependencies/stb}/stb_truetype.h +192 -69
  155. data/{src → dependencies/utf8proc}/utf8proc.c +0 -0
  156. data/{src → dependencies/utf8proc}/utf8proc.h +0 -0
  157. data/{src → dependencies/utf8proc}/utf8proc_data.h +0 -0
  158. data/ext/gosu/extconf.rb +56 -22
  159. data/{Gosu → include/Gosu}/Audio.hpp +6 -8
  160. data/{Gosu → include/Gosu}/AutoLink.hpp +0 -0
  161. data/include/Gosu/Bitmap.hpp +100 -0
  162. data/{Gosu → include/Gosu}/Buttons.hpp +94 -35
  163. data/{Gosu → include/Gosu}/Channel.h +0 -0
  164. data/{Gosu → include/Gosu}/Color.h +0 -0
  165. data/{Gosu → include/Gosu}/Color.hpp +0 -0
  166. data/{Gosu → include/Gosu}/Directories.hpp +0 -0
  167. data/{Gosu → include/Gosu}/Font.h +0 -0
  168. data/{Gosu → include/Gosu}/Font.hpp +0 -0
  169. data/{Gosu → include/Gosu}/Fwd.hpp +0 -0
  170. data/{Gosu → include/Gosu}/Gosu.h +3 -0
  171. data/{Gosu → include/Gosu}/Gosu.hpp +0 -0
  172. data/{Gosu → include/Gosu}/Graphics.hpp +0 -0
  173. data/{Gosu → include/Gosu}/GraphicsBase.hpp +0 -0
  174. data/{Gosu → include/Gosu}/IO.hpp +0 -0
  175. data/{Gosu → include/Gosu}/Image.h +0 -0
  176. data/{Gosu → include/Gosu}/Image.hpp +7 -6
  177. data/{Gosu → include/Gosu}/ImageData.hpp +0 -0
  178. data/{Gosu → include/Gosu}/Input.hpp +30 -15
  179. data/{Gosu → include/Gosu}/Inspection.hpp +0 -0
  180. data/{Gosu → include/Gosu}/Math.hpp +0 -0
  181. data/{Gosu → include/Gosu}/Platform.hpp +0 -0
  182. data/{Gosu → include/Gosu}/Sample.h +0 -0
  183. data/{Gosu → include/Gosu}/Song.h +0 -0
  184. data/{Gosu → include/Gosu}/Text.hpp +0 -0
  185. data/{Gosu → include/Gosu}/TextInput.h +0 -0
  186. data/{Gosu → include/Gosu}/TextInput.hpp +0 -0
  187. data/{Gosu → include/Gosu}/Timing.hpp +0 -0
  188. data/{Gosu → include/Gosu}/Utility.hpp +1 -1
  189. data/{Gosu → include/Gosu}/Version.hpp +0 -0
  190. data/{Gosu → include/Gosu}/Window.h +2 -0
  191. data/{Gosu → include/Gosu}/Window.hpp +21 -13
  192. data/lib/OpenAL32.dll +0 -0
  193. data/lib/SDL2.dll +0 -0
  194. data/lib/gosu.rb +0 -3
  195. data/lib/gosu/patches.rb +0 -9
  196. data/lib/gosu/swig_patches.rb +3 -2
  197. data/lib/libmpg123.dll +0 -0
  198. data/lib/libsndfile.dll +0 -0
  199. data/lib64/OpenAL32.dll +0 -0
  200. data/lib64/SDL2.dll +0 -0
  201. data/lib64/libmpg123.dll +0 -0
  202. data/lib64/libsndfile.dll +0 -0
  203. data/rdoc/gosu.rb +95 -20
  204. data/src/Audio.cpp +50 -224
  205. data/src/AudioFile.hpp +17 -37
  206. data/src/AudioFileAudioToolbox.cpp +237 -0
  207. data/src/AudioFileSDLSound.cpp +147 -0
  208. data/src/AudioImpl.cpp +3 -12
  209. data/src/AudioImpl.hpp +3 -1
  210. data/src/Bitmap.cpp +85 -83
  211. data/src/BitmapIO.cpp +52 -58
  212. data/src/Constants.cpp +80 -33
  213. data/src/Font.cpp +3 -1
  214. data/src/GosuWrapper.cpp +19 -0
  215. data/src/Graphics.cpp +7 -4
  216. data/src/Image.cpp +13 -16
  217. data/src/Input.cpp +408 -159
  218. data/src/LargeImageData.cpp +1 -1
  219. data/src/MarkupParser.cpp +2 -1
  220. data/src/RubyGosu.cxx +349 -83
  221. data/src/RubyGosu.h +4 -2
  222. data/src/TexChunk.cpp +1 -1
  223. data/src/TextBuilder.cpp +3 -1
  224. data/src/Texture.cpp +1 -1
  225. data/src/TrueTypeFont.cpp +1 -1
  226. data/src/Utility.cpp +11 -7
  227. data/src/Window.cpp +30 -39
  228. data/src/WindowWrapper.cpp +28 -0
  229. metadata +207 -52
  230. data/Gosu/Bitmap.hpp +0 -113
  231. data/src/AudioToolboxFile.hpp +0 -210
  232. data/src/OggFile.hpp +0 -92
  233. data/src/SndFile.hpp +0 -174
  234. data/src/WinMain.cpp +0 -64
@@ -0,0 +1,859 @@
1
+ /*
2
+ Simple DirectMedia Layer
3
+ Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
4
+
5
+ This software is provided 'as-is', without any express or implied
6
+ warranty. In no event will the authors be held liable for any damages
7
+ arising from the use of this software.
8
+
9
+ Permission is granted to anyone to use this software for any purpose,
10
+ including commercial applications, and to alter it and redistribute it
11
+ freely, subject to the following restrictions:
12
+
13
+ 1. The origin of this software must not be misrepresented; you must not
14
+ claim that you wrote the original software. If you use this software
15
+ in a product, an acknowledgment in the product documentation would be
16
+ appreciated but is not required.
17
+ 2. Altered source versions must be plainly marked as such, and must not be
18
+ misrepresented as being the original software.
19
+ 3. This notice may not be removed or altered from any source distribution.
20
+ */
21
+
22
+ /**
23
+ * \file SDL_audio.h
24
+ *
25
+ * Access to the raw audio mixing buffer for the SDL library.
26
+ */
27
+
28
+ #ifndef SDL_audio_h_
29
+ #define SDL_audio_h_
30
+
31
+ #include "SDL_stdinc.h"
32
+ #include "SDL_error.h"
33
+ #include "SDL_endian.h"
34
+ #include "SDL_mutex.h"
35
+ #include "SDL_thread.h"
36
+ #include "SDL_rwops.h"
37
+
38
+ #include "begin_code.h"
39
+ /* Set up for C function definitions, even when using C++ */
40
+ #ifdef __cplusplus
41
+ extern "C" {
42
+ #endif
43
+
44
+ /**
45
+ * \brief Audio format flags.
46
+ *
47
+ * These are what the 16 bits in SDL_AudioFormat currently mean...
48
+ * (Unspecified bits are always zero).
49
+ *
50
+ * \verbatim
51
+ ++-----------------------sample is signed if set
52
+ ||
53
+ || ++-----------sample is bigendian if set
54
+ || ||
55
+ || || ++---sample is float if set
56
+ || || ||
57
+ || || || +---sample bit size---+
58
+ || || || | |
59
+ 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
60
+ \endverbatim
61
+ *
62
+ * There are macros in SDL 2.0 and later to query these bits.
63
+ */
64
+ typedef Uint16 SDL_AudioFormat;
65
+
66
+ /**
67
+ * \name Audio flags
68
+ */
69
+ /* @{ */
70
+
71
+ #define SDL_AUDIO_MASK_BITSIZE (0xFF)
72
+ #define SDL_AUDIO_MASK_DATATYPE (1<<8)
73
+ #define SDL_AUDIO_MASK_ENDIAN (1<<12)
74
+ #define SDL_AUDIO_MASK_SIGNED (1<<15)
75
+ #define SDL_AUDIO_BITSIZE(x) (x & SDL_AUDIO_MASK_BITSIZE)
76
+ #define SDL_AUDIO_ISFLOAT(x) (x & SDL_AUDIO_MASK_DATATYPE)
77
+ #define SDL_AUDIO_ISBIGENDIAN(x) (x & SDL_AUDIO_MASK_ENDIAN)
78
+ #define SDL_AUDIO_ISSIGNED(x) (x & SDL_AUDIO_MASK_SIGNED)
79
+ #define SDL_AUDIO_ISINT(x) (!SDL_AUDIO_ISFLOAT(x))
80
+ #define SDL_AUDIO_ISLITTLEENDIAN(x) (!SDL_AUDIO_ISBIGENDIAN(x))
81
+ #define SDL_AUDIO_ISUNSIGNED(x) (!SDL_AUDIO_ISSIGNED(x))
82
+
83
+ /**
84
+ * \name Audio format flags
85
+ *
86
+ * Defaults to LSB byte order.
87
+ */
88
+ /* @{ */
89
+ #define AUDIO_U8 0x0008 /**< Unsigned 8-bit samples */
90
+ #define AUDIO_S8 0x8008 /**< Signed 8-bit samples */
91
+ #define AUDIO_U16LSB 0x0010 /**< Unsigned 16-bit samples */
92
+ #define AUDIO_S16LSB 0x8010 /**< Signed 16-bit samples */
93
+ #define AUDIO_U16MSB 0x1010 /**< As above, but big-endian byte order */
94
+ #define AUDIO_S16MSB 0x9010 /**< As above, but big-endian byte order */
95
+ #define AUDIO_U16 AUDIO_U16LSB
96
+ #define AUDIO_S16 AUDIO_S16LSB
97
+ /* @} */
98
+
99
+ /**
100
+ * \name int32 support
101
+ */
102
+ /* @{ */
103
+ #define AUDIO_S32LSB 0x8020 /**< 32-bit integer samples */
104
+ #define AUDIO_S32MSB 0x9020 /**< As above, but big-endian byte order */
105
+ #define AUDIO_S32 AUDIO_S32LSB
106
+ /* @} */
107
+
108
+ /**
109
+ * \name float32 support
110
+ */
111
+ /* @{ */
112
+ #define AUDIO_F32LSB 0x8120 /**< 32-bit floating point samples */
113
+ #define AUDIO_F32MSB 0x9120 /**< As above, but big-endian byte order */
114
+ #define AUDIO_F32 AUDIO_F32LSB
115
+ /* @} */
116
+
117
+ /**
118
+ * \name Native audio byte ordering
119
+ */
120
+ /* @{ */
121
+ #if SDL_BYTEORDER == SDL_LIL_ENDIAN
122
+ #define AUDIO_U16SYS AUDIO_U16LSB
123
+ #define AUDIO_S16SYS AUDIO_S16LSB
124
+ #define AUDIO_S32SYS AUDIO_S32LSB
125
+ #define AUDIO_F32SYS AUDIO_F32LSB
126
+ #else
127
+ #define AUDIO_U16SYS AUDIO_U16MSB
128
+ #define AUDIO_S16SYS AUDIO_S16MSB
129
+ #define AUDIO_S32SYS AUDIO_S32MSB
130
+ #define AUDIO_F32SYS AUDIO_F32MSB
131
+ #endif
132
+ /* @} */
133
+
134
+ /**
135
+ * \name Allow change flags
136
+ *
137
+ * Which audio format changes are allowed when opening a device.
138
+ */
139
+ /* @{ */
140
+ #define SDL_AUDIO_ALLOW_FREQUENCY_CHANGE 0x00000001
141
+ #define SDL_AUDIO_ALLOW_FORMAT_CHANGE 0x00000002
142
+ #define SDL_AUDIO_ALLOW_CHANNELS_CHANGE 0x00000004
143
+ #define SDL_AUDIO_ALLOW_SAMPLES_CHANGE 0x00000008
144
+ #define SDL_AUDIO_ALLOW_ANY_CHANGE (SDL_AUDIO_ALLOW_FREQUENCY_CHANGE|SDL_AUDIO_ALLOW_FORMAT_CHANGE|SDL_AUDIO_ALLOW_CHANNELS_CHANGE|SDL_AUDIO_ALLOW_SAMPLES_CHANGE)
145
+ /* @} */
146
+
147
+ /* @} *//* Audio flags */
148
+
149
+ /**
150
+ * This function is called when the audio device needs more data.
151
+ *
152
+ * \param userdata An application-specific parameter saved in
153
+ * the SDL_AudioSpec structure
154
+ * \param stream A pointer to the audio data buffer.
155
+ * \param len The length of that buffer in bytes.
156
+ *
157
+ * Once the callback returns, the buffer will no longer be valid.
158
+ * Stereo samples are stored in a LRLRLR ordering.
159
+ *
160
+ * You can choose to avoid callbacks and use SDL_QueueAudio() instead, if
161
+ * you like. Just open your audio device with a NULL callback.
162
+ */
163
+ typedef void (SDLCALL * SDL_AudioCallback) (void *userdata, Uint8 * stream,
164
+ int len);
165
+
166
+ /**
167
+ * The calculated values in this structure are calculated by SDL_OpenAudio().
168
+ *
169
+ * For multi-channel audio, the default SDL channel mapping is:
170
+ * 2: FL FR (stereo)
171
+ * 3: FL FR LFE (2.1 surround)
172
+ * 4: FL FR BL BR (quad)
173
+ * 5: FL FR FC BL BR (quad + center)
174
+ * 6: FL FR FC LFE SL SR (5.1 surround - last two can also be BL BR)
175
+ * 7: FL FR FC LFE BC SL SR (6.1 surround)
176
+ * 8: FL FR FC LFE BL BR SL SR (7.1 surround)
177
+ */
178
+ typedef struct SDL_AudioSpec
179
+ {
180
+ int freq; /**< DSP frequency -- samples per second */
181
+ SDL_AudioFormat format; /**< Audio data format */
182
+ Uint8 channels; /**< Number of channels: 1 mono, 2 stereo */
183
+ Uint8 silence; /**< Audio buffer silence value (calculated) */
184
+ Uint16 samples; /**< Audio buffer size in sample FRAMES (total samples divided by channel count) */
185
+ Uint16 padding; /**< Necessary for some compile environments */
186
+ Uint32 size; /**< Audio buffer size in bytes (calculated) */
187
+ SDL_AudioCallback callback; /**< Callback that feeds the audio device (NULL to use SDL_QueueAudio()). */
188
+ void *userdata; /**< Userdata passed to callback (ignored for NULL callbacks). */
189
+ } SDL_AudioSpec;
190
+
191
+
192
+ struct SDL_AudioCVT;
193
+ typedef void (SDLCALL * SDL_AudioFilter) (struct SDL_AudioCVT * cvt,
194
+ SDL_AudioFormat format);
195
+
196
+ /**
197
+ * \brief Upper limit of filters in SDL_AudioCVT
198
+ *
199
+ * The maximum number of SDL_AudioFilter functions in SDL_AudioCVT is
200
+ * currently limited to 9. The SDL_AudioCVT.filters array has 10 pointers,
201
+ * one of which is the terminating NULL pointer.
202
+ */
203
+ #define SDL_AUDIOCVT_MAX_FILTERS 9
204
+
205
+ /**
206
+ * \struct SDL_AudioCVT
207
+ * \brief A structure to hold a set of audio conversion filters and buffers.
208
+ *
209
+ * Note that various parts of the conversion pipeline can take advantage
210
+ * of SIMD operations (like SSE2, for example). SDL_AudioCVT doesn't require
211
+ * you to pass it aligned data, but can possibly run much faster if you
212
+ * set both its (buf) field to a pointer that is aligned to 16 bytes, and its
213
+ * (len) field to something that's a multiple of 16, if possible.
214
+ */
215
+ #ifdef __GNUC__
216
+ /* This structure is 84 bytes on 32-bit architectures, make sure GCC doesn't
217
+ pad it out to 88 bytes to guarantee ABI compatibility between compilers.
218
+ vvv
219
+ The next time we rev the ABI, make sure to size the ints and add padding.
220
+ */
221
+ #define SDL_AUDIOCVT_PACKED __attribute__((packed))
222
+ #else
223
+ #define SDL_AUDIOCVT_PACKED
224
+ #endif
225
+ /* */
226
+ typedef struct SDL_AudioCVT
227
+ {
228
+ int needed; /**< Set to 1 if conversion possible */
229
+ SDL_AudioFormat src_format; /**< Source audio format */
230
+ SDL_AudioFormat dst_format; /**< Target audio format */
231
+ double rate_incr; /**< Rate conversion increment */
232
+ Uint8 *buf; /**< Buffer to hold entire audio data */
233
+ int len; /**< Length of original audio buffer */
234
+ int len_cvt; /**< Length of converted audio buffer */
235
+ int len_mult; /**< buffer must be len*len_mult big */
236
+ double len_ratio; /**< Given len, final size is len*len_ratio */
237
+ SDL_AudioFilter filters[SDL_AUDIOCVT_MAX_FILTERS + 1]; /**< NULL-terminated list of filter functions */
238
+ int filter_index; /**< Current audio conversion function */
239
+ } SDL_AUDIOCVT_PACKED SDL_AudioCVT;
240
+
241
+
242
+ /* Function prototypes */
243
+
244
+ /**
245
+ * \name Driver discovery functions
246
+ *
247
+ * These functions return the list of built in audio drivers, in the
248
+ * order that they are normally initialized by default.
249
+ */
250
+ /* @{ */
251
+ extern DECLSPEC int SDLCALL SDL_GetNumAudioDrivers(void);
252
+ extern DECLSPEC const char *SDLCALL SDL_GetAudioDriver(int index);
253
+ /* @} */
254
+
255
+ /**
256
+ * \name Initialization and cleanup
257
+ *
258
+ * \internal These functions are used internally, and should not be used unless
259
+ * you have a specific need to specify the audio driver you want to
260
+ * use. You should normally use SDL_Init() or SDL_InitSubSystem().
261
+ */
262
+ /* @{ */
263
+ extern DECLSPEC int SDLCALL SDL_AudioInit(const char *driver_name);
264
+ extern DECLSPEC void SDLCALL SDL_AudioQuit(void);
265
+ /* @} */
266
+
267
+ /**
268
+ * This function returns the name of the current audio driver, or NULL
269
+ * if no driver has been initialized.
270
+ */
271
+ extern DECLSPEC const char *SDLCALL SDL_GetCurrentAudioDriver(void);
272
+
273
+ /**
274
+ * This function opens the audio device with the desired parameters, and
275
+ * returns 0 if successful, placing the actual hardware parameters in the
276
+ * structure pointed to by \c obtained. If \c obtained is NULL, the audio
277
+ * data passed to the callback function will be guaranteed to be in the
278
+ * requested format, and will be automatically converted to the hardware
279
+ * audio format if necessary. This function returns -1 if it failed
280
+ * to open the audio device, or couldn't set up the audio thread.
281
+ *
282
+ * When filling in the desired audio spec structure,
283
+ * - \c desired->freq should be the desired audio frequency in samples-per-
284
+ * second.
285
+ * - \c desired->format should be the desired audio format.
286
+ * - \c desired->samples is the desired size of the audio buffer, in
287
+ * samples. This number should be a power of two, and may be adjusted by
288
+ * the audio driver to a value more suitable for the hardware. Good values
289
+ * seem to range between 512 and 8096 inclusive, depending on the
290
+ * application and CPU speed. Smaller values yield faster response time,
291
+ * but can lead to underflow if the application is doing heavy processing
292
+ * and cannot fill the audio buffer in time. A stereo sample consists of
293
+ * both right and left channels in LR ordering.
294
+ * Note that the number of samples is directly related to time by the
295
+ * following formula: \code ms = (samples*1000)/freq \endcode
296
+ * - \c desired->size is the size in bytes of the audio buffer, and is
297
+ * calculated by SDL_OpenAudio().
298
+ * - \c desired->silence is the value used to set the buffer to silence,
299
+ * and is calculated by SDL_OpenAudio().
300
+ * - \c desired->callback should be set to a function that will be called
301
+ * when the audio device is ready for more data. It is passed a pointer
302
+ * to the audio buffer, and the length in bytes of the audio buffer.
303
+ * This function usually runs in a separate thread, and so you should
304
+ * protect data structures that it accesses by calling SDL_LockAudio()
305
+ * and SDL_UnlockAudio() in your code. Alternately, you may pass a NULL
306
+ * pointer here, and call SDL_QueueAudio() with some frequency, to queue
307
+ * more audio samples to be played (or for capture devices, call
308
+ * SDL_DequeueAudio() with some frequency, to obtain audio samples).
309
+ * - \c desired->userdata is passed as the first parameter to your callback
310
+ * function. If you passed a NULL callback, this value is ignored.
311
+ *
312
+ * The audio device starts out playing silence when it's opened, and should
313
+ * be enabled for playing by calling \c SDL_PauseAudio(0) when you are ready
314
+ * for your audio callback function to be called. Since the audio driver
315
+ * may modify the requested size of the audio buffer, you should allocate
316
+ * any local mixing buffers after you open the audio device.
317
+ */
318
+ extern DECLSPEC int SDLCALL SDL_OpenAudio(SDL_AudioSpec * desired,
319
+ SDL_AudioSpec * obtained);
320
+
321
+ /**
322
+ * SDL Audio Device IDs.
323
+ *
324
+ * A successful call to SDL_OpenAudio() is always device id 1, and legacy
325
+ * SDL audio APIs assume you want this device ID. SDL_OpenAudioDevice() calls
326
+ * always returns devices >= 2 on success. The legacy calls are good both
327
+ * for backwards compatibility and when you don't care about multiple,
328
+ * specific, or capture devices.
329
+ */
330
+ typedef Uint32 SDL_AudioDeviceID;
331
+
332
+ /**
333
+ * Get the number of available devices exposed by the current driver.
334
+ * Only valid after a successfully initializing the audio subsystem.
335
+ * Returns -1 if an explicit list of devices can't be determined; this is
336
+ * not an error. For example, if SDL is set up to talk to a remote audio
337
+ * server, it can't list every one available on the Internet, but it will
338
+ * still allow a specific host to be specified to SDL_OpenAudioDevice().
339
+ *
340
+ * In many common cases, when this function returns a value <= 0, it can still
341
+ * successfully open the default device (NULL for first argument of
342
+ * SDL_OpenAudioDevice()).
343
+ */
344
+ extern DECLSPEC int SDLCALL SDL_GetNumAudioDevices(int iscapture);
345
+
346
+ /**
347
+ * Get the human-readable name of a specific audio device.
348
+ * Must be a value between 0 and (number of audio devices-1).
349
+ * Only valid after a successfully initializing the audio subsystem.
350
+ * The values returned by this function reflect the latest call to
351
+ * SDL_GetNumAudioDevices(); recall that function to redetect available
352
+ * hardware.
353
+ *
354
+ * The string returned by this function is UTF-8 encoded, read-only, and
355
+ * managed internally. You are not to free it. If you need to keep the
356
+ * string for any length of time, you should make your own copy of it, as it
357
+ * will be invalid next time any of several other SDL functions is called.
358
+ */
359
+ extern DECLSPEC const char *SDLCALL SDL_GetAudioDeviceName(int index,
360
+ int iscapture);
361
+
362
+
363
+ /**
364
+ * Open a specific audio device. Passing in a device name of NULL requests
365
+ * the most reasonable default (and is equivalent to calling SDL_OpenAudio()).
366
+ *
367
+ * The device name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but
368
+ * some drivers allow arbitrary and driver-specific strings, such as a
369
+ * hostname/IP address for a remote audio server, or a filename in the
370
+ * diskaudio driver.
371
+ *
372
+ * \return 0 on error, a valid device ID that is >= 2 on success.
373
+ *
374
+ * SDL_OpenAudio(), unlike this function, always acts on device ID 1.
375
+ */
376
+ extern DECLSPEC SDL_AudioDeviceID SDLCALL SDL_OpenAudioDevice(const char
377
+ *device,
378
+ int iscapture,
379
+ const
380
+ SDL_AudioSpec *
381
+ desired,
382
+ SDL_AudioSpec *
383
+ obtained,
384
+ int
385
+ allowed_changes);
386
+
387
+
388
+
389
+ /**
390
+ * \name Audio state
391
+ *
392
+ * Get the current audio state.
393
+ */
394
+ /* @{ */
395
+ typedef enum
396
+ {
397
+ SDL_AUDIO_STOPPED = 0,
398
+ SDL_AUDIO_PLAYING,
399
+ SDL_AUDIO_PAUSED
400
+ } SDL_AudioStatus;
401
+ extern DECLSPEC SDL_AudioStatus SDLCALL SDL_GetAudioStatus(void);
402
+
403
+ extern DECLSPEC SDL_AudioStatus SDLCALL
404
+ SDL_GetAudioDeviceStatus(SDL_AudioDeviceID dev);
405
+ /* @} *//* Audio State */
406
+
407
+ /**
408
+ * \name Pause audio functions
409
+ *
410
+ * These functions pause and unpause the audio callback processing.
411
+ * They should be called with a parameter of 0 after opening the audio
412
+ * device to start playing sound. This is so you can safely initialize
413
+ * data for your callback function after opening the audio device.
414
+ * Silence will be written to the audio device during the pause.
415
+ */
416
+ /* @{ */
417
+ extern DECLSPEC void SDLCALL SDL_PauseAudio(int pause_on);
418
+ extern DECLSPEC void SDLCALL SDL_PauseAudioDevice(SDL_AudioDeviceID dev,
419
+ int pause_on);
420
+ /* @} *//* Pause audio functions */
421
+
422
+ /**
423
+ * \brief Load the audio data of a WAVE file into memory
424
+ *
425
+ * Loading a WAVE file requires \c src, \c spec, \c audio_buf and \c audio_len
426
+ * to be valid pointers. The entire data portion of the file is then loaded
427
+ * into memory and decoded if necessary.
428
+ *
429
+ * If \c freesrc is non-zero, the data source gets automatically closed and
430
+ * freed before the function returns.
431
+ *
432
+ * Supported are RIFF WAVE files with the formats PCM (8, 16, 24, and 32 bits),
433
+ * IEEE Float (32 bits), Microsoft ADPCM and IMA ADPCM (4 bits), and A-law and
434
+ * µ-law (8 bits). Other formats are currently unsupported and cause an error.
435
+ *
436
+ * If this function succeeds, the pointer returned by it is equal to \c spec
437
+ * and the pointer to the audio data allocated by the function is written to
438
+ * \c audio_buf and its length in bytes to \c audio_len. The \ref SDL_AudioSpec
439
+ * members \c freq, \c channels, and \c format are set to the values of the
440
+ * audio data in the buffer. The \c samples member is set to a sane default and
441
+ * all others are set to zero.
442
+ *
443
+ * It's necessary to use SDL_FreeWAV() to free the audio data returned in
444
+ * \c audio_buf when it is no longer used.
445
+ *
446
+ * Because of the underspecification of the Waveform format, there are many
447
+ * problematic files in the wild that cause issues with strict decoders. To
448
+ * provide compatibility with these files, this decoder is lenient in regards
449
+ * to the truncation of the file, the fact chunk, and the size of the RIFF
450
+ * chunk. The hints SDL_HINT_WAVE_RIFF_CHUNK_SIZE, SDL_HINT_WAVE_TRUNCATION,
451
+ * and SDL_HINT_WAVE_FACT_CHUNK can be used to tune the behavior of the
452
+ * loading process.
453
+ *
454
+ * Any file that is invalid (due to truncation, corruption, or wrong values in
455
+ * the headers), too big, or unsupported causes an error. Additionally, any
456
+ * critical I/O error from the data source will terminate the loading process
457
+ * with an error. The function returns NULL on error and in all cases (with the
458
+ * exception of \c src being NULL), an appropriate error message will be set.
459
+ *
460
+ * It is required that the data source supports seeking.
461
+ *
462
+ * Example:
463
+ * \code
464
+ * SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
465
+ * \endcode
466
+ *
467
+ * \param src The data source with the WAVE data
468
+ * \param freesrc A integer value that makes the function close the data source if non-zero
469
+ * \param spec A pointer filled with the audio format of the audio data
470
+ * \param audio_buf A pointer filled with the audio data allocated by the function
471
+ * \param audio_len A pointer filled with the length of the audio data buffer in bytes
472
+ * \return NULL on error, or non-NULL on success.
473
+ */
474
+ extern DECLSPEC SDL_AudioSpec *SDLCALL SDL_LoadWAV_RW(SDL_RWops * src,
475
+ int freesrc,
476
+ SDL_AudioSpec * spec,
477
+ Uint8 ** audio_buf,
478
+ Uint32 * audio_len);
479
+
480
+ /**
481
+ * Loads a WAV from a file.
482
+ * Compatibility convenience function.
483
+ */
484
+ #define SDL_LoadWAV(file, spec, audio_buf, audio_len) \
485
+ SDL_LoadWAV_RW(SDL_RWFromFile(file, "rb"),1, spec,audio_buf,audio_len)
486
+
487
+ /**
488
+ * This function frees data previously allocated with SDL_LoadWAV_RW()
489
+ */
490
+ extern DECLSPEC void SDLCALL SDL_FreeWAV(Uint8 * audio_buf);
491
+
492
+ /**
493
+ * This function takes a source format and rate and a destination format
494
+ * and rate, and initializes the \c cvt structure with information needed
495
+ * by SDL_ConvertAudio() to convert a buffer of audio data from one format
496
+ * to the other. An unsupported format causes an error and -1 will be returned.
497
+ *
498
+ * \return 0 if no conversion is needed, 1 if the audio filter is set up,
499
+ * or -1 on error.
500
+ */
501
+ extern DECLSPEC int SDLCALL SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
502
+ SDL_AudioFormat src_format,
503
+ Uint8 src_channels,
504
+ int src_rate,
505
+ SDL_AudioFormat dst_format,
506
+ Uint8 dst_channels,
507
+ int dst_rate);
508
+
509
+ /**
510
+ * Once you have initialized the \c cvt structure using SDL_BuildAudioCVT(),
511
+ * created an audio buffer \c cvt->buf, and filled it with \c cvt->len bytes of
512
+ * audio data in the source format, this function will convert it in-place
513
+ * to the desired format.
514
+ *
515
+ * The data conversion may expand the size of the audio data, so the buffer
516
+ * \c cvt->buf should be allocated after the \c cvt structure is initialized by
517
+ * SDL_BuildAudioCVT(), and should be \c cvt->len*cvt->len_mult bytes long.
518
+ *
519
+ * \return 0 on success or -1 if \c cvt->buf is NULL.
520
+ */
521
+ extern DECLSPEC int SDLCALL SDL_ConvertAudio(SDL_AudioCVT * cvt);
522
+
523
+ /* SDL_AudioStream is a new audio conversion interface.
524
+ The benefits vs SDL_AudioCVT:
525
+ - it can handle resampling data in chunks without generating
526
+ artifacts, when it doesn't have the complete buffer available.
527
+ - it can handle incoming data in any variable size.
528
+ - You push data as you have it, and pull it when you need it
529
+ */
530
+ /* this is opaque to the outside world. */
531
+ struct _SDL_AudioStream;
532
+ typedef struct _SDL_AudioStream SDL_AudioStream;
533
+
534
+ /**
535
+ * Create a new audio stream
536
+ *
537
+ * \param src_format The format of the source audio
538
+ * \param src_channels The number of channels of the source audio
539
+ * \param src_rate The sampling rate of the source audio
540
+ * \param dst_format The format of the desired audio output
541
+ * \param dst_channels The number of channels of the desired audio output
542
+ * \param dst_rate The sampling rate of the desired audio output
543
+ * \return 0 on success, or -1 on error.
544
+ *
545
+ * \sa SDL_AudioStreamPut
546
+ * \sa SDL_AudioStreamGet
547
+ * \sa SDL_AudioStreamAvailable
548
+ * \sa SDL_AudioStreamFlush
549
+ * \sa SDL_AudioStreamClear
550
+ * \sa SDL_FreeAudioStream
551
+ */
552
+ extern DECLSPEC SDL_AudioStream * SDLCALL SDL_NewAudioStream(const SDL_AudioFormat src_format,
553
+ const Uint8 src_channels,
554
+ const int src_rate,
555
+ const SDL_AudioFormat dst_format,
556
+ const Uint8 dst_channels,
557
+ const int dst_rate);
558
+
559
+ /**
560
+ * Add data to be converted/resampled to the stream
561
+ *
562
+ * \param stream The stream the audio data is being added to
563
+ * \param buf A pointer to the audio data to add
564
+ * \param len The number of bytes to write to the stream
565
+ * \return 0 on success, or -1 on error.
566
+ *
567
+ * \sa SDL_NewAudioStream
568
+ * \sa SDL_AudioStreamGet
569
+ * \sa SDL_AudioStreamAvailable
570
+ * \sa SDL_AudioStreamFlush
571
+ * \sa SDL_AudioStreamClear
572
+ * \sa SDL_FreeAudioStream
573
+ */
574
+ extern DECLSPEC int SDLCALL SDL_AudioStreamPut(SDL_AudioStream *stream, const void *buf, int len);
575
+
576
+ /**
577
+ * Get converted/resampled data from the stream
578
+ *
579
+ * \param stream The stream the audio is being requested from
580
+ * \param buf A buffer to fill with audio data
581
+ * \param len The maximum number of bytes to fill
582
+ * \return The number of bytes read from the stream, or -1 on error
583
+ *
584
+ * \sa SDL_NewAudioStream
585
+ * \sa SDL_AudioStreamPut
586
+ * \sa SDL_AudioStreamAvailable
587
+ * \sa SDL_AudioStreamFlush
588
+ * \sa SDL_AudioStreamClear
589
+ * \sa SDL_FreeAudioStream
590
+ */
591
+ extern DECLSPEC int SDLCALL SDL_AudioStreamGet(SDL_AudioStream *stream, void *buf, int len);
592
+
593
+ /**
594
+ * Get the number of converted/resampled bytes available. The stream may be
595
+ * buffering data behind the scenes until it has enough to resample
596
+ * correctly, so this number might be lower than what you expect, or even
597
+ * be zero. Add more data or flush the stream if you need the data now.
598
+ *
599
+ * \sa SDL_NewAudioStream
600
+ * \sa SDL_AudioStreamPut
601
+ * \sa SDL_AudioStreamGet
602
+ * \sa SDL_AudioStreamFlush
603
+ * \sa SDL_AudioStreamClear
604
+ * \sa SDL_FreeAudioStream
605
+ */
606
+ extern DECLSPEC int SDLCALL SDL_AudioStreamAvailable(SDL_AudioStream *stream);
607
+
608
+ /**
609
+ * Tell the stream that you're done sending data, and anything being buffered
610
+ * should be converted/resampled and made available immediately.
611
+ *
612
+ * It is legal to add more data to a stream after flushing, but there will
613
+ * be audio gaps in the output. Generally this is intended to signal the
614
+ * end of input, so the complete output becomes available.
615
+ *
616
+ * \sa SDL_NewAudioStream
617
+ * \sa SDL_AudioStreamPut
618
+ * \sa SDL_AudioStreamGet
619
+ * \sa SDL_AudioStreamAvailable
620
+ * \sa SDL_AudioStreamClear
621
+ * \sa SDL_FreeAudioStream
622
+ */
623
+ extern DECLSPEC int SDLCALL SDL_AudioStreamFlush(SDL_AudioStream *stream);
624
+
625
+ /**
626
+ * Clear any pending data in the stream without converting it
627
+ *
628
+ * \sa SDL_NewAudioStream
629
+ * \sa SDL_AudioStreamPut
630
+ * \sa SDL_AudioStreamGet
631
+ * \sa SDL_AudioStreamAvailable
632
+ * \sa SDL_AudioStreamFlush
633
+ * \sa SDL_FreeAudioStream
634
+ */
635
+ extern DECLSPEC void SDLCALL SDL_AudioStreamClear(SDL_AudioStream *stream);
636
+
637
+ /**
638
+ * Free an audio stream
639
+ *
640
+ * \sa SDL_NewAudioStream
641
+ * \sa SDL_AudioStreamPut
642
+ * \sa SDL_AudioStreamGet
643
+ * \sa SDL_AudioStreamAvailable
644
+ * \sa SDL_AudioStreamFlush
645
+ * \sa SDL_AudioStreamClear
646
+ */
647
+ extern DECLSPEC void SDLCALL SDL_FreeAudioStream(SDL_AudioStream *stream);
648
+
649
+ #define SDL_MIX_MAXVOLUME 128
650
+ /**
651
+ * This takes two audio buffers of the playing audio format and mixes
652
+ * them, performing addition, volume adjustment, and overflow clipping.
653
+ * The volume ranges from 0 - 128, and should be set to ::SDL_MIX_MAXVOLUME
654
+ * for full audio volume. Note this does not change hardware volume.
655
+ * This is provided for convenience -- you can mix your own audio data.
656
+ */
657
+ extern DECLSPEC void SDLCALL SDL_MixAudio(Uint8 * dst, const Uint8 * src,
658
+ Uint32 len, int volume);
659
+
660
+ /**
661
+ * This works like SDL_MixAudio(), but you specify the audio format instead of
662
+ * using the format of audio device 1. Thus it can be used when no audio
663
+ * device is open at all.
664
+ */
665
+ extern DECLSPEC void SDLCALL SDL_MixAudioFormat(Uint8 * dst,
666
+ const Uint8 * src,
667
+ SDL_AudioFormat format,
668
+ Uint32 len, int volume);
669
+
670
+ /**
671
+ * Queue more audio on non-callback devices.
672
+ *
673
+ * (If you are looking to retrieve queued audio from a non-callback capture
674
+ * device, you want SDL_DequeueAudio() instead. This will return -1 to
675
+ * signify an error if you use it with capture devices.)
676
+ *
677
+ * SDL offers two ways to feed audio to the device: you can either supply a
678
+ * callback that SDL triggers with some frequency to obtain more audio
679
+ * (pull method), or you can supply no callback, and then SDL will expect
680
+ * you to supply data at regular intervals (push method) with this function.
681
+ *
682
+ * There are no limits on the amount of data you can queue, short of
683
+ * exhaustion of address space. Queued data will drain to the device as
684
+ * necessary without further intervention from you. If the device needs
685
+ * audio but there is not enough queued, it will play silence to make up
686
+ * the difference. This means you will have skips in your audio playback
687
+ * if you aren't routinely queueing sufficient data.
688
+ *
689
+ * This function copies the supplied data, so you are safe to free it when
690
+ * the function returns. This function is thread-safe, but queueing to the
691
+ * same device from two threads at once does not promise which buffer will
692
+ * be queued first.
693
+ *
694
+ * You may not queue audio on a device that is using an application-supplied
695
+ * callback; doing so returns an error. You have to use the audio callback
696
+ * or queue audio with this function, but not both.
697
+ *
698
+ * You should not call SDL_LockAudio() on the device before queueing; SDL
699
+ * handles locking internally for this function.
700
+ *
701
+ * \param dev The device ID to which we will queue audio.
702
+ * \param data The data to queue to the device for later playback.
703
+ * \param len The number of bytes (not samples!) to which (data) points.
704
+ * \return 0 on success, or -1 on error.
705
+ *
706
+ * \sa SDL_GetQueuedAudioSize
707
+ * \sa SDL_ClearQueuedAudio
708
+ */
709
+ extern DECLSPEC int SDLCALL SDL_QueueAudio(SDL_AudioDeviceID dev, const void *data, Uint32 len);
710
+
711
+ /**
712
+ * Dequeue more audio on non-callback devices.
713
+ *
714
+ * (If you are looking to queue audio for output on a non-callback playback
715
+ * device, you want SDL_QueueAudio() instead. This will always return 0
716
+ * if you use it with playback devices.)
717
+ *
718
+ * SDL offers two ways to retrieve audio from a capture device: you can
719
+ * either supply a callback that SDL triggers with some frequency as the
720
+ * device records more audio data, (push method), or you can supply no
721
+ * callback, and then SDL will expect you to retrieve data at regular
722
+ * intervals (pull method) with this function.
723
+ *
724
+ * There are no limits on the amount of data you can queue, short of
725
+ * exhaustion of address space. Data from the device will keep queuing as
726
+ * necessary without further intervention from you. This means you will
727
+ * eventually run out of memory if you aren't routinely dequeueing data.
728
+ *
729
+ * Capture devices will not queue data when paused; if you are expecting
730
+ * to not need captured audio for some length of time, use
731
+ * SDL_PauseAudioDevice() to stop the capture device from queueing more
732
+ * data. This can be useful during, say, level loading times. When
733
+ * unpaused, capture devices will start queueing data from that point,
734
+ * having flushed any capturable data available while paused.
735
+ *
736
+ * This function is thread-safe, but dequeueing from the same device from
737
+ * two threads at once does not promise which thread will dequeued data
738
+ * first.
739
+ *
740
+ * You may not dequeue audio from a device that is using an
741
+ * application-supplied callback; doing so returns an error. You have to use
742
+ * the audio callback, or dequeue audio with this function, but not both.
743
+ *
744
+ * You should not call SDL_LockAudio() on the device before queueing; SDL
745
+ * handles locking internally for this function.
746
+ *
747
+ * \param dev The device ID from which we will dequeue audio.
748
+ * \param data A pointer into where audio data should be copied.
749
+ * \param len The number of bytes (not samples!) to which (data) points.
750
+ * \return number of bytes dequeued, which could be less than requested.
751
+ *
752
+ * \sa SDL_GetQueuedAudioSize
753
+ * \sa SDL_ClearQueuedAudio
754
+ */
755
+ extern DECLSPEC Uint32 SDLCALL SDL_DequeueAudio(SDL_AudioDeviceID dev, void *data, Uint32 len);
756
+
757
+ /**
758
+ * Get the number of bytes of still-queued audio.
759
+ *
760
+ * For playback device:
761
+ *
762
+ * This is the number of bytes that have been queued for playback with
763
+ * SDL_QueueAudio(), but have not yet been sent to the hardware. This
764
+ * number may shrink at any time, so this only informs of pending data.
765
+ *
766
+ * Once we've sent it to the hardware, this function can not decide the
767
+ * exact byte boundary of what has been played. It's possible that we just
768
+ * gave the hardware several kilobytes right before you called this
769
+ * function, but it hasn't played any of it yet, or maybe half of it, etc.
770
+ *
771
+ * For capture devices:
772
+ *
773
+ * This is the number of bytes that have been captured by the device and
774
+ * are waiting for you to dequeue. This number may grow at any time, so
775
+ * this only informs of the lower-bound of available data.
776
+ *
777
+ * You may not queue audio on a device that is using an application-supplied
778
+ * callback; calling this function on such a device always returns 0.
779
+ * You have to queue audio with SDL_QueueAudio()/SDL_DequeueAudio(), or use
780
+ * the audio callback, but not both.
781
+ *
782
+ * You should not call SDL_LockAudio() on the device before querying; SDL
783
+ * handles locking internally for this function.
784
+ *
785
+ * \param dev The device ID of which we will query queued audio size.
786
+ * \return Number of bytes (not samples!) of queued audio.
787
+ *
788
+ * \sa SDL_QueueAudio
789
+ * \sa SDL_ClearQueuedAudio
790
+ */
791
+ extern DECLSPEC Uint32 SDLCALL SDL_GetQueuedAudioSize(SDL_AudioDeviceID dev);
792
+
793
+ /**
794
+ * Drop any queued audio data. For playback devices, this is any queued data
795
+ * still waiting to be submitted to the hardware. For capture devices, this
796
+ * is any data that was queued by the device that hasn't yet been dequeued by
797
+ * the application.
798
+ *
799
+ * Immediately after this call, SDL_GetQueuedAudioSize() will return 0. For
800
+ * playback devices, the hardware will start playing silence if more audio
801
+ * isn't queued. Unpaused capture devices will start filling the queue again
802
+ * as soon as they have more data available (which, depending on the state
803
+ * of the hardware and the thread, could be before this function call
804
+ * returns!).
805
+ *
806
+ * This will not prevent playback of queued audio that's already been sent
807
+ * to the hardware, as we can not undo that, so expect there to be some
808
+ * fraction of a second of audio that might still be heard. This can be
809
+ * useful if you want to, say, drop any pending music during a level change
810
+ * in your game.
811
+ *
812
+ * You may not queue audio on a device that is using an application-supplied
813
+ * callback; calling this function on such a device is always a no-op.
814
+ * You have to queue audio with SDL_QueueAudio()/SDL_DequeueAudio(), or use
815
+ * the audio callback, but not both.
816
+ *
817
+ * You should not call SDL_LockAudio() on the device before clearing the
818
+ * queue; SDL handles locking internally for this function.
819
+ *
820
+ * This function always succeeds and thus returns void.
821
+ *
822
+ * \param dev The device ID of which to clear the audio queue.
823
+ *
824
+ * \sa SDL_QueueAudio
825
+ * \sa SDL_GetQueuedAudioSize
826
+ */
827
+ extern DECLSPEC void SDLCALL SDL_ClearQueuedAudio(SDL_AudioDeviceID dev);
828
+
829
+
830
+ /**
831
+ * \name Audio lock functions
832
+ *
833
+ * The lock manipulated by these functions protects the callback function.
834
+ * During a SDL_LockAudio()/SDL_UnlockAudio() pair, you can be guaranteed that
835
+ * the callback function is not running. Do not call these from the callback
836
+ * function or you will cause deadlock.
837
+ */
838
+ /* @{ */
839
+ extern DECLSPEC void SDLCALL SDL_LockAudio(void);
840
+ extern DECLSPEC void SDLCALL SDL_LockAudioDevice(SDL_AudioDeviceID dev);
841
+ extern DECLSPEC void SDLCALL SDL_UnlockAudio(void);
842
+ extern DECLSPEC void SDLCALL SDL_UnlockAudioDevice(SDL_AudioDeviceID dev);
843
+ /* @} *//* Audio lock functions */
844
+
845
+ /**
846
+ * This function shuts down audio processing and closes the audio device.
847
+ */
848
+ extern DECLSPEC void SDLCALL SDL_CloseAudio(void);
849
+ extern DECLSPEC void SDLCALL SDL_CloseAudioDevice(SDL_AudioDeviceID dev);
850
+
851
+ /* Ends C function definitions when using C++ */
852
+ #ifdef __cplusplus
853
+ }
854
+ #endif
855
+ #include "close_code.h"
856
+
857
+ #endif /* SDL_audio_h_ */
858
+
859
+ /* vi: set ts=4 sw=4 expandtab: */