AUD_C-API.h

Go to the documentation of this file.

/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * Copyright 2009-2011 Jörg Hermann Müller
 *
 * This file is part of AudaSpace.
 *
 * Audaspace is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * AudaSpace is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Audaspace; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef AUD_CAPI
#define AUD_CAPI

#ifdef WITH_PYTHON
#include "Python.h"
#endif

#ifdef __cplusplus
extern "C" {
#endif

#include "AUD_Space.h"

typedef enum
{
    AUD_NULL_DEVICE = 0,
    AUD_SDL_DEVICE,
    AUD_OPENAL_DEVICE,
    AUD_JACK_DEVICE
} AUD_DeviceType;

typedef struct
{
    AUD_Specs specs;
    float length;
} AUD_SoundInfo;

#ifndef AUD_CAPI_IMPLEMENTATION
    typedef void AUD_Sound;
    typedef void AUD_Handle;
    typedef void AUD_Device;
    typedef void AUD_SEntry;
    typedef float (*AUD_volumeFunction)(void*, void*, float);
    typedef void (*AUD_syncFunction)(void*, int, float);
#endif

extern void AUD_initOnce(void);

extern int AUD_init(AUD_DeviceType device, AUD_DeviceSpecs specs, int buffersize);

extern void AUD_exit(void);

extern void AUD_lock(void);

extern void AUD_unlock(void);

extern AUD_SoundInfo AUD_getInfo(AUD_Sound* sound);

extern AUD_Sound* AUD_load(const char* filename);

extern AUD_Sound* AUD_loadBuffer(unsigned char* buffer, int size);

extern AUD_Sound* AUD_bufferSound(AUD_Sound* sound);

extern AUD_Sound* AUD_monoSound(AUD_Sound* sound);

extern AUD_Sound* AUD_delaySound(AUD_Sound* sound, float delay);

extern AUD_Sound* AUD_limitSound(AUD_Sound* sound, float start, float end);

extern AUD_Sound* AUD_pingpongSound(AUD_Sound* sound);

extern AUD_Sound* AUD_loopSound(AUD_Sound* sound);

extern int AUD_setLoop(AUD_Handle* handle, int loops);

extern AUD_Sound* AUD_rectifySound(AUD_Sound* sound);

extern void AUD_unload(AUD_Sound* sound);

extern AUD_Handle* AUD_play(AUD_Sound* sound, int keep);

extern int AUD_pause(AUD_Handle* handle);

extern int AUD_resume(AUD_Handle* handle);

extern int AUD_stop(AUD_Handle* handle);

extern int AUD_setKeep(AUD_Handle* handle, int keep);

extern int AUD_seek(AUD_Handle* handle, float seekTo);

extern float AUD_getPosition(AUD_Handle* handle);

extern AUD_Status AUD_getStatus(AUD_Handle* handle);

extern int AUD_setListenerLocation(const float* location);

extern int AUD_setListenerVelocity(const float* velocity);

extern int AUD_setListenerOrientation(const float* orientation);

extern int AUD_setSpeedOfSound(float speed);

extern int AUD_setDopplerFactor(float factor);

extern int AUD_setDistanceModel(AUD_DistanceModel model);

extern int AUD_setSourceLocation(AUD_Handle* handle, const float* location);

extern int AUD_setSourceVelocity(AUD_Handle* handle, const float* velocity);

extern int AUD_setSourceOrientation(AUD_Handle* handle, const float* orientation);

extern int AUD_setRelative(AUD_Handle* handle, int relative);

extern int AUD_setVolumeMaximum(AUD_Handle* handle, float volume);

extern int AUD_setVolumeMinimum(AUD_Handle* handle, float volume);

extern int AUD_setDistanceMaximum(AUD_Handle* handle, float distance);

extern int AUD_setDistanceReference(AUD_Handle* handle, float distance);

extern int AUD_setAttenuation(AUD_Handle* handle, float factor);

extern int AUD_setConeAngleOuter(AUD_Handle* handle, float angle);

extern int AUD_setConeAngleInner(AUD_Handle* handle, float angle);

extern int AUD_setConeVolumeOuter(AUD_Handle* handle, float volume);

extern int AUD_setSoundVolume(AUD_Handle* handle, float volume);

extern int AUD_setSoundPitch(AUD_Handle* handle, float pitch);

extern AUD_Device* AUD_openReadDevice(AUD_DeviceSpecs specs);

extern int AUD_setDeviceVolume(AUD_Device* device, float volume);

extern AUD_Handle* AUD_playDevice(AUD_Device* device, AUD_Sound* sound, float seek);

extern int AUD_readDevice(AUD_Device* device, data_t* buffer, int length);

extern void AUD_closeReadDevice(AUD_Device* device);

extern float* AUD_readSoundBuffer(const char* filename, float low, float high,
                                  float attack, float release, float threshold,
                                  int accumulate, int additive, int square,
                                  float sthreshold, double samplerate,
                                  int* length);

extern AUD_Handle* AUD_pauseAfter(AUD_Handle* handle, float seconds);

extern AUD_Sound* AUD_createSequencer(float fps, int muted);

extern void AUD_destroySequencer(AUD_Sound* sequencer);

extern void AUD_setSequencerMuted(AUD_Sound* sequencer, int muted);

extern void AUD_setSequencerFPS(AUD_Sound* sequencer, float fps);

extern AUD_SEntry* AUD_addSequence(AUD_Sound* sequencer, AUD_Sound* sound,
                                   float begin, float end, float skip);

extern void AUD_removeSequence(AUD_Sound* sequencer, AUD_SEntry* entry);

extern void AUD_moveSequence(AUD_SEntry* entry, float begin, float end, float skip);

extern void AUD_muteSequence(AUD_SEntry* entry, char mute);

extern void AUD_setRelativeSequence(AUD_SEntry* entry, char relative);

extern void AUD_updateSequenceSound(AUD_SEntry* entry, AUD_Sound* sound);

extern void AUD_setSequenceAnimData(AUD_SEntry* entry, AUD_AnimateablePropertyType type, int frame, float* data, char animated);

extern void AUD_setSequencerAnimData(AUD_Sound* sequencer, AUD_AnimateablePropertyType type, int frame, float* data, char animated);

extern void AUD_updateSequenceData(AUD_SEntry* entry, float volume_max, float volume_min,
                                   float distance_max, float distance_reference, float attenuation,
                                   float cone_angle_outer, float cone_angle_inner, float cone_volume_outer);

extern void AUD_updateSequencerData(AUD_Sound* sequencer, float speed_of_sound,
                                    float factor, AUD_DistanceModel model);

extern void AUD_setSequencerDeviceSpecs(AUD_Sound* sequencer);

extern void AUD_setSequencerSpecs(AUD_Sound* sequencer, AUD_Specs specs);

extern void AUD_seekSequencer(AUD_Handle* handle, float time);

extern float AUD_getSequencerPosition(AUD_Handle* handle);

extern void AUD_startPlayback(void);

extern void AUD_stopPlayback(void);

#ifdef WITH_JACK

extern void AUD_setSyncCallback(AUD_syncFunction function, void* data);
#endif

extern int AUD_doesPlayback(void);

extern int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length, int samples_per_second);

extern AUD_Sound* AUD_copy(AUD_Sound* sound);

extern void AUD_freeHandle(AUD_Handle* channel);

extern void* AUD_createSet(void);

extern void AUD_destroySet(void* set);

extern char AUD_removeSet(void* set, void* entry);

extern void AUD_addSet(void* set, void* entry);

extern void* AUD_getSet(void* set);

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);

extern AUD_Device* AUD_openMixdownDevice(AUD_DeviceSpecs specs, AUD_Sound* sequencer, float volume, float start);

#ifdef WITH_PYTHON

extern PyObject* AUD_getPythonFactory(AUD_Sound* sound);

extern AUD_Sound* AUD_getPythonSound(PyObject* sound);
#endif

#ifdef __cplusplus
}

#include "AUD_Reference.h"
class AUD_IDevice;
class AUD_I3DDevice;

AUD_Reference<AUD_IDevice> AUD_getDevice();

AUD_I3DDevice* AUD_get3DDevice();
#endif

#endif //AUD_CAPI