svn merge -r39781:39792 https://svn.blender.org/svnroot/bf-blender/trunk/blender...
[blender-staging.git] / intern / audaspace / intern / AUD_C-API.h
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * Copyright 2009-2011 Jörg Hermann Müller
7  *
8  * This file is part of AudaSpace.
9  *
10  * Audaspace is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * AudaSpace is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with Audaspace; if not, write to the Free Software Foundation,
22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file AUD_C-API.h
28  *  \ingroup audaspace
29  */
30  
31 #ifndef AUD_CAPI
32 #define AUD_CAPI
33
34 #ifdef WITH_PYTHON
35 #include "Python.h"
36 #endif
37
38 #ifdef __cplusplus
39 extern "C" {
40 #endif
41
42 #include "AUD_Space.h"
43
44 /// Supported output devices.
45 typedef enum
46 {
47         AUD_NULL_DEVICE = 0,
48         AUD_SDL_DEVICE,
49         AUD_OPENAL_DEVICE,
50         AUD_JACK_DEVICE
51 } AUD_DeviceType;
52
53 /// Sound information structure.
54 typedef struct
55 {
56         AUD_Specs specs;
57         float length;
58 } AUD_SoundInfo;
59
60 #ifndef AUD_CAPI_IMPLEMENTATION
61         typedef void AUD_Sound;
62         typedef void AUD_Handle;
63         typedef void AUD_Device;
64         typedef void AUD_SEntry;
65         typedef float (*AUD_volumeFunction)(void*, void*, float);
66         typedef void (*AUD_syncFunction)(void*, int, float);
67 #endif
68
69 /**
70  * Initializes FFMPEG if it is enabled.
71  */
72 extern void AUD_initOnce(void);
73
74 /**
75  * Initializes an audio device.
76  * \param device The device type that should be used.
77  * \param specs The audio specification to be used.
78  * \param buffersize The buffersize for the device.
79  * \return Whether the device has been initialized.
80  */
81 extern int AUD_init(AUD_DeviceType device, AUD_DeviceSpecs specs, int buffersize);
82
83 /**
84  * Unitinitializes an audio device.
85  */
86 extern void AUD_exit(void);
87
88 /**
89  * Locks the playback device.
90  */
91 extern void AUD_lock(void);
92
93 /**
94  * Unlocks the device.
95  */
96 extern void AUD_unlock(void);
97
98 /**
99  * Returns information about a sound.
100  * \param sound The sound to get the info about.
101  * \return The AUD_SoundInfo structure with filled in data.
102  */
103 extern AUD_SoundInfo AUD_getInfo(AUD_Sound* sound);
104
105 /**
106  * Loads a sound file.
107  * \param filename The filename of the sound file.
108  * \return A handle of the sound file.
109  */
110 extern AUD_Sound* AUD_load(const char* filename);
111
112 /**
113  * Loads a sound file.
114  * \param buffer The buffer which contains the sound file.
115  * \param size The size of the buffer.
116  * \return A handle of the sound file.
117  */
118 extern AUD_Sound* AUD_loadBuffer(unsigned char* buffer, int size);
119
120 /**
121  * Buffers a sound.
122  * \param sound The sound to buffer.
123  * \return A handle of the sound buffer.
124  */
125 extern AUD_Sound* AUD_bufferSound(AUD_Sound* sound);
126
127 /**
128  * Rechannels the sound to be mono.
129  * \param sound The sound to rechannel.
130  * \return The mono sound.
131  */
132 extern AUD_Sound* AUD_monoSound(AUD_Sound* sound);
133
134 /**
135  * Delays a sound.
136  * \param sound The sound to dealy.
137  * \param delay The delay in seconds.
138  * \return A handle of the delayed sound.
139  */
140 extern AUD_Sound* AUD_delaySound(AUD_Sound* sound, float delay);
141
142 /**
143  * Limits a sound.
144  * \param sound The sound to limit.
145  * \param start The start time in seconds.
146  * \param end The stop time in seconds.
147  * \return A handle of the limited sound.
148  */
149 extern AUD_Sound* AUD_limitSound(AUD_Sound* sound, float start, float end);
150
151 /**
152  * Ping pongs a sound.
153  * \param sound The sound to ping pong.
154  * \return A handle of the ping pong sound.
155  */
156 extern AUD_Sound* AUD_pingpongSound(AUD_Sound* sound);
157
158 /**
159  * Loops a sound.
160  * \param sound The sound to loop.
161  * \return A handle of the looped sound.
162  */
163 extern AUD_Sound* AUD_loopSound(AUD_Sound* sound);
164
165 /**
166  * Sets a remaining loop count of a looping sound that currently plays.
167  * \param handle The playback handle.
168  * \param loops The count of remaining loops, -1 for infinity.
169  * \return Whether the handle is valid.
170  */
171 extern int AUD_setLoop(AUD_Handle* handle, int loops);
172
173 /**
174  * Rectifies a sound.
175  * \param sound The sound to rectify.
176  * \return A handle of the rectified sound.
177  */
178 extern AUD_Sound* AUD_rectifySound(AUD_Sound* sound);
179
180 /**
181  * Unloads a sound of any type.
182  * \param sound The handle of the sound.
183  */
184 extern void AUD_unload(AUD_Sound* sound);
185
186 /**
187  * Plays back a sound file.
188  * \param sound The handle of the sound file.
189  * \param keep When keep is true the sound source will not be deleted but set to
190  *             paused when its end has been reached.
191  * \return A handle to the played back sound.
192  */
193 extern AUD_Handle* AUD_play(AUD_Sound* sound, int keep);
194
195 /**
196  * Pauses a played back sound.
197  * \param handle The handle to the sound.
198  * \return Whether the handle has been playing or not.
199  */
200 extern int AUD_pause(AUD_Handle* handle);
201
202 /**
203  * Resumes a paused sound.
204  * \param handle The handle to the sound.
205  * \return Whether the handle has been paused or not.
206  */
207 extern int AUD_resume(AUD_Handle* handle);
208
209 /**
210  * Stops a playing or paused sound.
211  * \param handle The handle to the sound.
212  * \return Whether the handle has been valid or not.
213  */
214 extern int AUD_stop(AUD_Handle* handle);
215
216 /**
217  * Sets the end behaviour of a playing or paused sound.
218  * \param handle The handle to the sound.
219  * \param keep When keep is true the sound source will not be deleted but set to
220  *             paused when its end has been reached.
221  * \return Whether the handle has been valid or not.
222  */
223 extern int AUD_setKeep(AUD_Handle* handle, int keep);
224
225 /**
226  * Seeks a playing or paused sound.
227  * \param handle The handle to the sound.
228  * \param seekTo From where the sound file should be played back in seconds.
229  * \return Whether the handle has been valid or not.
230  */
231 extern int AUD_seek(AUD_Handle* handle, float seekTo);
232
233 /**
234  * Retrieves the playback position of a handle.
235  * \param handle The handle to the sound.
236  * \return The current playback position in seconds or 0.0 if the handle is
237  *         invalid.
238  */
239 extern float AUD_getPosition(AUD_Handle* handle);
240
241 /**
242  * Returns the status of a playing, paused or stopped sound.
243  * \param handle The handle to the sound.
244  * \return The status of the sound behind the handle.
245  */
246 extern AUD_Status AUD_getStatus(AUD_Handle* handle);
247
248 /**
249  * Sets the listener location.
250  * \param location The new location.
251  */
252 extern int AUD_setListenerLocation(const float* location);
253
254 /**
255  * Sets the listener velocity.
256  * \param velocity The new velocity.
257  */
258 extern int AUD_setListenerVelocity(const float* velocity);
259
260 /**
261  * Sets the listener orientation.
262  * \param orientation The new orientation as quaternion.
263  */
264 extern int AUD_setListenerOrientation(const float* orientation);
265
266 /**
267  * Sets the speed of sound.
268  * This value is needed for doppler effect calculation.
269  * \param speed The new speed of sound.
270  */
271 extern int AUD_setSpeedOfSound(float speed);
272
273 /**
274  * Sets the doppler factor.
275  * This value is a scaling factor for the velocity vectors of sources and
276  * listener which is used while calculating the doppler effect.
277  * \param factor The new doppler factor.
278  */
279 extern int AUD_setDopplerFactor(float factor);
280
281 /**
282  * Sets the distance model.
283  * \param model distance model.
284  */
285 extern int AUD_setDistanceModel(AUD_DistanceModel model);
286
287 /**
288  * Sets the location of a source.
289  * \param handle The handle of the source.
290  * \param location The new location.
291  * \return Whether the action succeeded.
292  */
293 extern int AUD_setSourceLocation(AUD_Handle* handle, const float* location);
294
295 /**
296  * Sets the velocity of a source.
297  * \param handle The handle of the source.
298  * \param velocity The new velocity.
299  * \return Whether the action succeeded.
300  */
301 extern int AUD_setSourceVelocity(AUD_Handle* handle, const float* velocity);
302
303 /**
304  * Sets the orientation of a source.
305  * \param handle The handle of the source.
306  * \param orientation The new orientation as quaternion.
307  * \return Whether the action succeeded.
308  */
309 extern int AUD_setSourceOrientation(AUD_Handle* handle, const float* orientation);
310
311 /**
312  * Sets whether the source location, velocity and orientation are relative
313  * to the listener.
314  * \param handle The handle of the source.
315  * \param relative Whether the source is relative.
316  * \return Whether the action succeeded.
317  */
318 extern int AUD_setRelative(AUD_Handle* handle, int relative);
319
320 /**
321  * Sets the maximum volume of a source.
322  * \param handle The handle of the source.
323  * \param volume The new maximum volume.
324  * \return Whether the action succeeded.
325  */
326 extern int AUD_setVolumeMaximum(AUD_Handle* handle, float volume);
327
328 /**
329  * Sets the minimum volume of a source.
330  * \param handle The handle of the source.
331  * \param volume The new minimum volume.
332  * \return Whether the action succeeded.
333  */
334 extern int AUD_setVolumeMinimum(AUD_Handle* handle, float volume);
335
336 /**
337  * Sets the maximum distance of a source.
338  * If a source is further away from the reader than this distance, the
339  * volume will automatically be set to 0.
340  * \param handle The handle of the source.
341  * \param distance The new maximum distance.
342  * \return Whether the action succeeded.
343  */
344 extern int AUD_setDistanceMaximum(AUD_Handle* handle, float distance);
345
346 /**
347  * Sets the reference distance of a source.
348  * \param handle The handle of the source.
349  * \param distance The new reference distance.
350  * \return Whether the action succeeded.
351  */
352 extern int AUD_setDistanceReference(AUD_Handle* handle, float distance);
353
354 /**
355  * Sets the attenuation of a source.
356  * This value is used for distance calculation.
357  * \param handle The handle of the source.
358  * \param factor The new attenuation.
359  * \return Whether the action succeeded.
360  */
361 extern int AUD_setAttenuation(AUD_Handle* handle, float factor);
362
363 /**
364  * Sets the outer angle of the cone of a source.
365  * \param handle The handle of the source.
366  * \param angle The new outer angle of the cone.
367  * \return Whether the action succeeded.
368  */
369 extern int AUD_setConeAngleOuter(AUD_Handle* handle, float angle);
370
371 /**
372  * Sets the inner angle of the cone of a source.
373  * \param handle The handle of the source.
374  * \param angle The new inner angle of the cone.
375  * \return Whether the action succeeded.
376  */
377 extern int AUD_setConeAngleInner(AUD_Handle* handle, float angle);
378
379 /**
380  * Sets the outer volume of the cone of a source.
381  * The volume between inner and outer angle is interpolated between inner
382  * volume and this value.
383  * \param handle The handle of the source.
384  * \param volume The new outer volume of the cone.
385  * \return Whether the action succeeded.
386  */
387 extern int AUD_setConeVolumeOuter(AUD_Handle* handle, float volume);
388
389 /**
390  * Sets the volume of a played back sound.
391  * \param handle The handle to the sound.
392  * \param volume The new volume, must be between 0.0 and 1.0.
393  * \return Whether the action succeeded.
394  */
395 extern int AUD_setSoundVolume(AUD_Handle* handle, float volume);
396
397 /**
398  * Sets the pitch of a played back sound.
399  * \param handle The handle to the sound.
400  * \param pitch The new pitch.
401  * \return Whether the action succeeded.
402  */
403 extern int AUD_setSoundPitch(AUD_Handle* handle, float pitch);
404
405 /**
406  * Opens a read device, with which audio data can be read.
407  * \param specs The specification of the audio data.
408  * \return A device handle.
409  */
410 extern AUD_Device* AUD_openReadDevice(AUD_DeviceSpecs specs);
411
412 /**
413  * Sets the main volume of a device.
414  * \param device The device.
415  * \param volume The new volume, must be between 0.0 and 1.0.
416  * \return Whether the action succeeded.
417  */
418 extern int AUD_setDeviceVolume(AUD_Device* device, float volume);
419
420 /**
421  * Plays back a sound file through a read device.
422  * \param device The read device.
423  * \param sound The handle of the sound file.
424  * \param seek The position where the sound should be seeked to.
425  * \return A handle to the played back sound.
426  */
427 extern AUD_Handle* AUD_playDevice(AUD_Device* device, AUD_Sound* sound, float seek);
428
429 /**
430  * Reads the next samples into the supplied buffer.
431  * \param device The read device.
432  * \param buffer The target buffer.
433  * \param length The length in samples to be filled.
434  * \return True if the reading succeeded, false if there are no sounds
435  *         played back currently, in that case the buffer is filled with
436  *         silence.
437  */
438 extern int AUD_readDevice(AUD_Device* device, data_t* buffer, int length);
439
440 /**
441  * Closes a read device.
442  * \param device The read device.
443  */
444 extern void AUD_closeReadDevice(AUD_Device* device);
445
446 /**
447  * Reads a sound file into a newly created float buffer.
448  * The sound is therefore bandpassed, rectified and resampled.
449  */
450 extern float* AUD_readSoundBuffer(const char* filename, float low, float high,
451                                                                   float attack, float release, float threshold,
452                                                                   int accumulate, int additive, int square,
453                                                                   float sthreshold, double samplerate,
454                                                                   int* length);
455
456 /**
457  * Pauses a playing sound after a specific amount of time.
458  * \param handle The handle to the sound.
459  * \param time The time in seconds.
460  * \return The silence handle.
461  */
462 extern AUD_Handle* AUD_pauseAfter(AUD_Handle* handle, float seconds);
463
464 /**
465  * Creates a new sequenced sound scene.
466  * \param fps The FPS of the scene.
467  * \param muted Whether the scene is muted.
468  * \return The new sound scene.
469  */
470 extern AUD_Sound* AUD_createSequencer(float fps, int muted);
471
472 /**
473  * Deletes a sound scene.
474  * \param sequencer The sound scene.
475  */
476 extern void AUD_destroySequencer(AUD_Sound* sequencer);
477
478 /**
479  * Sets the muting state of the scene.
480  * \param sequencer The sound scene.
481  * \param muted Whether the scene is muted.
482  */
483 extern void AUD_setSequencerMuted(AUD_Sound* sequencer, int muted);
484
485 /**
486  * Sets the scene's FPS.
487  * \param sequencer The sound scene.
488  * \param fps The new FPS.
489  */
490 extern void AUD_setSequencerFPS(AUD_Sound* sequencer, float fps);
491
492 /**
493  * Adds a new entry to the scene.
494  * \param sequencer The sound scene.
495  * \param sound The sound this entry should play.
496  * \param begin The start time.
497  * \param end The end time or a negative value if determined by the sound.
498  * \param skip How much seconds should be skipped at the beginning.
499  * \return The entry added.
500  */
501 extern AUD_SEntry* AUD_addSequence(AUD_Sound* sequencer, AUD_Sound* sound,
502                                                                    float begin, float end, float skip);
503
504 /**
505  * Removes an entry from the scene.
506  * \param sequencer The sound scene.
507  * \param entry The entry to remove.
508  */
509 extern void AUD_removeSequence(AUD_Sound* sequencer, AUD_SEntry* entry);
510
511 /**
512  * Moves the entry.
513  * \param entry The sequenced entry.
514  * \param begin The new start time.
515  * \param end The new end time or a negative value if unknown.
516  * \param skip How many seconds to skip at the beginning.
517  */
518 extern void AUD_moveSequence(AUD_SEntry* entry, float begin, float end, float skip);
519
520 /**
521  * Sets the muting state of the entry.
522  * \param entry The sequenced entry.
523  * \param mute Whether the entry should be muted or not.
524  */
525 extern void AUD_muteSequence(AUD_SEntry* entry, char mute);
526
527 /**
528  * Sets whether the entrie's location, velocity and orientation are relative
529  * to the listener.
530  * \param entry The sequenced entry.
531  * \param relative Whether the source is relative.
532  * \return Whether the action succeeded.
533  */
534 extern void AUD_setRelativeSequence(AUD_SEntry* entry, char relative);
535
536 /**
537  * Sets the sound of the entry.
538  * \param entry The sequenced entry.
539  * \param sound The new sound.
540  */
541 extern void AUD_updateSequenceSound(AUD_SEntry* entry, AUD_Sound* sound);
542
543 /**
544  * Writes animation data to a sequenced entry.
545  * \param entry The sequenced entry.
546  * \param type The type of animation data.
547  * \param frame The frame this data is for.
548  * \param data The data to write.
549  * \param animated Whether the attribute is animated.
550  */
551 extern void AUD_setSequenceAnimData(AUD_SEntry* entry, AUD_AnimateablePropertyType type, int frame, float* data, char animated);
552
553 /**
554  * Writes animation data to a sequenced entry.
555  * \param sequencer The sound scene.
556  * \param type The type of animation data.
557  * \param frame The frame this data is for.
558  * \param data The data to write.
559  * \param animated Whether the attribute is animated.
560  */
561 extern void AUD_setSequencerAnimData(AUD_Sound* sequencer, AUD_AnimateablePropertyType type, int frame, float* data, char animated);
562
563 /**
564  * Updates all non-animated parameters of the entry.
565  * \param entry The sequenced entry.
566  * \param volume_max The maximum volume.
567  * \param volume_min The minimum volume.
568  * \param distance_max The maximum distance.
569  * \param distance_reference The reference distance.
570  * \param attenuation The attenuation.
571  * \param cone_angle_outer The outer cone opening angle.
572  * \param cone_angle_inner The inner cone opening angle.
573  * \param cone_volume_outer The volume outside the outer cone.
574  */
575 extern void AUD_updateSequenceData(AUD_SEntry* entry, float volume_max, float volume_min,
576                                                                    float distance_max, float distance_reference, float attenuation,
577                                                                    float cone_angle_outer, float cone_angle_inner, float cone_volume_outer);
578
579 /**
580  * Updates all non-animated parameters of the entry.
581  * \param sequencer The sound scene.
582  * \param speed_of_sound The speed of sound for doppler calculation.
583  * \param factor The doppler factor to control the effect's strength.
584  * \param model The distance model for distance calculation.
585  */
586 extern void AUD_updateSequencerData(AUD_Sound* sequencer, float speed_of_sound,
587                                                                         float factor, AUD_DistanceModel model);
588
589 /**
590  * Sets the audio output specification of the sound scene to the specs of the
591  * current playback device.
592  * \param sequencer The sound scene.
593  */
594 extern void AUD_setSequencerDeviceSpecs(AUD_Sound* sequencer);
595
596 /**
597  * Sets the audio output specification of the sound scene.
598  * \param sequencer The sound scene.
599  * \param specs The new specification.
600  */
601 extern void AUD_setSequencerSpecs(AUD_Sound* sequencer, AUD_Specs specs);
602
603 /**
604  * Seeks sequenced sound scene playback.
605  * \param handle Playback handle.
606  * \param time Time in seconds to seek to.
607  */
608 extern void AUD_seekSequencer(AUD_Handle* handle, float time);
609
610 /**
611  * Returns the current sound scene playback time.
612  * \param handle Playback handle.
613  * \return The playback time in seconds.
614  */
615 extern float AUD_getSequencerPosition(AUD_Handle* handle);
616
617 /**
618  * Starts the playback of jack transport if possible.
619  */
620 extern void AUD_startPlayback(void);
621
622 /**
623  * Stops the playback of jack transport if possible.
624  */
625 extern void AUD_stopPlayback(void);
626
627 #ifdef WITH_JACK
628 /**
629  * Sets the sync callback for jack transport.
630  * \param function The callback function.
631  * \param data The data parameter for the callback.
632  */
633 extern void AUD_setSyncCallback(AUD_syncFunction function, void* data);
634 #endif
635
636 /**
637  * Returns whether jack transport is currently playing.
638  * \return Whether jack transport is currently playing.
639  */
640 extern int AUD_doesPlayback(void);
641
642 /**
643  * Reads a sound into a buffer for drawing at a specific sampling rate.
644  * \param sound The sound to read.
645  * \param buffer The buffer to write to. Must have a size of 3*4*length.
646  * \param length How many samples to read from the sound.
647  * \param samples_per_second How many samples to read per second of the sound.
648  * \return How many samples really have been read. Always <= length.
649  */
650 extern int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length, int samples_per_second);
651
652 /**
653  * Copies a sound.
654  * \param sound Sound to copy.
655  * \return Copied sound.
656  */
657 extern AUD_Sound* AUD_copy(AUD_Sound* sound);
658
659 /**
660  * Frees a handle.
661  * \param channel Handle to free.
662  */
663 extern void AUD_freeHandle(AUD_Handle* channel);
664
665 /**
666  * Creates a new set.
667  * \return The new set.
668  */
669 extern void* AUD_createSet(void);
670
671 /**
672  * Deletes a set.
673  * \param set The set to delete.
674  */
675 extern void AUD_destroySet(void* set);
676
677 /**
678  * Removes an entry from a set.
679  * \param set The set work on.
680  * \param entry The entry to remove.
681  * \return Whether the entry was in the set or not.
682  */
683 extern char AUD_removeSet(void* set, void* entry);
684
685 /**
686  * Adds a new entry to a set.
687  * \param set The set work on.
688  * \param entry The entry to add.
689  */
690 extern void AUD_addSet(void* set, void* entry);
691
692 /**
693  * Removes one entry from a set and returns it.
694  * \param set The set work on.
695  * \return The entry or NULL if the set is empty.
696  */
697 extern void* AUD_getSet(void* set);
698
699 /**
700  * Mixes a sound down into a file.
701  * \param sound The sound scene to mix down.
702  * \param start The start frame.
703  * \param length The count of frames to write.
704  * \param buffersize How many samples should be written at once.
705  * \param filename The file to write to.
706  * \param specs The file's audio specification.
707  * \param format The file's container format.
708  * \param codec The codec used for encoding the audio data.
709  * \param bitrate The bitrate for encoding.
710  * \return An error message or NULL in case of success.
711  */
712 extern const char* AUD_mixdown(AUD_Sound* sound, unsigned int start, unsigned int length, unsigned int buffersize, const char* filename, AUD_DeviceSpecs specs, AUD_Container format, AUD_Codec codec, unsigned int bitrate);
713
714 /**
715  * Opens a read device and prepares it for mixdown of the sound scene.
716  * \param specs Output audio specifications.
717  * \param sequencer The sound scene to mix down.
718  * \param volume The overall mixdown volume.
719  * \param start The start time of the mixdown in the sound scene.
720  * \return The read device for the mixdown.
721  */
722 extern AUD_Device* AUD_openMixdownDevice(AUD_DeviceSpecs specs, AUD_Sound* sequencer, float volume, float start);
723
724 #ifdef WITH_PYTHON
725 /**
726  * Retrieves the python factory of a sound.
727  * \param sound The sound factory.
728  * \return The python factory.
729  */
730 extern PyObject* AUD_getPythonFactory(AUD_Sound* sound);
731
732 /**
733  * Retrieves the sound factory of a python factory.
734  * \param sound The python factory.
735  * \return The sound factory.
736  */
737 extern AUD_Sound* AUD_getPythonSound(PyObject* sound);
738 #endif
739
740 #ifdef __cplusplus
741 }
742
743 #include "AUD_Reference.h"
744 class AUD_IDevice;
745 class AUD_I3DDevice;
746
747 /**
748  * Returns the current playback device.
749  * \return The playback device.
750  */
751 AUD_Reference<AUD_IDevice> AUD_getDevice();
752
753 /**
754  * Returns the current playback 3D device.
755  * \return The playback 3D device.
756  */
757 AUD_I3DDevice* AUD_get3DDevice();
758 #endif
759
760 #endif //AUD_CAPI