Bubel/bubel-ecs
2
0
Fork 0
Code Issues 1 Pull requests 2 Projects Releases Packages Wiki Activity Actions
bubel-ecs/demos/external/imports/bindbc/sdl/bind/sdlaudio.d
Mergul 73f2aa6861 -improved WASM compilation scripts 
-added external bindbc.sdl import for WASM
-working on demos (WIP, working simple demo with ECS and SDL2)
-small change in ecs.std
2019-11-06 20:38:46 +01:00

283 lines
No EOL
11 KiB
D
Raw Blame History

// Copyright Michael D. Parker 2018.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
module bindbc.sdl.bind.sdlaudio;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlrwops;
enum : ushort {
SDL_AUDIO_MASK_BITSIZE = 0xFF,
SDL_AUDIO_MASK_DATATYPE = 1<<8,
SDL_AUDIO_MASK_ENDIAN = 1<<12,
SDL_AUDIO_MASK_SIGNED = 1<<15,
}
enum SDL_AudioFormat : ushort {
AUDIO_U8 = 0x0008,
AUDIO_S8 = 0x8008,
AUDIO_U16LSB = 0x0010,
AUDIO_S16LSB = 0x8010,
AUDIO_U16MSB = 0x1010,
AUDIO_S16MSB = 0x9010,
AUDIO_U16 = AUDIO_U16LSB,
AUDIO_S16 = AUDIO_S16LSB,
AUDIO_S32LSB = 0x8020,
AUDIO_S32MSB = 0x9020,
AUDIO_S32 = AUDIO_S32LSB,
AUDIO_F32LSB = 0x8120,
AUDIO_F32MSB = 0x9120,
AUDIO_F32 = AUDIO_F32LSB,
}
mixin(expandEnum!SDL_AudioFormat);
version(LittleEndian) {
alias AUDIO_U16SYS = AUDIO_U16LSB;
alias AUDIO_S16SYS = AUDIO_S16LSB;
alias AUDIO_S32SYS = AUDIO_S32LSB;
alias AUDIO_F32SYS = AUDIO_F32LSB;
} else {
alias AUDIO_U16SYS = AUDIO_U16MSB;
alias AUDIO_S16SYS = AUDIO_S16MSB;
alias AUDIO_S32SYS = AUDIO_S32MSB;
alias AUDIO_F32SYS = AUDIO_F32MSB;
}
enum SDL_AUDIO_BITSIZE(SDL_AudioFormat x) = x & SDL_AUDIO_MASK_BITSIZE;
enum SDL_AUDIO_ISFLOAT(SDL_AudioFormat x) = x & SDL_AUDIO_MASK_DATATYPE;
enum SDL_AUDIO_ISBIGENDIAN(SDL_AudioFormat x) = x & SDL_AUDIO_MASK_ENDIAN;
enum SDL_AUDIO_ISSIGNED(SDL_AudioFormat x) = x & SDL_AUDIO_MASK_SIGNED;
enum SDL_AUDIO_ISINT(SDL_AudioFormat x) = !SDL_AUDIO_ISFLOAT!x;
enum SDL_AUDIO_ISLITTLEENDIAN(SDL_AudioFormat x) = !SDL_AUDIO_ISBIGENDIAN!x;
enum SDL_AUDIO_ISUNSIGNED(SDL_AudioFormat x) = !SDL_AUDIO_ISSIGNED!x;
static if(sdlSupport >= SDLSupport.sdl209) {
enum {
SDL_AUDIO_ALLOW_FREQUENCY_CHANGE = 0x00000001,
SDL_AUDIO_ALLOW_FORMAT_CHANGE = 0x00000002,
SDL_AUDIO_ALLOW_CHANNELS_CHANGE = 0x00000004,
SDL_AUDIO_ALLOW_SAMPLES_CHANGE = 0x00000008,
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,
}
}
else {
enum {
SDL_AUDIO_ALLOW_FREQUENCY_CHANGE = 0x00000001,
SDL_AUDIO_ALLOW_FORMAT_CHANGE = 0x00000002,
SDL_AUDIO_ALLOW_CHANNELS_CHANGE = 0x00000004,
SDL_AUDIO_ALLOW_ANY_CHANGE = SDL_AUDIO_ALLOW_FREQUENCY_CHANGE |
SDL_AUDIO_ALLOW_FORMAT_CHANGE |
SDL_AUDIO_ALLOW_CHANNELS_CHANGE,
}
}
extern(C) nothrow alias SDL_AudioCallback = void function(void* userdata, ubyte* stream, int len);
struct SDL_AudioSpec {
int freq;
SDL_AudioFormat format;
ubyte channels;
ubyte silence;
ushort samples;
ushort padding;
uint size;
SDL_AudioCallback callback;
void* userdata;
}
// Declared in 2.0.6, but doesn't hurt to use here
enum SDL_AUDIOCVT_MAX_FILTERS = 9;
extern(C) nothrow alias SDL_AudioFilter = void function(SDL_AudioCVT* cvt, SDL_AudioFormat format);
struct SDL_AudioCVT {
int needed;
SDL_AudioFormat src_format;
SDL_AudioFormat dst_format;
double rate_incr;
ubyte* buf;
int len;
int len_cvt;
int len_mult;
double len_ratio;
SDL_AudioFilter[SDL_AUDIOCVT_MAX_FILTERS + 1] filters;
int filter_index;
}
alias SDL_AudioDeviceID = uint;
enum SDL_AudioStatus {
SDL_AUDIO_STOPPED = 0,
SDL_AUDIO_PLAYING,
SDL_AUDIO_PAUSED,
}
mixin(expandEnum!SDL_AudioStatus);
enum SDL_MIX_MAXVOLUME = 128;
static if(sdlSupport >= SDLSupport.sdl207) {
struct SDL_AudioStream;
}
@nogc nothrow
SDL_AudioSpec* SDL_LoadWAV(const(char)* file, SDL_AudioSpec* spec, ubyte** audio_buf, uint* len) {
pragma(inline, true);
return SDL_LoadWAV_RW(SDL_RWFromFile(file,"rb"),1,spec,audio_buf,len);
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_GetNumAudioDrivers();
const(char)* SDL_GetAudioDriver(int);
int SDL_AudioInit(const(char)*);
void SDL_AudioQuit();
const(char)* SDL_GetCurrentAudioDriver();
int SDL_OpenAudio(SDL_AudioSpec*,SDL_AudioSpec*);
int SDL_GetNumAudioDevices(int);
const(char)* SDL_GetAudioDeviceName(int,int);
SDL_AudioDeviceID SDL_OpenAudioDevice(const(char)*,int,const(SDL_AudioSpec)*,SDL_AudioSpec*,int);
SDL_AudioStatus SDL_GetAudioStatus();
SDL_AudioStatus SDL_GetAudioDeviceStatus(SDL_AudioDeviceID);
void SDL_PauseAudio(int);
void SDL_PauseAudioDevice(SDL_AudioDeviceID,int);
SDL_AudioSpec* SDL_LoadWAV_RW(SDL_RWops*,int,SDL_AudioSpec*,ubyte**,uint*);
void SDL_FreeWAV(ubyte*);
int SDL_BuildAudioCVT(SDL_AudioCVT*,SDL_AudioFormat,ubyte,int,SDL_AudioFormat,ubyte,int);
int SDL_ConvertAudio(SDL_AudioCVT*);
void SDL_MixAudio(ubyte*,const(ubyte)*,uint,int);
void SDL_MixAudioFormat(ubyte*,const(ubyte)*,SDL_AudioFormat,uint,int);
void SDL_LockAudio();
void SDL_LockAudioDevice(SDL_AudioDeviceID);
void SDL_UnlockAudio();
void SDL_UnlockAudioDevice(SDL_AudioDeviceID);
void SDL_CloseAudio();
void SDL_CloseAudioDevice(SDL_AudioDeviceID);
static if(sdlSupport >= SDLSupport.sdl204) {
int SDL_ClearQueuedAudio(SDL_AudioDeviceID);
int SDL_GetQueuedAudioSize(SDL_AudioDeviceID);
int SDL_QueueAudio(SDL_AudioDeviceID,const (void)*,uint);
}
static if(sdlSupport >= SDLSupport.sdl205) {
uint SDL_DequeueAudio(SDL_AudioDeviceID,void*,uint);
}
static if(sdlSupport >= SDLSupport.sdl207) {
SDL_AudioStream* SDL_NewAudioStream(const(SDL_AudioFormat),const(ubyte),const(int),const(SDL_AudioFormat),const(ubyte),const(int));
int SDL_AudioStreamPut(SDL_AudioStream*,const(void)*,int);
int SDL_AudioStreamGet(SDL_AudioStream*,void*,int);
int SDL_AudioStreamAvailable(SDL_AudioStream*);
int SDL_AudioStreamFlush(SDL_AudioStream*);
void SDL_AudioStreamClear(SDL_AudioStream*);
void SDL_FreeAudioStream(SDL_AudioStream*);
}
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetNumAudioDrivers = int function();
alias pSDL_GetAudioDriver = const(char)* function(int);
alias pSDL_AudioInit = int function(const(char)*);
alias pSDL_AudioQuit = void function();
alias pSDL_GetCurrentAudioDriver = const(char)* function();
alias pSDL_OpenAudio = int function(SDL_AudioSpec*,SDL_AudioSpec*);
alias pSDL_GetNumAudioDevices = int function(int);
alias pSDL_GetAudioDeviceName = const(char)* function(int,int);
alias pSDL_OpenAudioDevice = SDL_AudioDeviceID function(const(char)*,int,const(SDL_AudioSpec)*,SDL_AudioSpec*,int);
alias pSDL_GetAudioStatus = SDL_AudioStatus function();
alias pSDL_GetAudioDeviceStatus = SDL_AudioStatus function(SDL_AudioDeviceID);
alias pSDL_PauseAudio = void function(int);
alias pSDL_PauseAudioDevice = void function(SDL_AudioDeviceID,int);
alias pSDL_LoadWAV_RW = SDL_AudioSpec* function(SDL_RWops*,int,SDL_AudioSpec*,ubyte**,uint*);
alias pSDL_FreeWAV = void function(ubyte*);
alias pSDL_BuildAudioCVT = int function(SDL_AudioCVT*,SDL_AudioFormat,ubyte,int,SDL_AudioFormat,ubyte,int);
alias pSDL_ConvertAudio = int function(SDL_AudioCVT*);
alias pSDL_MixAudio = void function(ubyte*,const(ubyte)*,uint,int);
alias pSDL_MixAudioFormat = void function(ubyte*,const(ubyte)*,SDL_AudioFormat,uint,int);
alias pSDL_LockAudio = void function();
alias pSDL_LockAudioDevice = void function(SDL_AudioDeviceID);
alias pSDL_UnlockAudio = void function();
alias pSDL_UnlockAudioDevice = void function(SDL_AudioDeviceID);
alias pSDL_CloseAudio = void function();
alias pSDL_CloseAudioDevice = void function(SDL_AudioDeviceID);
}
__gshared {
pSDL_GetNumAudioDrivers SDL_GetNumAudioDrivers;
pSDL_GetAudioDriver SDL_GetAudioDriver;
pSDL_AudioInit SDL_AudioInit;
pSDL_AudioQuit SDL_AudioQuit;
pSDL_GetCurrentAudioDriver SDL_GetCurrentAudioDriver;
pSDL_OpenAudio SDL_OpenAudio;
pSDL_GetNumAudioDevices SDL_GetNumAudioDevices;
pSDL_GetAudioDeviceName SDL_GetAudioDeviceName;
pSDL_OpenAudioDevice SDL_OpenAudioDevice;
pSDL_GetAudioStatus SDL_GetAudioStatus;
pSDL_GetAudioDeviceStatus SDL_GetAudioDeviceStatus;
pSDL_PauseAudio SDL_PauseAudio;
pSDL_PauseAudioDevice SDL_PauseAudioDevice;
pSDL_LoadWAV_RW SDL_LoadWAV_RW;
pSDL_FreeWAV SDL_FreeWAV;
pSDL_BuildAudioCVT SDL_BuildAudioCVT;
pSDL_ConvertAudio SDL_ConvertAudio;
pSDL_MixAudio SDL_MixAudio;
pSDL_MixAudioFormat SDL_MixAudioFormat;
pSDL_LockAudio SDL_LockAudio;
pSDL_LockAudioDevice SDL_LockAudioDevice;
pSDL_UnlockAudio SDL_UnlockAudio;
pSDL_UnlockAudioDevice SDL_UnlockAudioDevice;
pSDL_CloseAudio SDL_CloseAudio;
pSDL_CloseAudioDevice SDL_CloseAudioDevice;
}
static if(sdlSupport >= SDLSupport.sdl204) {
extern(C) @nogc nothrow {
alias pSDL_ClearQueuedAudio = int function(SDL_AudioDeviceID);
alias pSDL_GetQueuedAudioSize = int function(SDL_AudioDeviceID);
alias pSDL_QueueAudio = int function(SDL_AudioDeviceID,const (void)*,uint);
}
__gshared {
pSDL_ClearQueuedAudio SDL_ClearQueuedAudio;
pSDL_GetQueuedAudioSize SDL_GetQueuedAudioSize;
pSDL_QueueAudio SDL_QueueAudio;
}
}
static if(sdlSupport >= SDLSupport.sdl205) {
extern(C) @nogc nothrow {
alias pSDL_DequeueAudio = uint function(SDL_AudioDeviceID,void*,uint);
}
__gshared {
pSDL_DequeueAudio SDL_DequeueAudio;
}
}
static if(sdlSupport >= SDLSupport.sdl207) {
extern(C) @nogc nothrow {
alias pSDL_NewAudioStream = SDL_AudioStream* function(const(SDL_AudioFormat),const(ubyte),const(int),const(SDL_AudioFormat),const(ubyte),const(int));
alias pSDL_AudioStreamPut = int function(SDL_AudioStream*,const(void)*,int);
alias pSDL_AudioStreamGet = int function(SDL_AudioStream*,void*,int);
alias pSDL_AudioStreamAvailable = int function(SDL_AudioStream*);
alias pSDL_AudioStreamFlush = int function(SDL_AudioStream*);
alias pSDL_AudioStreamClear = void function(SDL_AudioStream*);
alias pSDL_FreeAudioStream = void function(SDL_AudioStream*);
}
__gshared {
pSDL_NewAudioStream SDL_NewAudioStream;
pSDL_AudioStreamPut SDL_AudioStreamPut;
pSDL_AudioStreamGet SDL_AudioStreamGet;
pSDL_AudioStreamAvailable SDL_AudioStreamAvailable;
pSDL_AudioStreamFlush SDL_AudioStreamFlush;
pSDL_AudioStreamClear SDL_AudioStreamClear;
pSDL_FreeAudioStream SDL_FreeAudioStream;
}
}
}
Reference in a new issue View git blame Copy permalink