Archivist
/
raylib-src
mirror of https://github.com/raysan5/raylib
1
0
Fork 0
Code Issues 0 Releases 24 Wiki Activity
Browse Source

Review coding style to match raylib style 

Moved AudioError enum inside audio.c
pull/124/head
raysan5 9 years ago
parent
7447b3e1da
commit
cf6d2e3985
3 changed files with 199 additions and 207 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +197
    -166
      src/audio.c
  2. +1
    -19
      src/audio.h
  3. +1
    -22
      src/raylib.h

+ 197
- 166
src/audio.c View File

@ -35,29 +35,29 @@
#include "raylib.h" #include "raylib.h"
#endif #endif
#include "AL/al.h" // OpenAL basic header
#include "AL/alc.h" // OpenAL context header (like OpenGL, OpenAL requires a context to work)
#include "AL/alext.h" // OpenAL extensions for other format types
#include "AL/al.h" // OpenAL basic header
#include "AL/alc.h" // OpenAL context header (like OpenGL, OpenAL requires a context to work)
#include "AL/alext.h" // OpenAL extensions for other format types
#include <stdlib.h> // Required for: malloc(), free()
#include <string.h> // Required for: strcmp(), strncmp()
#include <stdio.h> // Required for: FILE, fopen(), fclose(), fread()
#include <stdlib.h> // Required for: malloc(), free()
#include <string.h> // Required for: strcmp(), strncmp()
#include <stdio.h> // Required for: FILE, fopen(), fclose(), fread()
#if defined(AUDIO_STANDALONE) #if defined(AUDIO_STANDALONE)
#include <stdarg.h> // Required for: va_list, va_start(), vfprintf(), va_end()
#include <stdarg.h> // Required for: va_list, va_start(), vfprintf(), va_end()
#else #else
#include "utils.h" // Required for: DecompressData()
// NOTE: Includes Android fopen() function map
#include "utils.h" // Required for: DecompressData()
// NOTE: Includes Android fopen() function map
#endif #endif
//#define STB_VORBIS_HEADER_ONLY //#define STB_VORBIS_HEADER_ONLY
#include "stb_vorbis.h" // OGG loading functions
#include "stb_vorbis.h" // OGG loading functions
#define JAR_XM_IMPLEMENTATION #define JAR_XM_IMPLEMENTATION
#include "jar_xm.h" // XM loading functions
#include "jar_xm.h" // XM loading functions
#define JAR_MOD_IMPLEMENTATION #define JAR_MOD_IMPLEMENTATION
#include "jar_mod.h" // For playing .mod files
#include "jar_mod.h" // MOD loading functions
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Defines and Macros // Defines and Macros
@ -89,25 +89,45 @@ typedef struct MixChannel_t {
unsigned char mixChannel; // 0-3 or mixA-mixD, each mix channel can receive up to one dedicated audio stream unsigned char mixChannel; // 0-3 or mixA-mixD, each mix channel can receive up to one dedicated audio stream
bool floatingPoint; // if false then the short datatype is used instead bool floatingPoint; // if false then the short datatype is used instead
bool playing; // false if paused bool playing; // false if paused
ALenum alFormat; // openAL format specifier
ALuint alSource; // openAL source
ALuint alBuffer[MAX_STREAM_BUFFERS]; // openAL sample buffer
ALenum alFormat; // OpenAL format specifier
ALuint alSource; // OpenAL source
ALuint alBuffer[MAX_STREAM_BUFFERS]; // OpenAL sample buffer
} MixChannel_t; } MixChannel_t;
// Music type (file streaming from memory) // Music type (file streaming from memory)
// NOTE: Anything longer than ~10 seconds should be streamed into a mix channel... // NOTE: Anything longer than ~10 seconds should be streamed into a mix channel...
typedef struct Music { typedef struct Music {
stb_vorbis *stream; stb_vorbis *stream;
jar_xm_context_t *xmctx; // Stores jar_xm mixc, XM chiptune context
jar_mod_context_t modctx; // Stores mod chiptune context
jar_xm_context_t *xmctx; // XM chiptune context
jar_mod_context_t modctx; // MOD chiptune context
MixChannel_t *mixc; // mix channel MixChannel_t *mixc; // mix channel
unsigned int totalSamplesLeft; unsigned int totalSamplesLeft;
float totalLengthSeconds; float totalLengthSeconds;
bool loop; bool loop;
bool chipTune; // True if chiptune is loaded
bool chipTune; // chiptune is loaded?
} Music; } Music;
// Audio errors registered
typedef enum {
ERROR_RAW_CONTEXT_CREATION = 1,
ERROR_XM_CONTEXT_CREATION = 2,
ERROR_MOD_CONTEXT_CREATION = 4,
ERROR_MIX_CHANNEL_CREATION = 8,
ERROR_MUSIC_CHANNEL_CREATION = 16,
ERROR_LOADING_XM = 32,
ERROR_LOADING_MOD = 64,
ERROR_LOADING_WAV = 128,
ERROR_LOADING_OGG = 256,
ERROR_OUT_OF_MIX_CHANNELS = 512,
ERROR_EXTENSION_NOT_RECOGNIZED = 1024,
ERROR_UNABLE_TO_OPEN_RRES_FILE = 2048,
ERROR_INVALID_RRES_FILE = 4096,
ERROR_INVALID_RRES_RESOURCE = 8192,
ERROR_UNINITIALIZED_CHANNELS = 16384
} AudioError;
#if defined(AUDIO_STANDALONE) #if defined(AUDIO_STANDALONE)
typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType; typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType;
#endif #endif
@ -119,6 +139,8 @@ static MixChannel_t* mixChannels_g[MAX_MIX_CHANNELS]; // What mix channel
static bool musicEnabled_g = false; static bool musicEnabled_g = false;
static Music musicChannels_g[MAX_MUSIC_STREAMS]; // Current music loaded, up to two can play at the same time static Music musicChannels_g[MAX_MUSIC_STREAMS]; // Current music loaded, up to two can play at the same time
static lastAudioError = 0; // Registers last audio error
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Module specific Functions Declaration // Module specific Functions Declaration
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -129,10 +151,9 @@ static void UnloadWave(Wave wave); // Unload wave data
static bool BufferMusicStream(int index, int numBuffers); // Fill music buffers with data static bool BufferMusicStream(int index, int numBuffers); // Fill music buffers with data
static void EmptyMusicStream(int index); // Empty music buffers static void EmptyMusicStream(int index); // Empty music buffers
static MixChannel_t* InitMixChannel(unsigned short sampleRate, unsigned char mixChannel, unsigned char channels, bool floatingPoint); // For streaming into mix channels.
static void CloseMixChannel(MixChannel_t* mixc); // Frees mix channel
static int BufferMixChannel(MixChannel_t* mixc, void *data, int numberElements); // Pushes more audio data into mixc mix channel, if NULL is passed it pauses
static MixChannel_t *InitMixChannel(unsigned short sampleRate, unsigned char mixChannel, unsigned char channels, bool floatingPoint); // For streaming into mix channels.
static void CloseMixChannel(MixChannel_t *mixc); // Frees mix channel
static int BufferMixChannel(MixChannel_t *mixc, void *data, int numberElements); // Pushes more audio data into mixc mix channel, if NULL is passed it pauses
static int FillAlBufferWithSilence(MixChannel_t *mixc, ALuint buffer); // Fill buffer with zeros, returns number processed static int FillAlBufferWithSilence(MixChannel_t *mixc, ALuint buffer); // Fill buffer with zeros, returns number processed
static void ResampleShortToFloat(short *shorts, float *floats, unsigned short len); // Pass two arrays of the same legnth in static void ResampleShortToFloat(short *shorts, float *floats, unsigned short len); // Pass two arrays of the same legnth in
static void ResampleByteToFloat(char *chars, float *floats, unsigned short len); // Pass two arrays of same length in static void ResampleByteToFloat(char *chars, float *floats, unsigned short len); // Pass two arrays of same length in
@ -153,13 +174,13 @@ void InitAudioDevice(void)
// Open and initialize a device with default settings // Open and initialize a device with default settings
ALCdevice *device = alcOpenDevice(NULL); ALCdevice *device = alcOpenDevice(NULL);
if(!device) TraceLog(ERROR, "Audio device could not be opened");
if (!device) TraceLog(ERROR, "Audio device could not be opened");
ALCcontext *context = alcCreateContext(device, NULL); ALCcontext *context = alcCreateContext(device, NULL);
if(context == NULL || alcMakeContextCurrent(context) == ALC_FALSE)
if ((context == NULL) || p">(alcMakeContextCurrent(context) == ALC_FALSE))
{ {
if(context != NULL) alcDestroyContext(context);
if (context != NULL) alcDestroyContext(context);
alcCloseDevice(device); alcCloseDevice(device);
@ -177,11 +198,10 @@ void InitAudioDevice(void)
// Close the audio device for all contexts // Close the audio device for all contexts
void CloseAudioDevice(void) void CloseAudioDevice(void)
{ {
for(int index=0; index<MAX_MUSIC_STREAMS; index++)
for (int index=0; index<MAX_MUSIC_STREAMS; index++)
{ {
if(musicChannels_g[index].mixc) StopMusicStream(index); // Stop music streaming and close current stream
if (musicChannels_g[index].mixc) StopMusicStream(index); // Stop music streaming and close current stream
} }
ALCdevice *device; ALCdevice *device;
ALCcontext *context = alcGetCurrentContext(); ALCcontext *context = alcGetCurrentContext();
@ -199,9 +219,12 @@ void CloseAudioDevice(void)
bool IsAudioDeviceReady(void) bool IsAudioDeviceReady(void)
{ {
ALCcontext *context = alcGetCurrentContext(); ALCcontext *context = alcGetCurrentContext();
if (context == NULL) return false; if (context == NULL) return false;
else{
else
{
ALCdevice *device = alcGetContextsDevice(context); ALCdevice *device = alcGetContextsDevice(context);
if (device == NULL) return false; if (device == NULL) return false;
else return true; else return true;
} }
@ -214,33 +237,30 @@ bool IsAudioDeviceReady(void)
// For streaming into mix channels. // For streaming into mix channels.
// The mixChannel is what audio muxing channel you want to operate on, 0-3 are the ones available. Each mix channel can only be used one at a time. // The mixChannel is what audio muxing channel you want to operate on, 0-3 are the ones available. Each mix channel can only be used one at a time.
// exmple usage is InitMixChannel(48000, 0, 2, true); // mixchannel 1, 48khz, stereo, floating point // exmple usage is InitMixChannel(48000, 0, 2, true); // mixchannel 1, 48khz, stereo, floating point
static MixChannel_t* InitMixChannel(unsigned short sampleRate, unsigned char mixChannel, unsigned char channels, bool floatingPoint)
static MixChannel_t *InitMixChannel(unsigned short sampleRate, unsigned char mixChannel, unsigned char channels, bool floatingPoint)
{ {
if(mixChannel >= MAX_MIX_CHANNELS) return NULL;
if(!IsAudioDeviceReady()) InitAudioDevice();
if (mixChannel >= MAX_MIX_CHANNELS) return NULL;
if (!IsAudioDeviceReady()) InitAudioDevice();
if(!mixChannels_g[mixChannel]){
MixChannel_t *mixc = (MixChannel_t*)malloc(sizeof(MixChannel_t));
if (!mixChannels_g[mixChannel])
{
MixChannel_t *mixc = (MixChannel_t *)malloc(sizeof(MixChannel_t));
mixc->sampleRate = sampleRate; mixc->sampleRate = sampleRate;
mixc->channels = channels; mixc->channels = channels;
mixc->mixChannel = mixChannel; mixc->mixChannel = mixChannel;
mixc->floatingPoint = floatingPoint; mixc->floatingPoint = floatingPoint;
mixChannels_g[mixChannel] = mixc; mixChannels_g[mixChannel] = mixc;
// setup openAL format
if(channels == 1)
// Setup OpenAL format
if (channels == 1)
{ {
if(floatingPoint)
mixc->alFormat = AL_FORMAT_MONO_FLOAT32;
else
mixc->alFormat = AL_FORMAT_MONO16;
if (floatingPoint) mixc->alFormat = AL_FORMAT_MONO_FLOAT32;
else mixc->alFormat = AL_FORMAT_MONO16;
} }
else if(channels == 2)
else if (channels == 2)
{ {
if(floatingPoint)
mixc->alFormat = AL_FORMAT_STEREO_FLOAT32;
else
mixc->alFormat = AL_FORMAT_STEREO16;
if (floatingPoint) mixc->alFormat = AL_FORMAT_STEREO_FLOAT32;
else mixc->alFormat = AL_FORMAT_STEREO16;
} }
// Create an audio source // Create an audio source
@ -253,10 +273,8 @@ static MixChannel_t* InitMixChannel(unsigned short sampleRate, unsigned char mix
// Create Buffer // Create Buffer
alGenBuffers(MAX_STREAM_BUFFERS, mixc->alBuffer); alGenBuffers(MAX_STREAM_BUFFERS, mixc->alBuffer);
//fill buffers
int x;
for(x=0;x<MAX_STREAM_BUFFERS;x++)
FillAlBufferWithSilence(mixc, mixc->alBuffer[x]);
// Fill buffers
for (int i = 0; i < MAX_STREAM_BUFFERS; i++) FillAlBufferWithSilence(mixc, mixc->alBuffer[i]);
alSourceQueueBuffers(mixc->alSource, MAX_STREAM_BUFFERS, mixc->alBuffer); alSourceQueueBuffers(mixc->alSource, MAX_STREAM_BUFFERS, mixc->alBuffer);
mixc->playing = true; mixc->playing = true;
@ -264,27 +282,30 @@ static MixChannel_t* InitMixChannel(unsigned short sampleRate, unsigned char mix
return mixc; return mixc;
} }
return NULL; return NULL;
} }
// Frees buffer in mix channel // Frees buffer in mix channel
static void CloseMixChannel(MixChannel_t* mixc)
static void CloseMixChannel(MixChannel_t *mixc)
{ {
if(mixc){
if (mixc)
{
alSourceStop(mixc->alSource); alSourceStop(mixc->alSource);
mixc->playing = false; mixc->playing = false;
//flush out all queued buffers
// Flush out all queued buffers
ALuint buffer = 0; ALuint buffer = 0;
int queued = 0; int queued = 0;
alGetSourcei(mixc->alSource, AL_BUFFERS_QUEUED, &queued); alGetSourcei(mixc->alSource, AL_BUFFERS_QUEUED, &queued);
while (queued > 0) while (queued > 0)
{ {
alSourceUnqueueBuffers(mixc->alSource, 1, &buffer); alSourceUnqueueBuffers(mixc->alSource, 1, &buffer);
queued--; queued--;
} }
//delete source and buffers
// Delete source and buffers
alDeleteSources(1, &mixc->alSource); alDeleteSources(1, &mixc->alSource);
alDeleteBuffers(MAX_STREAM_BUFFERS, mixc->alBuffer); alDeleteBuffers(MAX_STREAM_BUFFERS, mixc->alBuffer);
mixChannels_g[mixc->mixChannel] = NULL; mixChannels_g[mixc->mixChannel] = NULL;
@ -296,39 +317,46 @@ static void CloseMixChannel(MixChannel_t* mixc)
// Pushes more audio data into mixc mix channel, only one buffer per call // Pushes more audio data into mixc mix channel, only one buffer per call
// Call "BufferMixChannel(mixc, NULL, 0)" if you want to pause the audio. // Call "BufferMixChannel(mixc, NULL, 0)" if you want to pause the audio.
// @Returns number of samples that where processed. // @Returns number of samples that where processed.
static int BufferMixChannel(MixChannel_t* mixc, void *data, int numberElements)
static int BufferMixChannel(MixChannel_t *mixc, void *data, int numberElements)
{ {
if(!mixc || mixChannels_g[mixc->mixChannel] != mixc) return 0; // when there is two channels there must be an even number of samples
if (!mixc || (mixChannels_g[mixc->mixChannel] != mixc)) return 0; // When there is two channels there must be an even number of samples
if (!data || !numberElements)
{ // pauses audio until data is given
if(mixc->playing){
if (!data || !numberElements)
{
// Pauses audio until data is given
if (mixc->playing)
{
alSourcePause(mixc->alSource); alSourcePause(mixc->alSource);
mixc->playing = false; mixc->playing = false;
} }
return 0; return 0;
} }
else if(!mixc->playing)
{ // restart audio otherwise
else if (!mixc->playing)
{
// Restart audio otherwise
alSourcePlay(mixc->alSource); alSourcePlay(mixc->alSource);
mixc->playing = true; mixc->playing = true;
} }
ALuint buffer = 0; ALuint buffer = 0;
alSourceUnqueueBuffers(mixc->alSource, 1, &buffer); alSourceUnqueueBuffers(mixc->alSource, 1, &buffer);
if(!buffer) return 0;
if(mixc->floatingPoint) // process float buffers
if (!buffer) return 0;
if (mixc->floatingPoint)
{ {
float *ptr = (float*)data;
// Process float buffers
float *ptr = (float *)data;
alBufferData(buffer, mixc->alFormat, ptr, numberElements*sizeof(float), mixc->sampleRate); alBufferData(buffer, mixc->alFormat, ptr, numberElements*sizeof(float), mixc->sampleRate);
} }
else // process short buffers
else
{ {
short *ptr = (short*)data;
// Process short buffers
short *ptr = (short *)data;
alBufferData(buffer, mixc->alFormat, ptr, numberElements*sizeof(short), mixc->sampleRate); alBufferData(buffer, mixc->alFormat, ptr, numberElements*sizeof(short), mixc->sampleRate);
} }
alSourceQueueBuffers(mixc->alSource, 1, &buffer); alSourceQueueBuffers(mixc->alSource, 1, &buffer);
return numberElements; return numberElements;
@ -337,15 +365,18 @@ static int BufferMixChannel(MixChannel_t* mixc, void *data, int numberElements)
// fill buffer with zeros, returns number processed // fill buffer with zeros, returns number processed
static int FillAlBufferWithSilence(MixChannel_t *mixc, ALuint buffer) static int FillAlBufferWithSilence(MixChannel_t *mixc, ALuint buffer)
{ {
if(mixc->floatingPoint){
float pcm[MUSIC_BUFFER_SIZE_FLOAT] = {0.f};
if (mixc->floatingPoint)
{
float pcm[MUSIC_BUFFER_SIZE_FLOAT] = { 0.0f };
alBufferData(buffer, mixc->alFormat, pcm, MUSIC_BUFFER_SIZE_FLOAT*sizeof(float), mixc->sampleRate); alBufferData(buffer, mixc->alFormat, pcm, MUSIC_BUFFER_SIZE_FLOAT*sizeof(float), mixc->sampleRate);
return MUSIC_BUFFER_SIZE_FLOAT; return MUSIC_BUFFER_SIZE_FLOAT;
} }
else else
{ {
short pcm[MUSIC_BUFFER_SIZE_SHORT] = {0};
short pcm[MUSIC_BUFFER_SIZE_SHORT] = { 0 };
alBufferData(buffer, mixc->alFormat, pcm, MUSIC_BUFFER_SIZE_SHORT*sizeof(short), mixc->sampleRate); alBufferData(buffer, mixc->alFormat, pcm, MUSIC_BUFFER_SIZE_SHORT*sizeof(short), mixc->sampleRate);
return MUSIC_BUFFER_SIZE_SHORT; return MUSIC_BUFFER_SIZE_SHORT;
} }
} }
@ -355,13 +386,10 @@ static int FillAlBufferWithSilence(MixChannel_t *mixc, ALuint buffer)
// ResampleShortToFloat(sh,fl,3); // ResampleShortToFloat(sh,fl,3);
static void ResampleShortToFloat(short *shorts, float *floats, unsigned short len) static void ResampleShortToFloat(short *shorts, float *floats, unsigned short len)
{ {
int x;
for(x=0;x<len;x++)
for (int i = 0; i < len; i++)
{ {
if(shorts[x] < 0)
floats[x] = (float)shorts[x] / 32766.f;
else
floats[x] = (float)shorts[x] / 32767.f;
if (shorts[x] < 0) floats[x] = (float)shorts[x]/32766.0f;
else floats[x] = (float)shorts[x]/32767.0f;
} }
} }
@ -370,13 +398,10 @@ static void ResampleShortToFloat(short *shorts, float *floats, unsigned short le
// ResampleByteToFloat(ch,fl,3); // ResampleByteToFloat(ch,fl,3);
static void ResampleByteToFloat(char *chars, float *floats, unsigned short len) static void ResampleByteToFloat(char *chars, float *floats, unsigned short len)
{ {
int x;
for(x=0;x<len;x++)
for (int i = 0; i < len; i++)
{ {
if(chars[x] < 0)
floats[x] = (float)chars[x] / 127.f;
else
floats[x] = (float)chars[x] / 128.f;
if (chars[x] < 0) floats[x] = (float)chars[x]/127.0f;
else floats[x] = (float)chars[x]/128.0f;
} }
} }
@ -385,22 +410,19 @@ static void ResampleByteToFloat(char *chars, float *floats, unsigned short len)
RawAudioContext InitRawAudioContext(int sampleRate, int channels, bool floatingPoint) RawAudioContext InitRawAudioContext(int sampleRate, int channels, bool floatingPoint)
{ {
int mixIndex; int mixIndex;
for(mixIndex = 0; mixIndex < MAX_MIX_CHANNELS; mixIndex++) // find empty mix channel slot
for (mixIndex = 0; mixIndex < MAX_MIX_CHANNELS; mixIndex++) // find empty mix channel slot
{ {
if(mixChannels_g[mixIndex] == NULL) break;
else if(mixIndex == MAX_MIX_CHANNELS - 1) return ERROR_OUT_OF_MIX_CHANNELS; // error
if (mixChannels_g[mixIndex] == NULL) break;
else if (mixIndex == (MAX_MIX_CHANNELS - 1)) return ERROR_OUT_OF_MIX_CHANNELS; // error
} }
if(InitMixChannel(sampleRate, mixIndex, channels, floatingPoint))
return mixIndex;
else
return ERROR_RAW_CONTEXT_CREATION; // error
if (InitMixChannel(sampleRate, mixIndex, channels, floatingPoint)) return mixIndex;
else return ERROR_RAW_CONTEXT_CREATION; // error
} }
void CloseRawAudioContext(RawAudioContext ctx) void CloseRawAudioContext(RawAudioContext ctx)
{ {
if(mixChannels_g[ctx])
CloseMixChannel(mixChannels_g[ctx]);
if (mixChannels_g[ctx]) CloseMixChannel(mixChannels_g[ctx]);
} }
// if 0 is returned, the buffers are still full and you need to keep trying with the same data until a + number is returned. // if 0 is returned, the buffers are still full and you need to keep trying with the same data until a + number is returned.
@ -409,18 +431,16 @@ void CloseRawAudioContext(RawAudioContext ctx)
int BufferRawAudioContext(RawAudioContext ctx, void *data, unsigned short numberElements) int BufferRawAudioContext(RawAudioContext ctx, void *data, unsigned short numberElements)
{ {
int numBuffered = 0; int numBuffered = 0;
if(ctx >= 0)
if (ctx >= 0)
{ {
MixChannel_t* mixc = mixChannels_g[ctx]; MixChannel_t* mixc = mixChannels_g[ctx];
numBuffered = BufferMixChannel(mixc, data, numberElements); numBuffered = BufferMixChannel(mixc, data, numberElements);
} }
return numBuffered; return numBuffered;
} }
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Module Functions Definition - Sounds loading and playing (.WAV) // Module Functions Definition - Sounds loading and playing (.WAV)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -438,9 +458,12 @@ Sound LoadSound(char *fileName)
if (strcmp(GetExtension(fileName),"wav") == 0) wave = LoadWAV(fileName); if (strcmp(GetExtension(fileName),"wav") == 0) wave = LoadWAV(fileName);
else if (strcmp(GetExtension(fileName),"ogg") == 0) wave = LoadOGG(fileName); else if (strcmp(GetExtension(fileName),"ogg") == 0) wave = LoadOGG(fileName);
else{
else
{
TraceLog(WARNING, "[%s] Sound extension not recognized, it can't be loaded", fileName); TraceLog(WARNING, "[%s] Sound extension not recognized, it can't be loaded", fileName);
sound.error = ERROR_EXTENSION_NOT_RECOGNIZED; //error
// TODO: Find a better way to register errors (similar to glGetError())
lastAudioError = ERROR_EXTENSION_NOT_RECOGNIZED;
} }
if (wave.data != NULL) if (wave.data != NULL)
@ -568,7 +591,7 @@ Sound LoadSoundFromRES(const char *rresName, int resId)
if (rresFile == NULL) if (rresFile == NULL)
{ {
TraceLog(WARNING, "[%s] rRES raylib resource file could not be opened", rresName); TraceLog(WARNING, "[%s] rRES raylib resource file could not be opened", rresName);
sound.error = ERROR_UNABLE_TO_OPEN_RRES_FILE; //error
lastAudioError = ERROR_UNABLE_TO_OPEN_RRES_FILE;
} }
else else
{ {
@ -583,7 +606,7 @@ Sound LoadSoundFromRES(const char *rresName, int resId)
if ((id[0] != 'r') && (id[1] != 'R') && (id[2] != 'E') &&(id[3] != 'S')) if ((id[0] != 'r') && (id[1] != 'R') && (id[2] != 'E') &&(id[3] != 'S'))
{ {
TraceLog(WARNING, "[%s] This is not a valid raylib resource file", rresName); TraceLog(WARNING, "[%s] This is not a valid raylib resource file", rresName);
sound.error = ERROR_INVALID_RRES_FILE;
lastAudioError = ERROR_INVALID_RRES_FILE;
} }
else else
{ {
@ -674,7 +697,7 @@ Sound LoadSoundFromRES(const char *rresName, int resId)
else else
{ {
TraceLog(WARNING, "[%s] Required resource do not seem to be a valid SOUND resource", rresName); TraceLog(WARNING, "[%s] Required resource do not seem to be a valid SOUND resource", rresName);
sound.error = ERROR_INVALID_RRES_RESOURCE;
lastAudioError = ERROR_INVALID_RRES_RESOURCE;
} }
} }
else else
@ -780,12 +803,12 @@ int PlayMusicStream(int musicIndex, char *fileName)
{ {
int mixIndex; int mixIndex;
if(musicChannels_g[musicIndex].stream || musicChannels_g[musicIndex].xmctx) return ERROR_UNINITIALIZED_CHANNELS; // error
if (musicChannels_g[musicIndex].stream || musicChannels_g[musicIndex].xmctx) return ERROR_UNINITIALIZED_CHANNELS; // error
for(mixIndex = 0; mixIndex < MAX_MIX_CHANNELS; mixIndex++) // find empty mix channel slot
for (mixIndex = 0; mixIndex < MAX_MIX_CHANNELS; mixIndex++) // find empty mix channel slot
{ {
if(mixChannels_g[mixIndex] == NULL) break;
else if(mixIndex == MAX_MIX_CHANNELS - 1) return ERROR_OUT_OF_MIX_CHANNELS; // error
if (mixChannels_g[mixIndex] == NULL) break;
else if (mixIndex == (MAX_MIX_CHANNELS - 1)) return ERROR_OUT_OF_MIX_CHANNELS; // error
} }
if (strcmp(GetExtension(fileName),"ogg") == 0) if (strcmp(GetExtension(fileName),"ogg") == 0)
@ -814,21 +837,24 @@ int PlayMusicStream(int musicIndex, char *fileName)
musicChannels_g[musicIndex].totalSamplesLeft = (unsigned int)stb_vorbis_stream_length_in_samples(musicChannels_g[musicIndex].stream) * info.channels; musicChannels_g[musicIndex].totalSamplesLeft = (unsigned int)stb_vorbis_stream_length_in_samples(musicChannels_g[musicIndex].stream) * info.channels;
musicChannels_g[musicIndex].totalLengthSeconds = stb_vorbis_stream_length_in_seconds(musicChannels_g[musicIndex].stream); musicChannels_g[musicIndex].totalLengthSeconds = stb_vorbis_stream_length_in_seconds(musicChannels_g[musicIndex].stream);
if (info.channels == 2){
if (info.channels == 2)
{
musicChannels_g[musicIndex].mixc = InitMixChannel(info.sample_rate, mixIndex, 2, false); musicChannels_g[musicIndex].mixc = InitMixChannel(info.sample_rate, mixIndex, 2, false);
musicChannels_g[musicIndex].mixc->playing = true; musicChannels_g[musicIndex].mixc->playing = true;
} }
else{
else
{
musicChannels_g[musicIndex].mixc = InitMixChannel(info.sample_rate, mixIndex, 1, false); musicChannels_g[musicIndex].mixc = InitMixChannel(info.sample_rate, mixIndex, 1, false);
musicChannels_g[musicIndex].mixc->playing = true; musicChannels_g[musicIndex].mixc->playing = true;
} }
if(!musicChannels_g[musicIndex].mixc) return ERROR_LOADING_OGG; // error
if (!musicChannels_g[musicIndex].mixc) return ERROR_LOADING_OGG; // error
} }
} }
else if (strcmp(GetExtension(fileName),"xm") == 0) else if (strcmp(GetExtension(fileName),"xm") == 0)
{ {
// only stereo is supported for xm // only stereo is supported for xm
if(!jar_xm_create_context_from_file(&musicChannels_g[musicIndex].xmctx, 48000, fileName))
if (!jar_xm_create_context_from_file(&musicChannels_g[musicIndex].xmctx, 48000, fileName))
{ {
musicChannels_g[musicIndex].chipTune = true; musicChannels_g[musicIndex].chipTune = true;
musicChannels_g[musicIndex].loop = true; musicChannels_g[musicIndex].loop = true;
@ -841,7 +867,9 @@ int PlayMusicStream(int musicIndex, char *fileName)
TraceLog(INFO, "[%s] XM track length: %11.6f sec", fileName, musicChannels_g[musicIndex].totalLengthSeconds); TraceLog(INFO, "[%s] XM track length: %11.6f sec", fileName, musicChannels_g[musicIndex].totalLengthSeconds);
musicChannels_g[musicIndex].mixc = InitMixChannel(48000, mixIndex, 2, true); musicChannels_g[musicIndex].mixc = InitMixChannel(48000, mixIndex, 2, true);
if(!musicChannels_g[musicIndex].mixc) return ERROR_XM_CONTEXT_CREATION; // error
if (!musicChannels_g[musicIndex].mixc) return ERROR_XM_CONTEXT_CREATION; // error
musicChannels_g[musicIndex].mixc->playing = true; musicChannels_g[musicIndex].mixc->playing = true;
} }
else else
@ -853,7 +881,8 @@ int PlayMusicStream(int musicIndex, char *fileName)
else if (strcmp(GetExtension(fileName),"mod") == 0) else if (strcmp(GetExtension(fileName),"mod") == 0)
{ {
jar_mod_init(&musicChannels_g[musicIndex].modctx); jar_mod_init(&musicChannels_g[musicIndex].modctx);
if(jar_mod_load_file(&musicChannels_g[musicIndex].modctx, fileName))
if (jar_mod_load_file(&musicChannels_g[musicIndex].modctx, fileName))
{ {
musicChannels_g[musicIndex].chipTune = true; musicChannels_g[musicIndex].chipTune = true;
musicChannels_g[musicIndex].loop = true; musicChannels_g[musicIndex].loop = true;
@ -865,7 +894,9 @@ int PlayMusicStream(int musicIndex, char *fileName)
TraceLog(INFO, "[%s] MOD track length: %11.6f sec", fileName, musicChannels_g[musicIndex].totalLengthSeconds); TraceLog(INFO, "[%s] MOD track length: %11.6f sec", fileName, musicChannels_g[musicIndex].totalLengthSeconds);
musicChannels_g[musicIndex].mixc = InitMixChannel(48000, mixIndex, 2, false); musicChannels_g[musicIndex].mixc = InitMixChannel(48000, mixIndex, 2, false);
if(!musicChannels_g[musicIndex].mixc) return ERROR_MOD_CONTEXT_CREATION; // error
if (!musicChannels_g[musicIndex].mixc) return ERROR_MOD_CONTEXT_CREATION; // error
musicChannels_g[musicIndex].mixc->playing = true; musicChannels_g[musicIndex].mixc->playing = true;
} }
else else
@ -879,6 +910,7 @@ int PlayMusicStream(int musicIndex, char *fileName)
TraceLog(WARNING, "[%s] Music extension not recognized, it can't be loaded", fileName); TraceLog(WARNING, "[%s] Music extension not recognized, it can't be loaded", fileName);
return ERROR_EXTENSION_NOT_RECOGNIZED; // error return ERROR_EXTENSION_NOT_RECOGNIZED; // error
} }
return 0; // normal return return 0; // normal return
} }
@ -894,17 +926,12 @@ void StopMusicStream(int index)
jar_xm_free_context(musicChannels_g[index].xmctx); jar_xm_free_context(musicChannels_g[index].xmctx);
musicChannels_g[index].xmctx = 0; musicChannels_g[index].xmctx = 0;
} }
else if(musicChannels_g[index].chipTune && musicChannels_g[index].modctx.mod_loaded)
{
jar_mod_unload(&musicChannels_g[index].modctx);
}
else
{
stb_vorbis_close(musicChannels_g[index].stream);
}
else if (musicChannels_g[index].chipTune && musicChannels_g[index].modctx.mod_loaded) jar_mod_unload(&musicChannels_g[index].modctx);
else stb_vorbis_close(musicChannels_g[index].stream);
if(!getMusicStreamCount()) musicEnabled_g = false;
if(musicChannels_g[index].stream || musicChannels_g[index].xmctx)
if (!GetMusicStreamCount()) musicEnabled_g = false;
if (musicChannels_g[index].stream || musicChannels_g[index].xmctx)
{ {
musicChannels_g[index].stream = NULL; musicChannels_g[index].stream = NULL;
musicChannels_g[index].xmctx = NULL; musicChannels_g[index].xmctx = NULL;
@ -913,11 +940,15 @@ void StopMusicStream(int index)
} }
//get number of music channels active at this time, this does not mean they are playing //get number of music channels active at this time, this does not mean they are playing
int getMusicStreamCount(void)
int GetMusicStreamCount(void)
{ {
int musicCount = 0; int musicCount = 0;
for(int musicIndex = 0; musicIndex < MAX_MUSIC_STREAMS; musicIndex++) // find empty music slot
// Find empty music slot
for (int musicIndex = 0; musicIndex < MAX_MUSIC_STREAMS; musicIndex++)
{
if(musicChannels_g[musicIndex].stream != NULL || musicChannels_g[musicIndex].chipTune) musicCount++; if(musicChannels_g[musicIndex].stream != NULL || musicChannels_g[musicIndex].chipTune) musicCount++;
}
return musicCount; return musicCount;
} }
@ -939,8 +970,11 @@ void ResumeMusicStream(int index)
{ {
// Resume music playing... if music available! // Resume music playing... if music available!
ALenum state; ALenum state;
if(index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc){
if (index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc)
{
alGetSourcei(musicChannels_g[index].mixc->alSource, AL_SOURCE_STATE, &state); alGetSourcei(musicChannels_g[index].mixc->alSource, AL_SOURCE_STATE, &state);
if (state == AL_PAUSED) if (state == AL_PAUSED)
{ {
TraceLog(INFO, "Resuming music stream"); TraceLog(INFO, "Resuming music stream");
@ -956,8 +990,10 @@ bool IsMusicPlaying(int index)
bool playing = false; bool playing = false;
ALint state; ALint state;
if(index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc){
if (index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc)
{
alGetSourcei(musicChannels_g[index].mixc->alSource, AL_SOURCE_STATE, &state); alGetSourcei(musicChannels_g[index].mixc->alSource, AL_SOURCE_STATE, &state);
if (state == AL_PLAYING) playing = true; if (state == AL_PLAYING) playing = true;
} }
@ -967,14 +1003,17 @@ bool IsMusicPlaying(int index)
// Set volume for music // Set volume for music
void SetMusicVolume(int index, float volume) void SetMusicVolume(int index, float volume)
{ {
if(index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc){
if (index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc)
{
alSourcef(musicChannels_g[index].mixc->alSource, AL_GAIN, volume); alSourcef(musicChannels_g[index].mixc->alSource, AL_GAIN, volume);
} }
} }
// Set pitch for music
void SetMusicPitch(int index, float pitch) void SetMusicPitch(int index, float pitch)
{ {
if(index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc){
if (index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc)
{
alSourcef(musicChannels_g[index].mixc->alSource, AL_PITCH, pitch); alSourcef(musicChannels_g[index].mixc->alSource, AL_PITCH, pitch);
} }
} }
@ -983,14 +1022,9 @@ void SetMusicPitch(int index, float pitch)
float GetMusicTimeLength(int index) float GetMusicTimeLength(int index)
{ {
float totalSeconds; float totalSeconds;
if (musicChannels_g[index].chipTune)
{
totalSeconds = (float)musicChannels_g[index].totalLengthSeconds;
}
else
{
totalSeconds = stb_vorbis_stream_length_in_seconds(musicChannels_g[index].stream);
}
if (musicChannels_g[index].chipTune) totalSeconds = (float)musicChannels_g[index].totalLengthSeconds;
else totalSeconds = stb_vorbis_stream_length_in_seconds(musicChannels_g[index].stream);
return totalSeconds; return totalSeconds;
} }
@ -999,7 +1033,8 @@ float GetMusicTimeLength(int index)
float GetMusicTimePlayed(int index) float GetMusicTimePlayed(int index)
{ {
float secondsPlayed = 0.0f; float secondsPlayed = 0.0f;
if(index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc)
if (index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc)
{ {
if (musicChannels_g[index].chipTune && musicChannels_g[index].xmctx) if (musicChannels_g[index].chipTune && musicChannels_g[index].xmctx)
{ {
@ -1033,33 +1068,33 @@ static bool BufferMusicStream(int index, int numBuffers)
short pcm[MUSIC_BUFFER_SIZE_SHORT]; short pcm[MUSIC_BUFFER_SIZE_SHORT];
float pcmf[MUSIC_BUFFER_SIZE_FLOAT]; float pcmf[MUSIC_BUFFER_SIZE_FLOAT];
int size = 0; // Total size of data steamed in L+R samples for xm floats, individual L or R for ogg shorts
bool active = true; // We can get more data from stream (not finished)
int size = 0; // Total size of data steamed in L+R samples for xm floats, individual L or R for ogg shorts
bool active = true; // We can get more data from stream (not finished)
if (musicChannels_g[index].chipTune) // There is no end of stream for xmfiles, once the end is reached zeros are generated for non looped chiptunes. if (musicChannels_g[index].chipTune) // There is no end of stream for xmfiles, once the end is reached zeros are generated for non looped chiptunes.
{ {
for(int x=0; x<numBuffers; x++)
for (int i = 0; i < numBuffers; i++)
{ {
if(musicChannels_g[index].modctx.mod_loaded){
if(musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_SHORT)
size = MUSIC_BUFFER_SIZE_SHORT / 2;
else
size = musicChannels_g[index].totalSamplesLeft / 2;
if (musicChannels_g[index].modctx.mod_loaded)
{
if (musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_SHORT) size =</span> MUSIC_BUFFER_SIZE_SHORT class="o">/2;
else size = musicChannels_g[index].totalSamplesLeft/2;
jar_mod_fillbuffer(&musicChannels_g[index].modctx, pcm, size, 0 ); jar_mod_fillbuffer(&musicChannels_g[index].modctx, pcm, size, 0 );
BufferMixChannel(musicChannels_g[index].mixc, pcm, size * 2);
BufferMixChannel(musicChannels_g[index].mixc, pcm, size*2);
} }
else nf">if(musicChannels_g[index].xmctx){
if(musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_FLOAT)
size = MUSIC_BUFFER_SIZE_FLOAT / 2;
else
size = musicChannels_g[index].totalSamplesLeft / 2;
else k">if (musicChannels_g[index].xmctx)
{
if (musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_FLOAT) size =</span> MUSIC_BUFFER_SIZE_FLOAT class="o">/2;
else size = musicChannels_g[index].totalSamplesLeft/2;
jar_xm_generate_samples(musicChannels_g[index].xmctx, pcmf, size); // reads 2*readlen shorts and moves them to buffer+size memory location jar_xm_generate_samples(musicChannels_g[index].xmctx, pcmf, size); // reads 2*readlen shorts and moves them to buffer+size memory location
BufferMixChannel(musicChannels_g[index].mixc, pcmf, size * 2);
BufferMixChannel(musicChannels_g[index].mixc, pcmf, size*2);
} }
musicChannels_g[index].totalSamplesLeft -= size; musicChannels_g[index].totalSamplesLeft -= size;
if(musicChannels_g[index].totalSamplesLeft <= 0)
if (musicChannels_g[index].totalSamplesLeft <= 0)
{ {
active = false; active = false;
break; break;
@ -1068,17 +1103,16 @@ static bool BufferMusicStream(int index, int numBuffers)
} }
else else
{ {
if(musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_SHORT)
size = MUSIC_BUFFER_SIZE_SHORT;
else
size = musicChannels_g[index].totalSamplesLeft;
if (musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_SHORT) size = MUSIC_BUFFER_SIZE_SHORT;
else size = musicChannels_g[index].totalSamplesLeft;
for(int x=0; x<numBuffers; x++)
for (int i = 0; i < numBuffers; i++)
{ {
int streamedBytes = stb_vorbis_get_samples_short_interleaved(musicChannels_g[index].stream, musicChannels_g[index].mixc->channels, pcm, size); int streamedBytes = stb_vorbis_get_samples_short_interleaved(musicChannels_g[index].stream, musicChannels_g[index].mixc->channels, pcm, size);
BufferMixChannel(musicChannels_g[index].mixc, pcm, streamedBytes * musicChannels_g[index].mixc->channels); BufferMixChannel(musicChannels_g[index].mixc, pcm, streamedBytes * musicChannels_g[index].mixc->channels);
musicChannels_g[index].totalSamplesLeft -= streamedBytes * musicChannels_g[index].mixc->channels; musicChannels_g[index].totalSamplesLeft -= streamedBytes * musicChannels_g[index].mixc->channels;
if(musicChannels_g[index].totalSamplesLeft <= 0)
if (musicChannels_g[index].totalSamplesLeft <= 0)
{ {
active = false; active = false;
break; break;
@ -1105,7 +1139,7 @@ static void EmptyMusicStream(int index)
} }
} }
//determine if a music stream is ready to be written to
// Determine if a music stream is ready to be written
static int IsMusicStreamReadyForBuffering(int index) static int IsMusicStreamReadyForBuffering(int index)
{ {
ALint processed = 0; ALint processed = 0;
@ -1120,7 +1154,7 @@ void UpdateMusicStream(int index)
bool active = true; bool active = true;
int numBuffers = IsMusicStreamReadyForBuffering(index); int numBuffers = IsMusicStreamReadyForBuffering(index);
if (musicChannels_g[index].mixc->playing && index < MAX_MUSIC_STREAMS && musicEnabled_g && musicChannels_g[index].mixc && numBuffers)
if (musicChannels_g[index].mixc->playing && p">(index < MAX_MUSIC_STREAMS) && musicEnabled_g && musicChannels_g[index].mixc && numBuffers)
{ {
active = BufferMusicStream(index, numBuffers); active = BufferMusicStream(index, numBuffers);
@ -1136,9 +1170,9 @@ void UpdateMusicStream(int index)
stb_vorbis_seek_start(musicChannels_g[index].stream); stb_vorbis_seek_start(musicChannels_g[index].stream);
musicChannels_g[index].totalSamplesLeft = stb_vorbis_stream_length_in_samples(musicChannels_g[index].stream) * musicChannels_g[index].mixc->channels; musicChannels_g[index].totalSamplesLeft = stb_vorbis_stream_length_in_samples(musicChannels_g[index].stream) * musicChannels_g[index].mixc->channels;
} }
active = true; active = true;
} }
if (alGetError() != AL_NO_ERROR) TraceLog(WARNING, "Error buffering data..."); if (alGetError() != AL_NO_ERROR) TraceLog(WARNING, "Error buffering data...");
@ -1149,9 +1183,6 @@ void UpdateMusicStream(int index)
if (!active) StopMusicStream(index); if (!active) StopMusicStream(index);
} }
else
return;
} }
// Load WAV file into Wave structure // Load WAV file into Wave structure

+ 1
- 19
src/audio.h View File

@ -47,24 +47,6 @@
#endif #endif
#endif #endif
typedef enum {
ERROR_RAW_CONTEXT_CREATION = 1,
ERROR_XM_CONTEXT_CREATION = 2,
ERROR_MOD_CONTEXT_CREATION = 4,
ERROR_MIX_CHANNEL_CREATION = 8,
ERROR_MUSIC_CHANNEL_CREATION = 16,
ERROR_LOADING_XM = 32,
ERROR_LOADING_MOD = 64,
ERROR_LOADING_WAV = 128,
ERROR_LOADING_OGG = 256,
ERROR_OUT_OF_MIX_CHANNELS = 512,
ERROR_EXTENSION_NOT_RECOGNIZED = 1024,
ERROR_UNABLE_TO_OPEN_RRES_FILE = 2048,
ERROR_INVALID_RRES_FILE = 4096,
ERROR_INVALID_RRES_RESOURCE = 8192,
ERROR_UNINITIALIZED_CHANNELS = 16384
} AudioError;
// Sound source type // Sound source type
typedef struct Sound { typedef struct Sound {
unsigned int source; unsigned int source;
@ -120,7 +102,7 @@ bool IsMusicPlaying(int index); // Check if musi
void SetMusicVolume(int index, float volume); // Set volume for music (1.0 is max level) void SetMusicVolume(int index, float volume); // Set volume for music (1.0 is max level)
float GetMusicTimeLength(int index); // Get music time length (in seconds) float GetMusicTimeLength(int index); // Get music time length (in seconds)
float GetMusicTimePlayed(int index); // Get current music time played (in seconds) float GetMusicTimePlayed(int index); // Get current music time played (in seconds)
int getMusicStreamCount(void);
int GetMusicStreamCount(void);
void SetMusicPitch(int index, float pitch); void SetMusicPitch(int index, float pitch);
// used to output raw audio streams, returns negative numbers on error // used to output raw audio streams, returns negative numbers on error

+ 1
- 22
src/raylib.h View File

@ -452,29 +452,10 @@ typedef struct Ray {
Vector3 direction; Vector3 direction;
} Ray; } Ray;
typedef enum { // allows errors to be & together
ERROR_RAW_CONTEXT_CREATION = 1,
ERROR_XM_CONTEXT_CREATION = 2,
ERROR_MOD_CONTEXT_CREATION = 4,
ERROR_MIX_CHANNEL_CREATION = 8,
ERROR_MUSIC_CHANNEL_CREATION = 16,
ERROR_LOADING_XM = 32,
ERROR_LOADING_MOD = 64,
ERROR_LOADING_WAV = 128,
ERROR_LOADING_OGG = 256,
ERROR_OUT_OF_MIX_CHANNELS = 512,
ERROR_EXTENSION_NOT_RECOGNIZED = 1024,
ERROR_UNABLE_TO_OPEN_RRES_FILE = 2048,
ERROR_INVALID_RRES_FILE = 4096,
ERROR_INVALID_RRES_RESOURCE = 8192,
ERROR_UNINITIALIZED_CHANNELS = 16384
} AudioError;
// Sound source type // Sound source type
typedef struct Sound { typedef struct Sound {
unsigned int source; unsigned int source;
unsigned int buffer; unsigned int buffer;
AudioError error; // if there was any error during the creation or use of this Sound
} Sound; } Sound;
// Wave type, defines audio wave data // Wave type, defines audio wave data
@ -488,8 +469,6 @@ typedef struct Wave {
typedef int RawAudioContext; typedef int RawAudioContext;
// Texture formats // Texture formats
// NOTE: Support depends on OpenGL version and platform // NOTE: Support depends on OpenGL version and platform
typedef enum { typedef enum {
@ -940,7 +919,7 @@ bool IsMusicPlaying(int index); // Check if musi
void SetMusicVolume(int index, float volume); // Set volume for music (1.0 is max level) void SetMusicVolume(int index, float volume); // Set volume for music (1.0 is max level)
float GetMusicTimeLength(int index); // Get current music time length (in seconds) float GetMusicTimeLength(int index); // Get current music time length (in seconds)
float GetMusicTimePlayed(int index); // Get current music time played (in seconds) float GetMusicTimePlayed(int index); // Get current music time played (in seconds)
int getMusicStreamCount(void);
int GetMusicStreamCount(void);
void SetMusicPitch(int index, float pitch); void SetMusicPitch(int index, float pitch);
// used to output raw audio streams, returns negative numbers on error // used to output raw audio streams, returns negative numbers on error

Write Preview
Loading…
Cancel
Save