AUD_C-API.h

Go to the documentation of this file.

/*
 * $Id: AUD_C-API.h 36092 2011-04-10 22:40:37Z nexyon $
 *
 * ***** 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 __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_Channel;
        typedef void AUD_Device;
        typedef void AUD_SequencerEntry;
        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_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_Channel* handle, int loops);

extern AUD_Sound* AUD_rectifySound(AUD_Sound* sound);

extern void AUD_unload(AUD_Sound* sound);

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

extern int AUD_pause(AUD_Channel* handle);

extern int AUD_resume(AUD_Channel* handle);

extern int AUD_stop(AUD_Channel* handle);

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

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

extern float AUD_getPosition(AUD_Channel* handle);

extern AUD_Status AUD_getStatus(AUD_Channel* 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_Channel* handle, const float* location);

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

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

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

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

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

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

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

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

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

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

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

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

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

extern AUD_Device* AUD_openReadDevice(AUD_DeviceSpecs specs);

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

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

extern int AUD_setDeviceSoundVolume(AUD_Device* device,
                                                                        AUD_Channel* handle,
                                                                        float volume);

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, int samplerate,
                                                                  int* length);

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

extern AUD_Sound* AUD_createSequencer(int muted, void* data, AUD_volumeFunction volume);

extern void AUD_destroySequencer(AUD_Sound* sequencer);

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

extern AUD_SequencerEntry* AUD_addSequencer(AUD_Sound** sequencer, AUD_Sound* sound,
                                                                                float begin, float end, float skip, void* data);

extern void AUD_removeSequencer(AUD_Sound* sequencer, AUD_SequencerEntry* entry);

extern void AUD_moveSequencer(AUD_Sound* sequencer, AUD_SequencerEntry* entry,
                                                  float begin, float end, float skip);

extern void AUD_muteSequencer(AUD_Sound* sequencer, AUD_SequencerEntry* entry,
                                                  char mute);

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

extern void AUD_startPlayback(void);

extern void AUD_stopPlayback(void);

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

extern float AUD_getSequencerPosition(AUD_Channel* handle);

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

extern int AUD_doesPlayback(void);

#ifdef __cplusplus
}
#endif

#endif //AUD_CAPI