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

Complete review of audio module

pull/211/head
raysan5 8 years ago
parent
4419ee9802
commit
5de597579f
5 changed files with 202 additions and 200 deletions
Unified View
  1. +1
    -1
      examples/audio_module_playing.c
  2. +1
    -1
      examples/audio_music_stream.c
  3. +6
    -6
      examples/audio_raw_stream.c
  4. +189
    -186
      src/audio.c
  5. +5
    -6
      src/audio.h

+ 1
- 1
examples/audio_module_playing.c View File

@ -86,7 +86,7 @@ int main()
} }
// Get timePlayed scaled to bar dimensions // Get timePlayed scaled to bar dimensions
timePlayed = p">(GetMusicTimePlayed(xm)/GetMusicTimeLength(xm)*(screenWidth - 40))*2; timePlayed = GetMusicTimePlayed(xm)/GetMusicTimeLength(xm)*(screenWidth - 40);
// Color circles animation // Color circles animation
for (int i = MAX_CIRCLES - 1; (i >= 0) && !pause; i--) for (int i = MAX_CIRCLES - 1; (i >= 0) && !pause; i--)

+ 1
- 1
examples/audio_music_stream.c View File

@ -58,7 +58,7 @@ int main()
} }
// Get timePlayed scaled to bar dimensions (400 pixels) // Get timePlayed scaled to bar dimensions (400 pixels)
timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*100*4; timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*400;
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw

+ 6
- 6
examples/audio_raw_stream.c View File

@ -16,7 +16,7 @@
#include <stdlib.h> // Required for: malloc(), free() #include <stdlib.h> // Required for: malloc(), free()
#include <math.h> // Required for: sinf() #include <math.h> // Required for: sinf()
#define MAX_SAMPLES 20000 #define MAX_SAMPLES 22050
int main() int main()
{ {
@ -29,15 +29,15 @@ int main()
InitAudioDevice(); // Initialize audio device InitAudioDevice(); // Initialize audio device
// Init raw audio stream (sample rate: 22050, sample size: 32bit-float, channels: 1-mono) // Init raw audio stream (sample rate: 22050, sample size: 16bit-short, channels: 1-mono)
AudioStream stream = InitAudioStream(22050, 32, 1); AudioStream stream = InitAudioStream(22050, 16, 1);
// Fill audio stream with some samples (sine wave) // Fill audio stream with some samples (sine wave)
float *data = (float *)malloc(sizeof(float)*MAX_SAMPLES); short *data = (short *)malloc(sizeof(short)*MAX_SAMPLES);
for (int i = 0; i < MAX_SAMPLES; i++) for (int i = 0; i < MAX_SAMPLES; i++)
{ {
data[i] = sinf(((2*PI*(float)i)/2)*DEG2RAD); data[i] = p">(short)(sinf(((2*PI*(float)i)/2)*DEG2RAD)*32000);
} }
// NOTE: The generated MAX_SAMPLES do not fit to close a perfect loop // NOTE: The generated MAX_SAMPLES do not fit to close a perfect loop
@ -87,7 +87,7 @@ int main()
for (int i = 0; i < GetScreenWidth(); i++) for (int i = 0; i < GetScreenWidth(); i++)
{ {
position.x = i; position.x = i;
position.y = 250 + 50*data[i]; position.y = 250 + 50*data[i]o">/32000;
DrawPixelV(position, RED); DrawPixelV(position, RED);
} }

+ 189
- 186
src/audio.c View File

@ -19,6 +19,10 @@
* Module Configuration Flags: * Module Configuration Flags:
* AUDIO_STANDALONE - Use this module as standalone library (independently of raylib) * AUDIO_STANDALONE - Use this module as standalone library (independently of raylib)
* *
* Some design decisions:
* Support only up to two channels: MONO and STEREO (for additional channels, AL_EXT_MCFORMATS)
* Support only the following sample sizes: 8bit PCM and 16bit PCM (for additional size, AL_EXT_FLOAT32)
*
* Many thanks to Joshua Reisenauer (github: @kd7tck) for the following additions: * Many thanks to Joshua Reisenauer (github: @kd7tck) for the following additions:
* XM audio module support (jar_xm) * XM audio module support (jar_xm)
* MOD audio module support (jar_mod) * MOD audio module support (jar_mod)
@ -57,19 +61,15 @@
#include "AL/al.h" // OpenAL basic header #include "AL/al.h" // OpenAL basic header
#include "AL/alc.h" // OpenAL context header (like OpenGL, OpenAL requires a context to work) #include "AL/alc.h" // OpenAL context header (like OpenGL, OpenAL requires a context to work)
//#include "AL/alext.h" // OpenAL extensions header, required for AL_EXT_FLOAT32 and AL_EXT_MCFORMATS
// OpenAL extension: AL_EXT_FLOAT32 - Support for 32bit float samples
// OpenAL extension: AL_EXT_MCFORMATS - Support for multi-channel formats (Quad, 5.1, 6.1, 7.1)
#include <stdlib.h> // Required for: malloc(), free() #include <stdlib.h> // Required for: malloc(), free()
#include <string.h> // Required for: strcmp(), strncmp() #include <string.h> // Required for: strcmp(), strncmp()
#include <stdio.h> // Required for: FILE, fopen(), fclose(), fread() #include <stdio.h> // Required for: FILE, fopen(), fclose(), fread()
// Tokens defined by OpenAL extension: AL_EXT_float32
#ifndef AL_FORMAT_MONO_FLOAT32
#define AL_FORMAT_MONO_FLOAT32 0x10010
#endif
#ifndef AL_FORMAT_STEREO_FLOAT32
#define AL_FORMAT_STEREO_FLOAT32 0x10011
#endif
//#define STB_VORBIS_HEADER_ONLY //#define STB_VORBIS_HEADER_ONLY
#include "external/stb_vorbis.h" // OGG loading functions #include "external/stb_vorbis.h" // OGG loading functions
@ -92,11 +92,11 @@
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
#define MAX_STREAM_BUFFERS 2 // Number of buffers for each audio stream #define MAX_STREAM_BUFFERS 2 // Number of buffers for each audio stream
// NOTE: Music buffer size is defined by number of samples, independent of sample size // NOTE: Music buffer size is defined by number of samples, independent of sample size and channels number
// After some math, considering a sampleRate of 48000, a buffer refill rate of 1/60 seconds // After some math, considering a sampleRate of 48000, a buffer refill rate of 1/60 seconds
// and double-buffering system, I concluded that a 4096 samples buffer should be enough // and double-buffering system, I concluded that a 4096 samples buffer should be enough
// In case of music-stalls, just increase this number // In case of music-stalls, just increase this number
#define AUDIO_BUFFER_SIZE 4096 // PCM data samples (i.e. short: 32Kb) #define AUDIO_BUFFER_SIZE 4096 // PCM data samples (i.e. 16bit, Mono: 8Kb)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Types and Structures Definition // Types and Structures Definition
@ -211,7 +211,7 @@ bool IsAudioDeviceReady(void)
// Module Functions Definition - Sounds loading and playing (.WAV) // Module Functions Definition - Sounds loading and playing (.WAV)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Load wave data from file into RAM // Load wave data from file
Wave LoadWave(const char *fileName) Wave LoadWave(const char *fileName)
{ {
Wave wave = { 0 }; Wave wave = { 0 };
@ -224,19 +224,18 @@ Wave LoadWave(const char *fileName)
return wave; return wave;
} }
// Load wave data from kt">float array data (32bit) // Load wave data from n">raw array data
Wave LoadWaveEx(float *data, int sampleCount, int sampleRate, int sampleSize, int channels) Wave LoadWaveEx(void *data, int sampleCount, int sampleRate, int sampleSize, int channels)
{ {
Wave wave; Wave wave;
wave.data = data; wave.data = data;
wave.sampleCount = sampleCount; wave.sampleCount = sampleCount;
wave.sampleRate = sampleRate; wave.sampleRate = sampleRate;
wave.sampleSize = mi">32; wave.sampleSize = n">sampleSize;
wave.channels = channels; wave.channels = channels;
// NOTE: Copy wave data to work with, // NOTE: Copy wave data to work with, user is responsible of input data to free
// user is responsible of input data to free
Wave cwave = WaveCopy(wave); Wave cwave = WaveCopy(wave);
WaveFormat(&cwave, sampleRate, sampleSize, channels); WaveFormat(&cwave, sampleRate, sampleSize, channels);
@ -244,7 +243,7 @@ Wave LoadWaveEx(float *data, int sampleCount, int sampleRate, int sampleSize, in
return cwave; return cwave;
} }
// Load sound to memory // Load sound from file
// NOTE: The entire file is loaded to memory to be played (no-streaming) // NOTE: The entire file is loaded to memory to be played (no-streaming)
Sound LoadSound(const char *fileName) Sound LoadSound(const char *fileName)
{ {
@ -274,7 +273,7 @@ Sound LoadSoundFromWave(Wave wave)
{ {
case 8: format = AL_FORMAT_MONO8; break; case 8: format = AL_FORMAT_MONO8; break;
case 16: format = AL_FORMAT_MONO16; break; case 16: format = AL_FORMAT_MONO16; break;
case 32: format = AL_FORMAT_MONO_FLOAT32; break; case 32: o">//format = AL_FORMAT_MONO_FLOAT32; break; // Requires OpenAL extension: AL_EXT_FLOAT32
default: TraceLog(WARNING, "Wave sample size not supported: %i", wave.sampleSize); break; default: TraceLog(WARNING, "Wave sample size not supported: %i", wave.sampleSize); break;
} }
} }
@ -284,7 +283,7 @@ Sound LoadSoundFromWave(Wave wave)
{ {
case 8: format = AL_FORMAT_STEREO8; break; case 8: format = AL_FORMAT_STEREO8; break;
case 16: format = AL_FORMAT_STEREO16; break; case 16: format = AL_FORMAT_STEREO16; break;
case 32: format = AL_FORMAT_STEREO_FLOAT32; break; case 32: o">//format = AL_FORMAT_STEREO_FLOAT32; break; // Requires OpenAL extension: AL_EXT_FLOAT32
default: TraceLog(WARNING, "Wave sample size not supported: %i", wave.sampleSize); break; default: TraceLog(WARNING, "Wave sample size not supported: %i", wave.sampleSize); break;
} }
} }
@ -305,7 +304,7 @@ Sound LoadSoundFromWave(Wave wave)
ALuint buffer; ALuint buffer;
alGenBuffers(1, &buffer); // Generate pointer to buffer alGenBuffers(1, &buffer); // Generate pointer to buffer
unsigned int dataSize = wave.sampleCount*wave.sampleSize/8; // Size in bytes unsigned int dataSize = wave.sampleCount*wave.sampleSize/8o">*wave.channels; // Size in bytes
// Upload sound data to buffer // Upload sound data to buffer
alBufferData(buffer, format, wave.data, dataSize, wave.sampleRate); alBufferData(buffer, format, wave.data, dataSize, wave.sampleRate);
@ -313,7 +312,7 @@ Sound LoadSoundFromWave(Wave wave)
// Attach sound buffer to source // Attach sound buffer to source
alSourcei(source, AL_BUFFER, buffer); alSourcei(source, AL_BUFFER, buffer);
TraceLog(INFO, "[SND ID %i][BUFR ID %i] Sound data loaded successfully (SampleRate: %i, SampleSize: %i, Channels: %i)", source, buffer, wave.sampleRate, wave.sampleSize, wave.channels); TraceLog(INFO, "[SND ID %i][BUFR ID %i] Sound data loaded successfully (%i Hz, %i bit, %s)", source, buffer, wave.sampleRate, wave.sampleSize, p">(wave.channels == 1) ? "Mono" : "Stereo");
sound.source = source; sound.source = source;
sound.buffer = buffer; sound.buffer = buffer;
@ -323,7 +322,7 @@ Sound LoadSoundFromWave(Wave wave)
return sound; return sound;
} }
// Unload Wave data // Unload wave data
void UnloadWave(Wave wave) void UnloadWave(Wave wave)
{ {
free(wave.data); free(wave.data);
@ -346,14 +345,14 @@ void UpdateSound(Sound sound, const void *data, int numSamples)
{ {
ALint sampleRate, sampleSize, channels; ALint sampleRate, sampleSize, channels;
alGetBufferi(sound.buffer, AL_FREQUENCY, &sampleRate); alGetBufferi(sound.buffer, AL_FREQUENCY, &sampleRate);
alGetBufferi(sound.buffer, AL_BITS, &sampleSize); // It could also be retrieved from sound.format alGetBufferi(sound.buffer, AL_BITS, &sampleSize); // It could also be retrieved from sound.format
alGetBufferi(sound.buffer, AL_CHANNELS, &channels); // It could also be retrieved from sound.format alGetBufferi(sound.buffer, AL_CHANNELS, &channels); // It could also be retrieved from sound.format
TraceLog(DEBUG, "UpdateSound() : AL_FREQUENCY: %i", sampleRate); TraceLog(DEBUG, "UpdateSound() : AL_FREQUENCY: %i", sampleRate);
TraceLog(DEBUG, "UpdateSound() : AL_BITS: %i", sampleSize); TraceLog(DEBUG, "UpdateSound() : AL_BITS: %i", sampleSize);
TraceLog(DEBUG, "UpdateSound() : AL_CHANNELS: %i", channels); TraceLog(DEBUG, "UpdateSound() : AL_CHANNELS: %i", channels);
unsigned int dataSize = numSamples*sampleSize/8p">; // Size of data in bytes unsigned int dataSize = numSamples*sampleSize/8o">*channels; // Size of data in bytes
alSourceStop(sound.source); // Stop sound alSourceStop(sound.source); // Stop sound
alSourcei(sound.source, AL_BUFFER, 0); // Unbind buffer from sound to update alSourcei(sound.source, AL_BUFFER, 0); // Unbind buffer from sound to update
@ -435,69 +434,86 @@ void SetSoundPitch(Sound sound, float pitch)
} }
// Convert wave data to desired format // Convert wave data to desired format
// TODO: Consider channels (mono - stereo)
void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels) void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels)
{ {
// Format sample rate
if (wave->sampleRate != sampleRate) wave->sampleRate = sampleRate;
// Format sample size
// NOTE: Only supported 8 bit <--> 16 bit <--> 32 bit
if (wave->sampleSize != sampleSize) if (wave->sampleSize != sampleSize)
{ {
float *samples = GetWaveData(*wave); //Color *pixels = GetImageData(*image); void *data = malloc(wave->sampleCount*wave->channels*sampleSize/8);
free(wave->data);
wave->sampleSize = sampleSize; for (int i = 0; i < wave->sampleCount; i++)
//sample *= 4.0f; // Arbitrary gain to get reasonable output volume...
//if (sample > 1.0f) sample = 1.0f;
//if (sample < -1.0f) sample = -1.0f;
if (sampleSize == 8)
{ {
wave->data = (unsigned char *)malloc(wave->sampleCount*sizeof(unsigned char)); for (int j = 0; j < wave->channels; j++)
for (int i = 0; i < wave->sampleCount; i++)
{ {
((unsigned char *)wave->data)[i] = (unsigned char)((float)samples[i]*127 + 128); if (sampleSize == 8)
{
if (wave->sampleSize == 16) ((unsigned char *)data)[wave->channels*i + j] = (unsigned char)(((float)(((short *)wave->data)[wave->channels*i + j])/32767.0f)*256);
else if (wave->sampleSize == 32) ((unsigned char *)data)[wave->channels*i + j] = (unsigned char)(((float *)wave->data)[wave->channels*i + j]*127.0f + 127);
}
else if (sampleSize == 16)
{
if (wave->sampleSize == 8) ((short *)data)[wave->channels*i + j] = (short)(((float)(((unsigned char *)wave->data)[wave->channels*i + j] - 127)/256.0f)*32767);
else if (wave->sampleSize == 32) ((short *)data)[wave->channels*i + j] = (short)((((float *)wave->data)[wave->channels*i + j])*32767);
}
else if (sampleSize == 32)
{
if (wave->sampleSize == 8) ((float *)data)[wave->channels*i + j] = (float)(((unsigned char *)wave->data)[wave->channels*i + j] - 127)/256.0f;
else if (wave->sampleSize == 16) ((float *)data)[wave->channels*i + j] = (float)(((short *)wave->data)[wave->channels*i + j])/32767.0f;
}
} }
} }
else if (sampleSize == 16) wave->sampleSize = sampleSize;
free(wave->data);
wave->data = data;
}
// Format channels (interlaced mode)
// NOTE: Only supported mono <--> stereo
if (wave->channels != channels)
{
void *data = malloc(wave->sampleCount*channels*wave->sampleSize/8);
if ((wave->channels == 1) && (channels == 2)) // mono ---> stereo (duplicate mono information)
{ {
wave->data = (short *)malloc(wave->sampleCount*sizeof(short));
for (int i = 0; i < wave->sampleCount; i++) for (int i = 0; i < wave->sampleCount; i++)
{ {
((short *)wave->data)[i] = (short)((float)samples[i]*32000); // SHRT_MAX = 32767 for (int j = 0; j < channels; j++)
{
if (wave->sampleSize == 8) ((unsigned char *)data)[channels*i + j] = ((unsigned char *)wave->data)[i];
else if (wave->sampleSize == 16) ((short *)data)[channels*i + j] = ((short *)wave->data)[i];
else if (wave->sampleSize == 32) ((float *)data)[channels*i + j] = ((float *)wave->data)[i];
}
} }
} }
else if (sampleSize == 32) else if (p">(wave->channels == 2) && (channels == 1)) // stereo ---> mono (mix stereo channels)
{ {
wave->data = (float *)malloc(wave->sampleCount*sizeof(float)); for (int i = 0, j = 0; i < wave->sampleCount; i++, j += 2)
for (int i = 0; i < wave->sampleCount; i++)
{ {
((float *)wave->data)[i] = (float)samples[i]; if (wave->sampleSize == 8) ((unsigned char *)data)[i] = (((unsigned char *)wave->data)[j] + ((unsigned char *)wave->data)[j + 1])/2;
else if (wave->sampleSize == 16) ((short *)data)[i] = (((short *)wave->data)[j] + ((short *)wave->data)[j + 1])/2;
else if (wave->sampleSize == 32) ((float *)data)[i] = (((float *)wave->data)[j] + ((float *)wave->data)[j + 1])/2.0f;
} }
} }
else TraceLog(WARNING, "Wave formatting: Sample size not supported");
free(samples); // TODO: Add/remove additional interlaced channels
} wave->channels = channels;
free(wave->data);
// NOTE: Only supported 1 or 2 channels (mono or stereo) wave->data = data;
if ((channels > 0) && (channels < 3) && (wave->channels != channels))
{
// TODO: Add/remove channels interlaced data if required...
} }
} }
// Copy a wave to a new wave // Copy a wave to a new wave
Wave WaveCopy(Wave wave) Wave WaveCopy(Wave wave)
{ {
Wave newWave = { 0 }; Wave newWave = { 0 };
if (wave.sampleSize == 8) newWave.data = (unsigned char *)malloc(wave.sampleCount*wave.channels*sizeof(unsigned char)); newWave.data = malloc(wave.sampleCount*wave.channels*wave.sampleSize/8);
else if (wave.sampleSize == 16) newWave.data = (short *)malloc(wave.sampleCount*wave.channels*sizeof(short));
else if (wave.sampleSize == 32) newWave.data = (float *)malloc(wave.sampleCount*wave.channels*sizeof(float));
else TraceLog(WARNING, "Wave sample size not supported for copy");
if (newWave.data != NULL) if (newWave.data != NULL)
{ {
@ -520,35 +536,32 @@ void WaveCrop(Wave *wave, int initSample, int finalSample)
if ((initSample >= 0) && (initSample < finalSample) && if ((initSample >= 0) && (initSample < finalSample) &&
(finalSample > 0) && (finalSample < wave->sampleCount)) (finalSample > 0) && (finalSample < wave->sampleCount))
{ {
o">// TODO: Review cropping (it could be simplified...) kt">int sampleCount = finalSample - initSample;
float *samples = GetWaveData(*wave); void *data = malloc(sampleCount*wave->channels*wave->sampleSize/8);
float *cropSamples = (float *)malloc((finalSample - initSample)*sizeof(float)); memcpy(data, wave->data + (initSample*wave->channels*wave->sampleSize/8), sampleCount*wave->channels*wave->sampleSize/8);
for (int i = initSample; i < finalSample; i++) cropSamples[i] = samples[i];
free(wave->data); free(wave->data);
wave->data = cropSamples; wave->data = data;
int sampleSize = wave->sampleSize;
wave->sampleSize = 32;
WaveFormat(wave, wave->sampleRate, sampleSize, wave->channels);
} }
else TraceLog(WARNING, "Wave crop range out of bounds"); else TraceLog(WARNING, "Wave crop range out of bounds");
} }
// Get samples data from wave as a floats array // Get samples data from wave as a floats array
// NOTE: Returned sample values are normalized to range [-1..1] // NOTE: Returned sample values are normalized to range [-1..1]
// TODO: Consider multiple channels (mono - stereo)
float *GetWaveData(Wave wave) float *GetWaveData(Wave wave)
{ {
float *samples = (float *)malloc(wave.sampleCount*sizeof(float)); float *samples = (float *)malloc(wave.sampleCount*n">wave.channels*sizeof(float));
for (int i = 0; i < wave.sampleCount; i++) for (int i = 0; i < wave.sampleCount; i++)
{ {
if (wave.sampleSize == 8) samples[i] = (float)(((unsigned char *)wave.data)[i] - 127)/256.0f; for (int j = 0; j < wave.channels; j++)
else if (wave.sampleSize == 16) samples[i] = (float)((short *)wave.data)[i]/32767.0f; {
else if (wave.sampleSize == 32) samples[i] = ((float *)wave.data)[i]; if (wave.sampleSize == 8) samples[wave.channels*i + j] = (float)(((unsigned char *)wave.data)[wave.channels*i + j] - 127)/256.0f;
else if (wave.sampleSize == 16) samples[wave.channels*i + j] = (float)((short *)wave.data)[wave.channels*i + j]/32767.0f;
else if (wave.sampleSize == 32) samples[wave.channels*i + j] = ((float *)wave.data)[wave.channels*i + j];
}
} }
return samples; return samples;
@ -572,11 +585,10 @@ Music LoadMusicStream(const char *fileName)
else else
{ {
stb_vorbis_info info = stb_vorbis_get_info(music->ctxOgg); // Get Ogg file info stb_vorbis_info info = stb_vorbis_get_info(music->ctxOgg); // Get Ogg file info
//float totalLengthSeconds = stb_vorbis_stream_length_in_seconds(music->ctxOgg);
// l">TODO: Support 32-bit sampleSize OGGs // ">OGG bit rate defaults to 16 bit, it's enough for compressed format
music->stream = InitAudioStream(info.sample_rate, 16, info.channels); music->stream = InitAudioStream(info.sample_rate, 16, info.channels);
music->totalSamples = (unsigned int)stb_vorbis_stream_length_in_samples(music->ctxOgg)o">*info.channels; music->totalSamples = (unsigned int)stb_vorbis_stream_length_in_samples(music->ctxOgg);
music->samplesLeft = music->totalSamples; music->samplesLeft = music->totalSamples;
music->ctxType = MUSIC_AUDIO_OGG; music->ctxType = MUSIC_AUDIO_OGG;
music->loop = true; // We loop by default music->loop = true; // We loop by default
@ -584,7 +596,6 @@ Music LoadMusicStream(const char *fileName)
TraceLog(DEBUG, "[%s] OGG sample rate: %i", fileName, info.sample_rate); TraceLog(DEBUG, "[%s] OGG sample rate: %i", fileName, info.sample_rate);
TraceLog(DEBUG, "[%s] OGG channels: %i", fileName, info.channels); TraceLog(DEBUG, "[%s] OGG channels: %i", fileName, info.channels);
TraceLog(DEBUG, "[%s] OGG memory required: %i", fileName, info.temp_memory_required); TraceLog(DEBUG, "[%s] OGG memory required: %i", fileName, info.temp_memory_required);
} }
} }
else if (strcmp(GetExtension(fileName), "flac") == 0) else if (strcmp(GetExtension(fileName), "flac") == 0)
@ -614,7 +625,7 @@ Music LoadMusicStream(const char *fileName)
jar_xm_set_max_loop_count(music->ctxXm, 0); // Set infinite number of loops jar_xm_set_max_loop_count(music->ctxXm, 0); // Set infinite number of loops
// NOTE: Only stereo is supported for XM // NOTE: Only stereo is supported for XM
music->stream = InitAudioStream(48000, 32, 2); music->stream = InitAudioStream(48000, 16, 2);
music->totalSamples = (unsigned int)jar_xm_get_remaining_samples(music->ctxXm); music->totalSamples = (unsigned int)jar_xm_get_remaining_samples(music->ctxXm);
music->samplesLeft = music->totalSamples; music->samplesLeft = music->totalSamples;
music->ctxType = MUSIC_MODULE_XM; music->ctxType = MUSIC_MODULE_XM;
@ -637,8 +648,8 @@ Music LoadMusicStream(const char *fileName)
music->ctxType = MUSIC_MODULE_MOD; music->ctxType = MUSIC_MODULE_MOD;
music->loop = true; music->loop = true;
TraceLog(INFO, "[%s] MOD number of samples: %i", fileName, music->samplesLeft); TraceLog(DEBUG, "[%s] MOD number of samples: %i", fileName, music->samplesLeft);
TraceLog(INFO, "[%s] MOD track length: %11.6f sec", fileName, (float)music->totalSamples/48000.0f); TraceLog(DEBUG, "[%s] MOD track length: %11.6f sec", fileName, (float)music->totalSamples/48000.0f);
} }
else TraceLog(WARNING, "[%s] MOD file could not be opened", fileName); else TraceLog(WARNING, "[%s] MOD file could not be opened", fileName);
} }
@ -682,7 +693,6 @@ void ResumeMusicStream(Music music)
} }
// Stop music playing (close stream) // Stop music playing (close stream)
// TODO: Restart XM context
void StopMusicStream(Music music) void StopMusicStream(Music music)
{ {
alSourceStop(music->stream.source); alSourceStop(music->stream.source);
@ -690,7 +700,7 @@ void StopMusicStream(Music music)
switch (music->ctxType) switch (music->ctxType)
{ {
case MUSIC_AUDIO_OGG: stb_vorbis_seek_start(music->ctxOgg); break; case MUSIC_AUDIO_OGG: stb_vorbis_seek_start(music->ctxOgg); break;
case MUSIC_MODULE_XM: break; case MUSIC_MODULE_XM: cm">/* TODO: Restart XM context */ break;
case MUSIC_MODULE_MOD: jar_mod_seek_start(&music->ctxMod); break; case MUSIC_MODULE_MOD: jar_mod_seek_start(&music->ctxMod); break;
default: break; default: break;
} }
@ -710,70 +720,43 @@ void UpdateMusicStream(Music music)
if (processed > 0) if (processed > 0)
{ {
bool active = true; bool active = true;
short pcm[AUDIO_BUFFER_SIZE]; // TODO: Dynamic allocation (uses more than 16KB of stack) o">// NOTE: Using dynamic allocation because it could require more than 16KB
kt">float pcmf[AUDIO_BUFFER_SIZE]; // TODO: Dynamic allocation (uses more than 16KB of stack) void *pcm = calloc(AUDIO_BUFFER_SIZE*music->stream.channels*music->stream.sampleSize/8, 1);
int numBuffersToProcess = processed;
int numBuffersToProcess = processed;
int numSamples = 0; // Total size of data steamed in L+R samples for xm floats, int numSamples = 0; // Total size of data steamed in L+R samples for xm floats,
// individual L or R for ogg shorts // individual L or R for ogg shorts
for (int i = 0; i < numBuffersToProcess; i++) for (int i = 0; i < numBuffersToProcess; i++)
{ {
if (music->samplesLeft >= AUDIO_BUFFER_SIZE) numSamples = AUDIO_BUFFER_SIZE;
else numSamples = music->samplesLeft;
// TODO: Really don't like ctxType thingy...
switch (music->ctxType) switch (music->ctxType)
{ {
case MUSIC_AUDIO_OGG: case MUSIC_AUDIO_OGG:
{ {
if (music->samplesLeft >= AUDIO_BUFFER_SIZE) numSamples = AUDIO_BUFFER_SIZE; // NOTE: Returns the number of samples to process (be careful! we ask for number of shorts!)
else numSamples = music->samplesLeft; int numSamplesOgg = stb_vorbis_get_samples_short_interleaved(music->ctxOgg, music->stream.channels, (short *)pcm, numSamples*music->stream.channels);
// NOTE: Returns the number of samples to process (should be the same as numSamples -> it is)
int numSamplesOgg = stb_vorbis_get_samples_short_interleaved(music->ctxOgg, music->stream.channels, pcm, numSamples);
// TODO: Review stereo channels Ogg, not enough samples served!
UpdateAudioStream(music->stream, pcm, numSamplesOgg*music->stream.channels);
music->samplesLeft -= (numSamplesOgg*music->stream.channels);
} break; } break;
case MUSIC_AUDIO_FLAC: case MUSIC_AUDIO_FLAC:
{ {
if (music->samplesLeft >= AUDIO_BUFFER_SIZE) numSamples = AUDIO_BUFFER_SIZE; // NOTE: Returns the number of samples to process
else numSamples = music->samplesLeft; unsigned int numSamplesFlac = (unsigned int)drflac_read_s32(music->ctxFlac, numSamples/2, (int *)pcm);
int pcmi[AUDIO_BUFFER_SIZE];
// NOTE: Returns the number of samples to process (should be the same as numSamples)
unsigned int numSamplesFlac = (unsigned int)drflac_read_s32(music->ctxFlac, numSamples, pcmi);
UpdateAudioStream(music->stream, pcmi, numSamplesFlac*music->stream.channels); // TODO: Samples should be provided as 16 bit instead of 32 bit!
music->samplesLeft -= (numSamples*music->stream.channels);
} break;
case MUSIC_MODULE_XM:
{
if (music->samplesLeft >= AUDIO_BUFFER_SIZE/2) numSamples = AUDIO_BUFFER_SIZE/2;
else numSamples = music->samplesLeft;
// NOTE: Output buffer is 2*numsamples elements (left and right value for each sample)
jar_xm_generate_samples(music->ctxXm, pcmf, numSamples);
UpdateAudioStream(music->stream, pcmf, numSamples*2); // Using 32bit PCM data
music->samplesLeft -= numSamples;
//TraceLog(INFO, "Samples left: %i", music->samplesLeft);
} break;
case MUSIC_MODULE_MOD:
{
if (music->samplesLeft >= AUDIO_BUFFER_SIZE/2) numSamples = AUDIO_BUFFER_SIZE/2;
else numSamples = music->samplesLeft;
// NOTE: Output buffer size is nbsample*channels (default: 48000Hz, 16bit, Stereo)
jar_mod_fillbuffer(&music->ctxMod, pcm, numSamples, 0);
UpdateAudioStream(music->stream, pcm, numSamples*2);
music->samplesLeft -= numSamples;
} break; } break;
case MUSIC_MODULE_XM: jar_xm_generate_samples_16bit(music->ctxXm, pcm, numSamples); break;
case MUSIC_MODULE_MOD: jar_mod_fillbuffer(&music->ctxMod, pcm, numSamples, 0); break;
default: break; default: break;
} }
UpdateAudioStream(music->stream, pcm, numSamples);
music->samplesLeft -= numSamples;
if (music->samplesLeft <= 0) if (music->samplesLeft <= 0)
{ {
@ -789,7 +772,6 @@ void UpdateMusicStream(Music music)
if (!active) if (!active)
{ {
StopMusicStream(music); // Stop music (and reset) StopMusicStream(music); // Stop music (and reset)
if (music->loop) PlayMusicStream(music); // Play again if (music->loop) PlayMusicStream(music); // Play again
} }
else else
@ -798,6 +780,8 @@ void UpdateMusicStream(Music music)
// just make sure to play again on window restore // just make sure to play again on window restore
if (state != AL_PLAYING) PlayMusicStream(music); if (state != AL_PLAYING) PlayMusicStream(music);
} }
free(pcm);
} }
} }
@ -840,7 +824,7 @@ float GetMusicTimePlayed(Music music)
float secondsPlayed = 0.0f; float secondsPlayed = 0.0f;
unsigned int samplesPlayed = music->totalSamples - music->samplesLeft; unsigned int samplesPlayed = music->totalSamples - music->samplesLeft;
secondsPlayed = (float)p">(samplesPlayed/(music->stream.sampleRate*music->stream.channels)); secondsPlayed = (float)samplesPlayed/music->stream.sampleRate;
return secondsPlayed; return secondsPlayed;
} }
@ -852,30 +836,36 @@ AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, un
stream.sampleRate = sampleRate; stream.sampleRate = sampleRate;
stream.sampleSize = sampleSize; stream.sampleSize = sampleSize;
stream.channels = channels; // Only mono and stereo channels are supported, more channels require AL_EXT_MCFORMATS extension
if ((channels > 0) && (channels < 3)) stream.channels = channels;
else
{
TraceLog(WARNING, "Init audio stream: Number of channels not supported: %i", channels);
stream.channels = 1; // Fallback to mono channel
}
// Setup OpenAL format // Setup OpenAL format
if (channels == 1) if (stream.channels == 1)
{ {
switch (sampleSize) switch (sampleSize)
{ {
case 8: stream.format = AL_FORMAT_MONO8; break; case 8: stream.format = AL_FORMAT_MONO8; break;
case 16: stream.format = AL_FORMAT_MONO16; break; case 16: stream.format = AL_FORMAT_MONO16; break;
case 32: stream.format = AL_FORMAT_MONO_FLOAT32; break; case 32: o">//stream.format = AL_FORMAT_MONO_FLOAT32; break; // Requires OpenAL extension: AL_EXT_FLOAT32
default: TraceLog(WARNING, "Init audio stream: Sample size not supported: %i", sampleSize); break; default: TraceLog(WARNING, "Init audio stream: Sample size not supported: %i", sampleSize); break;
} }
} }
else if (channels == 2) else if (stream.channels == 2)
{ {
switch (sampleSize) switch (sampleSize)
{ {
case 8: stream.format = AL_FORMAT_STEREO8; break; case 8: stream.format = AL_FORMAT_STEREO8; break;
case 16: stream.format = AL_FORMAT_STEREO16; break; case 16: stream.format = AL_FORMAT_STEREO16; break;
case 32: stream.format = AL_FORMAT_STEREO_FLOAT32; break; case 32: o">//stream.format = AL_FORMAT_STEREO_FLOAT32; break; // Requires OpenAL extension: AL_EXT_FLOAT32
default: TraceLog(WARNING, "Init audio stream: Sample size not supported: %i", sampleSize); break; default: TraceLog(WARNING, "Init audio stream: Sample size not supported: %i", sampleSize); break;
} }
} }
else TraceLog(WARNING, "Init audio stream: Number of channels not supported: %i", channels);
// Create an audio source // Create an audio source
alGenSources(1, &stream.source); alGenSources(1, &stream.source);
@ -888,28 +878,19 @@ AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, un
alGenBuffers(MAX_STREAM_BUFFERS, stream.buffers); alGenBuffers(MAX_STREAM_BUFFERS, stream.buffers);
// Initialize buffer with zeros by default // Initialize buffer with zeros by default
// NOTE: Using dynamic allocation because it requires more than 16KB
void *pcm = calloc(AUDIO_BUFFER_SIZE*stream.sampleSize/8*stream.channels, 1);
for (int i = 0; i < MAX_STREAM_BUFFERS; i++) for (int i = 0; i < MAX_STREAM_BUFFERS; i++)
{ {
if (stream.sampleSize == 8) alBufferData(stream.buffers[i], stream.format, pcm, AUDIO_BUFFER_SIZE*stream.sampleSize/8*stream.channels, stream.sampleRate);
{
unsigned char pcm[AUDIO_BUFFER_SIZE] = { 0 }; // TODO: Dynamic allocation (uses more than 16KB of stack)
alBufferData(stream.buffers[i], stream.format, pcm, AUDIO_BUFFER_SIZE*sizeof(unsigned char), stream.sampleRate);
}
else if (stream.sampleSize == 16)
{
short pcm[AUDIO_BUFFER_SIZE] = { 0 }; // TODO: Dynamic allocation (uses more than 16KB of stack)
alBufferData(stream.buffers[i], stream.format, pcm, AUDIO_BUFFER_SIZE*sizeof(short), stream.sampleRate);
}
else if (stream.sampleSize == 32)
{
float pcm[AUDIO_BUFFER_SIZE] = { 0.0f }; // TODO: Dynamic allocation (uses more than 16KB of stack)
alBufferData(stream.buffers[i], stream.format, pcm, AUDIO_BUFFER_SIZE*sizeof(float), stream.sampleRate);
}
} }
free(pcm);
alSourceQueueBuffers(stream.source, MAX_STREAM_BUFFERS, stream.buffers); alSourceQueueBuffers(stream.source, MAX_STREAM_BUFFERS, stream.buffers);
TraceLog(INFO, "[AUD ID %i] Audio stream loaded successfully", stream.source); TraceLog(INFO, "[AUD ID %i] Audio stream loaded successfully (%i Hz, %i bit, %s)", stream.source, stream.sampleRate, stream.sampleSize, (stream.channels == 1) ? "Mono" : "Stereo");
return stream; return stream;
} }
@ -940,8 +921,8 @@ void CloseAudioStream(AudioStream stream)
} }
// Update audio stream buffers with data // Update audio stream buffers with data
// NOTE: Only one buffer per call // NOTE: Only updates one buffer per call
void UpdateAudioStream(AudioStream stream, void *data, int numSamples) void UpdateAudioStream(AudioStream stream, ">const void *data, int numSamples)
{ {
ALuint buffer = 0; ALuint buffer = 0;
alSourceUnqueueBuffers(stream.source, 1, &buffer); alSourceUnqueueBuffers(stream.source, 1, &buffer);
@ -949,10 +930,7 @@ void UpdateAudioStream(AudioStream stream, void *data, int numSamples)
// Check if any buffer was available for unqueue // Check if any buffer was available for unqueue
if (alGetError() != AL_INVALID_VALUE) if (alGetError() != AL_INVALID_VALUE)
{ {
if (stream.sampleSize == 8) alBufferData(buffer, stream.format, (unsigned char *)data, numSamples*sizeof(unsigned char), stream.sampleRate); alBufferData(buffer, stream.format, data, numSamples*stream.channels*stream.sampleSize/8, stream.sampleRate);
else if (stream.sampleSize == 16) alBufferData(buffer, stream.format, (short *)data, numSamples*sizeof(short), stream.sampleRate);
else if (stream.sampleSize == 32) alBufferData(buffer, stream.format, (float *)data, numSamples*sizeof(float), stream.sampleRate);
alSourceQueueBuffers(stream.source, 1, &buffer); alSourceQueueBuffers(stream.source, 1, &buffer);
} }
} }
@ -1007,7 +985,7 @@ static Wave LoadWAV(const char *fileName)
char chunkID[4]; char chunkID[4];
int chunkSize; int chunkSize;
char format[4]; char format[4];
} RiffHeader; } WavRiffHeader;
typedef struct { typedef struct {
char subChunkID[4]; char subChunkID[4];
@ -1018,16 +996,16 @@ static Wave LoadWAV(const char *fileName)
int byteRate; int byteRate;
short blockAlign; short blockAlign;
short bitsPerSample; short bitsPerSample;
} WaveFormat; } WavFormat;
typedef struct { typedef struct {
char subChunkID[4]; char subChunkID[4];
int subChunkSize; int subChunkSize;
} WaveData; } WavData;
RiffHeader riffHeader; WavRiffHeader wavRiffHeader;
WaveFormat waveFormat; WavFormat wavFormat;
WaveData waveData; WavData wavData;
Wave wave = { 0 }; Wave wave = { 0 };
FILE *wavFile; FILE *wavFile;
@ -1042,56 +1020,70 @@ static Wave LoadWAV(const char *fileName)
else else
{ {
// Read in the first chunk into the struct // Read in the first chunk into the struct
fread(&riffHeader, sizeof(RiffHeader), 1, wavFile); fread(&wavRiffHeader, sizeof(WavRiffHeader), 1, wavFile);
// Check for RIFF and WAVE tags // Check for RIFF and WAVE tags
if (strncmp(riffHeader.chunkID, "RIFF", 4) || if (strncmp(wavRiffHeader.chunkID, "RIFF", 4) ||
strncmp(riffHeader.format, "WAVE", 4)) strncmp(wavRiffHeader.format, "WAVE", 4))
{ {
TraceLog(WARNING, "[%s] Invalid RIFF or WAVE Header", fileName); TraceLog(WARNING, "[%s] Invalid RIFF or WAVE Header", fileName);
} }
else else
{ {
// Read in the 2nd chunk for the wave info // Read in the 2nd chunk for the wave info
fread(&waveFormat, sizeof(WaveFormat), 1, wavFile); fread(&wavFormat, sizeof(WavFormat), 1, wavFile);
// Check for fmt tag // Check for fmt tag
if ((waveFormat.subChunkID[0] != 'f') || (waveFormat.subChunkID[1] != 'm') || if ((wavFormat.subChunkID[0] != 'f') || (wavFormat.subChunkID[1] != 'm') ||
(waveFormat.subChunkID[2] != 't') || (waveFormat.subChunkID[3] != ' ')) (wavFormat.subChunkID[2] != 't') || (wavFormat.subChunkID[3] != ' '))
{ {
TraceLog(WARNING, "[%s] Invalid Wave format", fileName); TraceLog(WARNING, "[%s] Invalid Wave format", fileName);
} }
else else
{ {
// Check for extra parameters; // Check for extra parameters;
if (waveFormat.subChunkSize > 16) fseek(wavFile, sizeof(short), SEEK_CUR); if (wavFormat.subChunkSize > 16) fseek(wavFile, sizeof(short), SEEK_CUR);
// Read in the the last byte of data before the sound file // Read in the the last byte of data before the sound file
fread(&waveData, sizeof(WaveData), 1, wavFile); fread(&wavData, sizeof(WavData), 1, wavFile);
// Check for data tag // Check for data tag
if ((waveData.subChunkID[0] != 'd') || (waveData.subChunkID[1] != 'a') || if ((wavData.subChunkID[0] != 'd') || (wavData.subChunkID[1] != 'a') ||
(waveData.subChunkID[2] != 't') || (waveData.subChunkID[3] != 'a')) (wavData.subChunkID[2] != 't') || (wavData.subChunkID[3] != 'a'))
{ {
TraceLog(WARNING, "[%s] Invalid data header", fileName); TraceLog(WARNING, "[%s] Invalid data header", fileName);
} }
else else
{ {
// Allocate memory for data // Allocate memory for data
wave.data = (unsigned char *)malloc(sizeof(unsigned char)*waveData.subChunkSize); wave.data = (unsigned char *)malloc(sizeof(unsigned char)*wavData.subChunkSize);
// Read in the sound data into the soundData variable // Read in the sound data into the soundData variable
fread(wave.data, waveData.subChunkSize, 1, wavFile); fread(wave.data, wavData.subChunkSize, 1, wavFile);
// Store wave parameters // Store wave parameters
wave.sampleRate = waveFormat.sampleRate; wave.sampleRate = wavFormat.sampleRate;
wave.sampleSize = waveFormat.bitsPerSample; wave.sampleSize = wavFormat.bitsPerSample;
wave.channels = waveFormat.numChannels; wave.channels = wavFormat.numChannels;
// NOTE: Only support up to 16 bit sample sizes
if (wave.sampleSize > 16)
{
WaveFormat(&wave, wave.sampleRate, 16, wave.channels);
TraceLog(WARNING, "[%s] WAV sample size (%ibit) not supported, converted to 16bit", fileName, wave.sampleSize);
}
// NOTE: Only support up to 2 channels (mono, stereo)
if (wave.channels > 2)
{
WaveFormat(&wave, wave.sampleRate, wave.sampleSize, 2);
TraceLog(WARNING, "[%s] WAV channels number (%i) not supported, converted to 2 channels", fileName, wave.channels);
}
// NOTE: subChunkSize comes in bytes, we need to translate it to number of samples // NOTE: subChunkSize comes in bytes, we need to translate it to number of samples
wave.sampleCount = waveData.subChunkSize/(waveFormat.bitsPerSample/8); wave.sampleCount = p">(wavData.subChunkSize/(wave.sampleSize/8))/wave.channels;
TraceLog(INFO, "[%s] WAV file loaded successfully (SampleRate: %i, SampleSize: %i, Channels: %i)", fileName, wave.sampleRate, wave.sampleSize, wave.channels); TraceLog(INFO, "[%s] WAV file loaded successfully (%i Hz, %i bit, %s)", fileName, wave.sampleRate, wave.sampleSize, p">(wave.channels == 1) o">? pan class="sa">";Mono" : "Stereo");
} }
} }
} }
@ -1137,7 +1129,7 @@ static Wave LoadOGG(const char *fileName)
TraceLog(DEBUG, "[%s] Samples obtained: %i", fileName, samplesObtained); TraceLog(DEBUG, "[%s] Samples obtained: %i", fileName, samplesObtained);
TraceLog(INFO, "[%s] OGG file loaded successfully (SampleRate: %i, SampleSize: %i, Channels: %i)", fileName, wave.sampleRate, wave.sampleSize, wave.channels); TraceLog(INFO, "[%s] OGG file loaded successfully (%i Hz, %i bit, %s)", fileName, wave.sampleRate, wave.sampleSize, p">(wave.channels == 1) ? "Mono" : "Stereo");
stb_vorbis_close(oggFile); stb_vorbis_close(oggFile);
} }
@ -1156,9 +1148,20 @@ static Wave LoadFLAC(const char *fileName)
wave.data = drflac_open_and_decode_file_s32(fileName, &wave.channels, &wave.sampleRate, &totalSampleCount); wave.data = drflac_open_and_decode_file_s32(fileName, &wave.channels, &wave.sampleRate, &totalSampleCount);
wave.sampleCount = (int)totalSampleCount; wave.sampleCount = (int)totalSampleCount;
wave.sampleSize = 32; wave.sampleSize = 32; // 32 bit per sample (float)
// NOTE: By default, dr_flac returns 32bit float samples, needs to be converted to 16bit
WaveFormat(&wave, wave.sampleRate, 16, wave.channels);
// NOTE: Only support up to 2 channels (mono, stereo)
if (wave.channels > 2)
{
WaveFormat(&wave, wave.sampleRate, wave.sampleSize, 2);
TraceLog(WARNING, "[%s] FLAC channels number (%i) not supported, converted to 2 channels", fileName, wave.channels);
}
if (wave.data == NULL) TraceLog(WARNING, "[%s] FLAC data could not be loaded", fileName); if (wave.data == NULL) TraceLog(WARNING, "[%s] FLAC data could not be loaded", fileName);
else TraceLog(INFO, "[%s] FLAC file loaded successfully (%i Hz, %i bit, %s)", fileName, wave.sampleRate, wave.sampleSize, (wave.channels == 1) ? "Mono" : "Stereo");
return wave; return wave;
} }

+ 5
- 6
src/audio.h View File

@ -110,12 +110,11 @@ void InitAudioDevice(void); // Initialize au
void CloseAudioDevice(void); // Close the audio device and context void CloseAudioDevice(void); // Close the audio device and context
bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully
Wave LoadWave(const char *fileName); // Load wave data from file into RAM Wave LoadWave(const char *fileName); // Load wave data from file
Wave LoadWaveEx(float *data, int sampleCount, int sampleRate, int sampleSize, int channels); // Load wave data from float array data (32bit) Wave LoadWaveEx(void *data, int sampleCount, int sampleRate, int sampleSize, int channels); // Load wave data from raw array data
Sound LoadSound(const char *fileName); // Load sound to memory Sound LoadSound(const char *fileName); // Load sound from file
Sound LoadSoundFromWave(Wave wave); // Load sound to memory from wave data Sound LoadSoundFromWave(Wave wave); // Load sound from wave data
Sound LoadSoundFromRES(const char *rresName, int resId); // Load sound to memory from rRES file (raylib Resource) void UpdateSound(Sound sound, const void *data, int numSamples);// Update sound buffer with new data
void UpdateSound(Sound sound, const void *data, int numSamples); // Update sound buffer with new data
void UnloadWave(Wave wave); // Unload wave data void UnloadWave(Wave wave); // Unload wave data
void UnloadSound(Sound sound); // Unload sound void UnloadSound(Sound sound); // Unload sound
void PlaySound(Sound sound); // Play a sound void PlaySound(Sound sound); // Play a sound

Write Preview
||||||
​x
 
​
000:0
Loading…
Cancel
Save