1 /*
2  * Updated for 4.9 api inclusion by Ryan Dickie
3  * Originally done by KC/Milan
4  */
5 
6 #ifndef __al_included_allegro5_allegro_audio_h
7 #define __al_included_allegro5_allegro_audio_h
8 
9 #ifdef __cplusplus
10 extern "C" {
11 #endif
12 
13 /* Title: Audio types
14  */
15 
16 #include "allegro5/allegro.h"
17 
18 
19 #if (defined ALLEGRO_MINGW32) || (defined ALLEGRO_MSVC) || (defined ALLEGRO_BCC32)
20    #ifndef ALLEGRO_STATICLINK
21       #ifdef ALLEGRO_KCM_AUDIO_SRC
22          #define _ALLEGRO_KCM_AUDIO_DLL __declspec(dllexport)
23       #else
24          #define _ALLEGRO_KCM_AUDIO_DLL __declspec(dllimport)
25       #endif
26    #else
27       #define _ALLEGRO_KCM_AUDIO_DLL
28    #endif
29 #endif
30 
31 #if defined ALLEGRO_MSVC
32    #define ALLEGRO_KCM_AUDIO_FUNC(type, name, args)      _ALLEGRO_KCM_AUDIO_DLL type __cdecl name args
33 #elif defined ALLEGRO_MINGW32
34    #define ALLEGRO_KCM_AUDIO_FUNC(type, name, args)            extern type name args
35 #elif defined ALLEGRO_BCC32
36    #define ALLEGRO_KCM_AUDIO_FUNC(type, name, args)      extern _ALLEGRO_KCM_AUDIO_DLL type name args
37 #else
38    #define ALLEGRO_KCM_AUDIO_FUNC      AL_FUNC
39 #endif
40 
41 /* Enum: ALLEGRO_AUDIO_EVENT_TYPE
42  */
43 enum ALLEGRO_AUDIO_EVENT_TYPE
44 {
45    /* Internal, used to communicate with acodec. */
46    /* Must be in 512 <= n < 1024 */
47    _KCM_STREAM_FEEDER_QUIT_EVENT_TYPE    = 512,
48    ALLEGRO_EVENT_AUDIO_STREAM_FRAGMENT   = 513,
49    ALLEGRO_EVENT_AUDIO_STREAM_FINISHED   = 514,
50 #if defined(ALLEGRO_UNSTABLE) || defined(ALLEGRO_INTERNAL_UNSTABLE) || defined(ALLEGRO_KCM_AUDIO_SRC)
51    ALLEGRO_EVENT_AUDIO_RECORDER_FRAGMENT = 515,
52 #endif
53 };
54 
55 #if defined(ALLEGRO_UNSTABLE) || defined(ALLEGRO_INTERNAL_UNSTABLE) || defined(ALLEGRO_KCM_AUDIO_SRC)
56 /* Type: ALLEGRO_AUDIO_RECORDER_EVENT
57  */
58 typedef struct ALLEGRO_AUDIO_RECORDER_EVENT ALLEGRO_AUDIO_RECORDER_EVENT;
59 struct ALLEGRO_AUDIO_RECORDER_EVENT
60 {
61    _AL_EVENT_HEADER(struct ALLEGRO_AUDIO_RECORDER)
62    struct ALLEGRO_USER_EVENT_DESCRIPTOR *__internal__descr;
63    void *buffer;
64    unsigned int samples;
65 };
66 #endif
67 
68 
69 /* Enum: ALLEGRO_AUDIO_DEPTH
70  */
71 enum ALLEGRO_AUDIO_DEPTH
72 {
73    /* Sample depth and type, and signedness. Mixers only use 32-bit signed
74     * float (-1..+1). The unsigned value is a bit-flag applied to the depth
75     * value.
76     */
77    ALLEGRO_AUDIO_DEPTH_INT8      = 0x00,
78    ALLEGRO_AUDIO_DEPTH_INT16     = 0x01,
79    ALLEGRO_AUDIO_DEPTH_INT24     = 0x02,
80    ALLEGRO_AUDIO_DEPTH_FLOAT32   = 0x03,
81 
82    ALLEGRO_AUDIO_DEPTH_UNSIGNED  = 0x08,
83 
84    /* For convenience */
85    ALLEGRO_AUDIO_DEPTH_UINT8  = ALLEGRO_AUDIO_DEPTH_INT8 |
86                                  ALLEGRO_AUDIO_DEPTH_UNSIGNED,
87    ALLEGRO_AUDIO_DEPTH_UINT16 = ALLEGRO_AUDIO_DEPTH_INT16 |
88                                  ALLEGRO_AUDIO_DEPTH_UNSIGNED,
89    ALLEGRO_AUDIO_DEPTH_UINT24 = ALLEGRO_AUDIO_DEPTH_INT24 |
90                                  ALLEGRO_AUDIO_DEPTH_UNSIGNED
91 };
92 
93 
94 /* Enum: ALLEGRO_CHANNEL_CONF
95  */
96 enum ALLEGRO_CHANNEL_CONF
97 {
98    /* Speaker configuration (mono, stereo, 2.1, 3, etc). With regards to
99     * behavior, most of this code makes no distinction between, say, 4.1 and
100     * 5 speaker setups.. they both have 5 "channels". However, users would
101     * like the distinction, and later when the higher-level stuff is added,
102     * the differences will become more important. (v>>4)+(v&0xF) should yield
103     * the total channel count.
104     */
105    ALLEGRO_CHANNEL_CONF_1   = 0x10,
106    ALLEGRO_CHANNEL_CONF_2   = 0x20,
107    ALLEGRO_CHANNEL_CONF_3   = 0x30,
108    ALLEGRO_CHANNEL_CONF_4   = 0x40,
109    ALLEGRO_CHANNEL_CONF_5_1 = 0x51,
110    ALLEGRO_CHANNEL_CONF_6_1 = 0x61,
111    ALLEGRO_CHANNEL_CONF_7_1 = 0x71
112 #define ALLEGRO_MAX_CHANNELS 8
113 };
114 
115 
116 /* Enum: ALLEGRO_PLAYMODE
117  */
118 enum ALLEGRO_PLAYMODE
119 {
120    ALLEGRO_PLAYMODE_ONCE   = 0x100,
121    ALLEGRO_PLAYMODE_LOOP   = 0x101,
122    ALLEGRO_PLAYMODE_BIDIR  = 0x102,
123    _ALLEGRO_PLAYMODE_STREAM_ONCE   = 0x103,   /* internal */
124    _ALLEGRO_PLAYMODE_STREAM_ONEDIR = 0x104    /* internal */
125 };
126 
127 
128 /* Enum: ALLEGRO_MIXER_QUALITY
129  */
130 enum ALLEGRO_MIXER_QUALITY
131 {
132    ALLEGRO_MIXER_QUALITY_POINT   = 0x110,
133    ALLEGRO_MIXER_QUALITY_LINEAR  = 0x111,
134    ALLEGRO_MIXER_QUALITY_CUBIC   = 0x112
135 };
136 
137 
138 /* Enum: ALLEGRO_AUDIO_PAN_NONE
139  */
140 #define ALLEGRO_AUDIO_PAN_NONE      (-1000.0f)
141 
142 /* Type: ALLEGRO_SAMPLE
143  */
144 typedef struct ALLEGRO_SAMPLE ALLEGRO_SAMPLE;
145 
146 
147 /* Type: ALLEGRO_SAMPLE_ID
148  */
149 typedef struct ALLEGRO_SAMPLE_ID ALLEGRO_SAMPLE_ID;
150 
151 struct ALLEGRO_SAMPLE_ID {
152    int _index;
153    int _id;
154 };
155 
156 
157 /* Type: ALLEGRO_SAMPLE_INSTANCE
158  */
159 typedef struct ALLEGRO_SAMPLE_INSTANCE ALLEGRO_SAMPLE_INSTANCE;
160 
161 
162 /* Type: ALLEGRO_AUDIO_STREAM
163  */
164 typedef struct ALLEGRO_AUDIO_STREAM ALLEGRO_AUDIO_STREAM;
165 
166 
167 /* Type: ALLEGRO_MIXER
168  */
169 typedef struct ALLEGRO_MIXER ALLEGRO_MIXER;
170 
171 
172 /* Type: ALLEGRO_VOICE
173  */
174 typedef struct ALLEGRO_VOICE ALLEGRO_VOICE;
175 
176 
177 #if defined(ALLEGRO_UNSTABLE) || defined(ALLEGRO_INTERNAL_UNSTABLE) || defined(ALLEGRO_KCM_AUDIO_SRC)
178 /* Type: ALLEGRO_AUDIO_RECORDER
179  */
180 typedef struct ALLEGRO_AUDIO_RECORDER ALLEGRO_AUDIO_RECORDER;
181 #endif
182 
183 
184 #ifndef __cplusplus
185 typedef enum ALLEGRO_AUDIO_DEPTH ALLEGRO_AUDIO_DEPTH;
186 typedef enum ALLEGRO_CHANNEL_CONF ALLEGRO_CHANNEL_CONF;
187 typedef enum ALLEGRO_PLAYMODE ALLEGRO_PLAYMODE;
188 typedef enum ALLEGRO_MIXER_QUALITY ALLEGRO_MIXER_QUALITY;
189 #endif
190 
191 
192 /* Sample functions */
193 
194 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_SAMPLE *, al_create_sample, (void *buf,
195       unsigned int samples, unsigned int freq, ALLEGRO_AUDIO_DEPTH depth,
196       ALLEGRO_CHANNEL_CONF chan_conf, bool free_buf));
197 ALLEGRO_KCM_AUDIO_FUNC(void, al_destroy_sample, (ALLEGRO_SAMPLE *spl));
198 
199 
200 /* Sample instance functions */
201 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_SAMPLE_INSTANCE*, al_create_sample_instance, (
202       ALLEGRO_SAMPLE *data));
203 ALLEGRO_KCM_AUDIO_FUNC(void, al_destroy_sample_instance, (
204       ALLEGRO_SAMPLE_INSTANCE *spl));
205 
206 ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_sample_frequency, (const ALLEGRO_SAMPLE *spl));
207 ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_sample_length, (const ALLEGRO_SAMPLE *spl));
208 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_DEPTH, al_get_sample_depth, (const ALLEGRO_SAMPLE *spl));
209 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_CHANNEL_CONF, al_get_sample_channels, (const ALLEGRO_SAMPLE *spl));
210 ALLEGRO_KCM_AUDIO_FUNC(void *, al_get_sample_data, (const ALLEGRO_SAMPLE *spl));
211 
212 ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_sample_instance_frequency, (const ALLEGRO_SAMPLE_INSTANCE *spl));
213 ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_sample_instance_length, (const ALLEGRO_SAMPLE_INSTANCE *spl));
214 ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_sample_instance_position, (const ALLEGRO_SAMPLE_INSTANCE *spl));
215 
216 ALLEGRO_KCM_AUDIO_FUNC(float, al_get_sample_instance_speed, (const ALLEGRO_SAMPLE_INSTANCE *spl));
217 ALLEGRO_KCM_AUDIO_FUNC(float, al_get_sample_instance_gain, (const ALLEGRO_SAMPLE_INSTANCE *spl));
218 ALLEGRO_KCM_AUDIO_FUNC(float, al_get_sample_instance_pan, (const ALLEGRO_SAMPLE_INSTANCE *spl));
219 ALLEGRO_KCM_AUDIO_FUNC(float, al_get_sample_instance_time, (const ALLEGRO_SAMPLE_INSTANCE *spl));
220 
221 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_DEPTH, al_get_sample_instance_depth, (const ALLEGRO_SAMPLE_INSTANCE *spl));
222 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_CHANNEL_CONF, al_get_sample_instance_channels, (const ALLEGRO_SAMPLE_INSTANCE *spl));
223 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_PLAYMODE, al_get_sample_instance_playmode, (const ALLEGRO_SAMPLE_INSTANCE *spl));
224 
225 ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_sample_instance_playing, (const ALLEGRO_SAMPLE_INSTANCE *spl));
226 ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_sample_instance_attached, (const ALLEGRO_SAMPLE_INSTANCE *spl));
227 
228 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_position, (ALLEGRO_SAMPLE_INSTANCE *spl, unsigned int val));
229 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_length, (ALLEGRO_SAMPLE_INSTANCE *spl, unsigned int val));
230 
231 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_speed, (ALLEGRO_SAMPLE_INSTANCE *spl, float val));
232 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_gain, (ALLEGRO_SAMPLE_INSTANCE *spl, float val));
233 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_pan, (ALLEGRO_SAMPLE_INSTANCE *spl, float val));
234 
235 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_playmode, (ALLEGRO_SAMPLE_INSTANCE *spl, ALLEGRO_PLAYMODE val));
236 
237 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_playing, (ALLEGRO_SAMPLE_INSTANCE *spl, bool val));
238 ALLEGRO_KCM_AUDIO_FUNC(bool, al_detach_sample_instance, (ALLEGRO_SAMPLE_INSTANCE *spl));
239 
240 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample, (ALLEGRO_SAMPLE_INSTANCE *spl, ALLEGRO_SAMPLE *data));
241 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_SAMPLE *, al_get_sample, (ALLEGRO_SAMPLE_INSTANCE *spl));
242 ALLEGRO_KCM_AUDIO_FUNC(bool, al_play_sample_instance, (ALLEGRO_SAMPLE_INSTANCE *spl));
243 ALLEGRO_KCM_AUDIO_FUNC(bool, al_stop_sample_instance, (ALLEGRO_SAMPLE_INSTANCE *spl));
244 #if defined(ALLEGRO_UNSTABLE) || defined(ALLEGRO_INTERNAL_UNSTABLE) || defined(ALLEGRO_KCM_AUDIO_SRC)
245 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_sample_instance_channel_matrix, (ALLEGRO_SAMPLE_INSTANCE *spl, const float *matrix));
246 #endif
247 
248 
249 /* Stream functions */
250 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_STREAM*, al_create_audio_stream, (size_t buffer_count,
251       unsigned int samples, unsigned int freq,
252       ALLEGRO_AUDIO_DEPTH depth, ALLEGRO_CHANNEL_CONF chan_conf));
253 ALLEGRO_KCM_AUDIO_FUNC(void, al_destroy_audio_stream, (ALLEGRO_AUDIO_STREAM *stream));
254 ALLEGRO_KCM_AUDIO_FUNC(void, al_drain_audio_stream, (ALLEGRO_AUDIO_STREAM *stream));
255 
256 ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_audio_stream_frequency, (const ALLEGRO_AUDIO_STREAM *stream));
257 ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_audio_stream_length, (const ALLEGRO_AUDIO_STREAM *stream));
258 ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_audio_stream_fragments, (const ALLEGRO_AUDIO_STREAM *stream));
259 ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_available_audio_stream_fragments, (const ALLEGRO_AUDIO_STREAM *stream));
260 
261 ALLEGRO_KCM_AUDIO_FUNC(float, al_get_audio_stream_speed, (const ALLEGRO_AUDIO_STREAM *stream));
262 ALLEGRO_KCM_AUDIO_FUNC(float, al_get_audio_stream_gain, (const ALLEGRO_AUDIO_STREAM *stream));
263 ALLEGRO_KCM_AUDIO_FUNC(float, al_get_audio_stream_pan, (const ALLEGRO_AUDIO_STREAM *stream));
264 
265 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_CHANNEL_CONF, al_get_audio_stream_channels, (const ALLEGRO_AUDIO_STREAM *stream));
266 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_DEPTH, al_get_audio_stream_depth, (const ALLEGRO_AUDIO_STREAM *stream));
267 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_PLAYMODE, al_get_audio_stream_playmode, (const ALLEGRO_AUDIO_STREAM *stream));
268 
269 ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_audio_stream_playing, (const ALLEGRO_AUDIO_STREAM *spl));
270 ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_audio_stream_attached, (const ALLEGRO_AUDIO_STREAM *spl));
271 ALLEGRO_KCM_AUDIO_FUNC(uint64_t, al_get_audio_stream_played_samples, (const ALLEGRO_AUDIO_STREAM *stream));
272 
273 ALLEGRO_KCM_AUDIO_FUNC(void *, al_get_audio_stream_fragment, (const ALLEGRO_AUDIO_STREAM *stream));
274 
275 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_speed, (ALLEGRO_AUDIO_STREAM *stream, float val));
276 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_gain, (ALLEGRO_AUDIO_STREAM *stream, float val));
277 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_pan, (ALLEGRO_AUDIO_STREAM *stream, float val));
278 
279 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_playmode, (ALLEGRO_AUDIO_STREAM *stream, ALLEGRO_PLAYMODE val));
280 
281 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_playing, (ALLEGRO_AUDIO_STREAM *stream, bool val));
282 ALLEGRO_KCM_AUDIO_FUNC(bool, al_detach_audio_stream, (ALLEGRO_AUDIO_STREAM *stream));
283 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_fragment, (ALLEGRO_AUDIO_STREAM *stream, void *val));
284 
285 ALLEGRO_KCM_AUDIO_FUNC(bool, al_rewind_audio_stream, (ALLEGRO_AUDIO_STREAM *stream));
286 ALLEGRO_KCM_AUDIO_FUNC(bool, al_seek_audio_stream_secs, (ALLEGRO_AUDIO_STREAM *stream, double time));
287 ALLEGRO_KCM_AUDIO_FUNC(double, al_get_audio_stream_position_secs, (ALLEGRO_AUDIO_STREAM *stream));
288 ALLEGRO_KCM_AUDIO_FUNC(double, al_get_audio_stream_length_secs, (ALLEGRO_AUDIO_STREAM *stream));
289 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_loop_secs, (ALLEGRO_AUDIO_STREAM *stream, double start, double end));
290 
291 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_EVENT_SOURCE *, al_get_audio_stream_event_source, (ALLEGRO_AUDIO_STREAM *stream));
292 
293 #if defined(ALLEGRO_UNSTABLE) || defined(ALLEGRO_INTERNAL_UNSTABLE) || defined(ALLEGRO_KCM_AUDIO_SRC)
294 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_audio_stream_channel_matrix, (ALLEGRO_AUDIO_STREAM *stream, const float *matrix));
295 #endif
296 
297 /* Mixer functions */
298 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_MIXER*, al_create_mixer, (unsigned int freq,
299       ALLEGRO_AUDIO_DEPTH depth, ALLEGRO_CHANNEL_CONF chan_conf));
300 ALLEGRO_KCM_AUDIO_FUNC(void, al_destroy_mixer, (ALLEGRO_MIXER *mixer));
301 ALLEGRO_KCM_AUDIO_FUNC(bool, al_attach_sample_instance_to_mixer, (
302    ALLEGRO_SAMPLE_INSTANCE *stream, ALLEGRO_MIXER *mixer));
303 ALLEGRO_KCM_AUDIO_FUNC(bool, al_attach_audio_stream_to_mixer, (ALLEGRO_AUDIO_STREAM *stream,
304    ALLEGRO_MIXER *mixer));
305 ALLEGRO_KCM_AUDIO_FUNC(bool, al_attach_mixer_to_mixer, (ALLEGRO_MIXER *stream,
306    ALLEGRO_MIXER *mixer));
307 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_mixer_postprocess_callback, (
308       ALLEGRO_MIXER *mixer,
309       void (*cb)(void *buf, unsigned int samples, void *data),
310       void *data));
311 
312 ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_mixer_frequency, (const ALLEGRO_MIXER *mixer));
313 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_CHANNEL_CONF, al_get_mixer_channels, (const ALLEGRO_MIXER *mixer));
314 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_DEPTH, al_get_mixer_depth, (const ALLEGRO_MIXER *mixer));
315 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_MIXER_QUALITY, al_get_mixer_quality, (const ALLEGRO_MIXER *mixer));
316 ALLEGRO_KCM_AUDIO_FUNC(float, al_get_mixer_gain, (const ALLEGRO_MIXER *mixer));
317 ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_mixer_playing, (const ALLEGRO_MIXER *mixer));
318 ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_mixer_attached, (const ALLEGRO_MIXER *mixer));
319 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_mixer_frequency, (ALLEGRO_MIXER *mixer, unsigned int val));
320 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_mixer_quality, (ALLEGRO_MIXER *mixer, ALLEGRO_MIXER_QUALITY val));
321 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_mixer_gain, (ALLEGRO_MIXER *mixer, float gain));
322 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_mixer_playing, (ALLEGRO_MIXER *mixer, bool val));
323 ALLEGRO_KCM_AUDIO_FUNC(bool, al_detach_mixer, (ALLEGRO_MIXER *mixer));
324 
325 /* Voice functions */
326 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_VOICE*, al_create_voice, (unsigned int freq,
327       ALLEGRO_AUDIO_DEPTH depth,
328       ALLEGRO_CHANNEL_CONF chan_conf));
329 ALLEGRO_KCM_AUDIO_FUNC(void, al_destroy_voice, (ALLEGRO_VOICE *voice));
330 ALLEGRO_KCM_AUDIO_FUNC(bool, al_attach_sample_instance_to_voice, (
331    ALLEGRO_SAMPLE_INSTANCE *stream, ALLEGRO_VOICE *voice));
332 ALLEGRO_KCM_AUDIO_FUNC(bool, al_attach_audio_stream_to_voice, (
333    ALLEGRO_AUDIO_STREAM *stream, ALLEGRO_VOICE *voice ));
334 ALLEGRO_KCM_AUDIO_FUNC(bool, al_attach_mixer_to_voice, (ALLEGRO_MIXER *mixer,
335    ALLEGRO_VOICE *voice));
336 ALLEGRO_KCM_AUDIO_FUNC(void, al_detach_voice, (ALLEGRO_VOICE *voice));
337 
338 ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_voice_frequency, (const ALLEGRO_VOICE *voice));
339 ALLEGRO_KCM_AUDIO_FUNC(unsigned int, al_get_voice_position, (const ALLEGRO_VOICE *voice));
340 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_CHANNEL_CONF, al_get_voice_channels, (const ALLEGRO_VOICE *voice));
341 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_DEPTH, al_get_voice_depth, (const ALLEGRO_VOICE *voice));
342 ALLEGRO_KCM_AUDIO_FUNC(bool, al_get_voice_playing, (const ALLEGRO_VOICE *voice));
343 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_voice_position, (ALLEGRO_VOICE *voice, unsigned int val));
344 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_voice_playing, (ALLEGRO_VOICE *voice, bool val));
345 
346 /* Misc. audio functions */
347 ALLEGRO_KCM_AUDIO_FUNC(bool, al_install_audio, (void));
348 ALLEGRO_KCM_AUDIO_FUNC(void, al_uninstall_audio, (void));
349 ALLEGRO_KCM_AUDIO_FUNC(bool, al_is_audio_installed, (void));
350 ALLEGRO_KCM_AUDIO_FUNC(uint32_t, al_get_allegro_audio_version, (void));
351 
352 ALLEGRO_KCM_AUDIO_FUNC(size_t, al_get_channel_count, (ALLEGRO_CHANNEL_CONF conf));
353 ALLEGRO_KCM_AUDIO_FUNC(size_t, al_get_audio_depth_size, (ALLEGRO_AUDIO_DEPTH conf));
354 
355 ALLEGRO_KCM_AUDIO_FUNC(void, al_fill_silence, (void *buf, unsigned int samples,
356       ALLEGRO_AUDIO_DEPTH depth, ALLEGRO_CHANNEL_CONF chan_conf));
357 
358 /* Simple audio layer */
359 ALLEGRO_KCM_AUDIO_FUNC(bool, al_reserve_samples, (int reserve_samples));
360 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_MIXER *, al_get_default_mixer, (void));
361 ALLEGRO_KCM_AUDIO_FUNC(bool, al_set_default_mixer, (ALLEGRO_MIXER *mixer));
362 ALLEGRO_KCM_AUDIO_FUNC(bool, al_restore_default_mixer, (void));
363 ALLEGRO_KCM_AUDIO_FUNC(bool, al_play_sample, (ALLEGRO_SAMPLE *data,
364       float gain, float pan, float speed, ALLEGRO_PLAYMODE loop, ALLEGRO_SAMPLE_ID *ret_id));
365 ALLEGRO_KCM_AUDIO_FUNC(void, al_stop_sample, (ALLEGRO_SAMPLE_ID *spl_id));
366 ALLEGRO_KCM_AUDIO_FUNC(void, al_stop_samples, (void));
367 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_VOICE *, al_get_default_voice, (void));
368 ALLEGRO_KCM_AUDIO_FUNC(void, al_set_default_voice, (ALLEGRO_VOICE *voice));
369 
370 #if defined(ALLEGRO_UNSTABLE) || defined(ALLEGRO_INTERNAL_UNSTABLE) || defined(ALLEGRO_KCM_AUDIO_SRC)
371 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_SAMPLE_INSTANCE*, al_lock_sample_id, (ALLEGRO_SAMPLE_ID *spl_id));
372 ALLEGRO_KCM_AUDIO_FUNC(void, al_unlock_sample_id, (ALLEGRO_SAMPLE_ID *spl_id));
373 #endif
374 
375 /* File type handlers */
376 ALLEGRO_KCM_AUDIO_FUNC(bool, al_register_sample_loader, (const char *ext,
377 	ALLEGRO_SAMPLE *(*loader)(const char *filename)));
378 ALLEGRO_KCM_AUDIO_FUNC(bool, al_register_sample_saver, (const char *ext,
379 	bool (*saver)(const char *filename, ALLEGRO_SAMPLE *spl)));
380 ALLEGRO_KCM_AUDIO_FUNC(bool, al_register_audio_stream_loader, (const char *ext,
381 	ALLEGRO_AUDIO_STREAM *(*stream_loader)(const char *filename,
382 	    size_t buffer_count, unsigned int samples)));
383 
384 ALLEGRO_KCM_AUDIO_FUNC(bool, al_register_sample_loader_f, (const char *ext,
385 	ALLEGRO_SAMPLE *(*loader)(ALLEGRO_FILE *fp)));
386 ALLEGRO_KCM_AUDIO_FUNC(bool, al_register_sample_saver_f, (const char *ext,
387 	bool (*saver)(ALLEGRO_FILE *fp, ALLEGRO_SAMPLE *spl)));
388 ALLEGRO_KCM_AUDIO_FUNC(bool, al_register_audio_stream_loader_f, (const char *ext,
389 	ALLEGRO_AUDIO_STREAM *(*stream_loader)(ALLEGRO_FILE *fp,
390 	    size_t buffer_count, unsigned int samples)));
391 
392 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_SAMPLE *, al_load_sample, (const char *filename));
393 ALLEGRO_KCM_AUDIO_FUNC(bool, al_save_sample, (const char *filename,
394 	ALLEGRO_SAMPLE *spl));
395 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_STREAM *, al_load_audio_stream, (const char *filename,
396 	size_t buffer_count, unsigned int samples));
397 
398 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_SAMPLE *, al_load_sample_f, (ALLEGRO_FILE* fp, const char *ident));
399 ALLEGRO_KCM_AUDIO_FUNC(bool, al_save_sample_f, (ALLEGRO_FILE* fp, const char *ident,
400 	ALLEGRO_SAMPLE *spl));
401 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_STREAM *, al_load_audio_stream_f, (ALLEGRO_FILE* fp, const char *ident,
402 	size_t buffer_count, unsigned int samples));
403 
404 
405 #if defined(ALLEGRO_UNSTABLE) || defined(ALLEGRO_INTERNAL_UNSTABLE) || defined(ALLEGRO_KCM_AUDIO_SRC)
406 
407 /* Recording functions */
408 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_RECORDER *, al_create_audio_recorder, (size_t fragment_count,
409    unsigned int samples, unsigned int freq, ALLEGRO_AUDIO_DEPTH depth, ALLEGRO_CHANNEL_CONF chan_conf));
410 ALLEGRO_KCM_AUDIO_FUNC(bool, al_start_audio_recorder, (ALLEGRO_AUDIO_RECORDER *r));
411 ALLEGRO_KCM_AUDIO_FUNC(void, al_stop_audio_recorder, (ALLEGRO_AUDIO_RECORDER *r));
412 ALLEGRO_KCM_AUDIO_FUNC(bool, al_is_audio_recorder_recording, (ALLEGRO_AUDIO_RECORDER *r));
413 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_EVENT_SOURCE *, al_get_audio_recorder_event_source,
414    (ALLEGRO_AUDIO_RECORDER *r));
415 ALLEGRO_KCM_AUDIO_FUNC(ALLEGRO_AUDIO_RECORDER_EVENT *, al_get_audio_recorder_event, (ALLEGRO_EVENT *event));
416 ALLEGRO_KCM_AUDIO_FUNC(void, al_destroy_audio_recorder, (ALLEGRO_AUDIO_RECORDER *r));
417 
418 #endif
419 
420 #ifdef __cplusplus
421 } /* End extern "C" */
422 #endif
423 
424 #endif
425 
426 
427 /* vim: set sts=3 sw=3 et: */
428