Dima353/openal-soft
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove unnecessary wrappers around SDL_sound

Browse Source 
Also remove wrappers for the now-unsupported buffer_samples extension.
This commit is contained in:
Chris Robinson
2017-03-04 20:25:10 -08:00
parent c013068003
commit 87fd288359
10 changed files with 253 additions and 629 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+1 -5
View File
@@ -1464,12 +1464,8 @@ ENDIF()
IF(ALSOFT_EXAMPLES)
IF(SDL2_FOUND)
IF(SDL_SOUND_FOUND)
ADD_LIBRARY(ex-common STATIC examples/common/alhelpers.c
examples/common/sdl_sound.c)
ADD_LIBRARY(ex-common STATIC examples/common/alhelpers.c)
SET_PROPERTY(TARGET ex-common APPEND PROPERTY COMPILE_FLAGS ${EXTRA_CFLAGS})
SET_PROPERTY(TARGET ex-common APPEND PROPERTY
INCLUDE_DIRECTORIES ${SDL2_INCLUDE_DIR} ${SDL_SOUND_INCLUDE_DIR}
)
ADD_EXECUTABLE(alstream examples/alstream.c ${COMMON_OBJS})
TARGET_LINK_LIBRARIES(alstream ex-common ${SDL_SOUND_LIBRARIES} ${SDL2_LIBRARY}
examples/alhrtf.c
+48 -27
View File
@@ -28,12 +28,13 @@
#include <assert.h>
#include <math.h>
#include <SDL_sound.h>
#include "AL/al.h"
#include "AL/alc.h"
#include "AL/alext.h"
#include "common/alhelpers.h"
#include "common/sdl_sound.h"
#ifndef M_PI
@@ -44,47 +45,63 @@ static LPALCGETSTRINGISOFT alcGetStringiSOFT;
static LPALCRESETDEVICESOFT alcResetDeviceSOFT;
/* LoadBuffer loads the named audio file into an OpenAL buffer object, and
* returns the new buffer ID. */
* returns the new buffer ID.
*/
static ALuint LoadSound(const char *filename)
{
ALenum err, format, type, channels;
ALuint rate, buffer;
size_t datalen;
void *data;
FilePtr sound;
Sound_Sample *sample;
ALenum err, format;
ALuint buffer;
Uint32 slen;
/* Open the audio file */
sound = openAudioFile(filename, 1000);
if(!sound)
sample = Sound_NewSampleFromFile(filename, NULL, 65536);
if(!sample)
{
fprintf(stderr, "Could not open audio in %s\n", filename);
closeAudioFile(sound);
return 0;
}
/* Get the sound format, and figure out the OpenAL format */
if(getAudioInfo(sound, &rate, &channels, &type) != 0)
if(sample->actual.channels == 1)
{
fprintf(stderr, "Error getting audio info for %s\n", filename);
closeAudioFile(sound);
return 0;
if(sample->actual.format == AUDIO_U8)
format = AL_FORMAT_MONO8;
else if(sample->actual.format == AUDIO_S16SYS)
format = AL_FORMAT_MONO16;
else
{
fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
Sound_FreeSample(sample);
return 0;
}
}
format = GetFormat(channels, type, NULL);
if(format == AL_NONE)
else if(sample->actual.channels == 2)
{
fprintf(stderr, "Unsupported format (%s, %s) for %s\n",
ChannelsName(channels), TypeName(type), filename);
closeAudioFile(sound);
if(sample->actual.format == AUDIO_U8)
format = AL_FORMAT_STEREO8;
else if(sample->actual.format == AUDIO_S16SYS)
format = AL_FORMAT_STEREO16;
else
{
fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
Sound_FreeSample(sample);
return 0;
}
}
else
{
fprintf(stderr, "Unsupported channel count: %d\n", sample->actual.channels);
Sound_FreeSample(sample);
return 0;
}
/* Decode the whole audio stream to a buffer. */
data = decodeAudioStream(sound, &datalen);
if(!data)
slen = Sound_DecodeAll(sample);
if(!sample->buffer || slen == 0)
{
fprintf(stderr, "Failed to read audio from %s\n", filename);
closeAudioFile(sound);
Sound_FreeSample(sample);
return 0;
}
@@ -92,9 +109,8 @@ static ALuint LoadSound(const char *filename)
* close the file. */
buffer = 0;
alGenBuffers(1, &buffer);
alBufferData(buffer, format, data, datalen, rate);
free(data);
closeAudioFile(sound);
alBufferData(buffer, format, sample->buffer, slen, sample->actual.rate);
Sound_FreeSample(sample);
/* Check if an error occured, and clean up if so. */
err = alGetError();
@@ -219,10 +235,14 @@ int main(int argc, char **argv)
}
fflush(stdout);
/* Initialize SDL_sound. */
Sound_Init();
/* Load the sound into a buffer. */
buffer = LoadSound(soundname);
if(!buffer)
{
Sound_Quit();
CloseAL();
return 1;
}
@@ -263,10 +283,11 @@ int main(int argc, char **argv)
alGetSourcei(source, AL_SOURCE_STATE, &state);
} while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
/* All done. Delete resources, and close OpenAL. */
/* All done. Delete resources, and close down SDL_sound and OpenAL. */
alDeleteSources(1, &source);
alDeleteBuffers(1, &buffer);
Sound_Quit();
CloseAL();
return 0;
examples/allatency.c
+49 -38
View File
@@ -27,17 +27,15 @@
#include <stdio.h>
#include <assert.h>
#include <SDL_sound.h>
#include "AL/al.h"
#include "AL/alc.h"
#include "AL/alext.h"
#include "common/alhelpers.h"
#include "common/sdl_sound.h"
static LPALBUFFERSAMPLESSOFT alBufferSamplesSOFT = wrap_BufferSamples;
static LPALISBUFFERFORMATSUPPORTEDSOFT alIsBufferFormatSupportedSOFT;
static LPALSOURCEDSOFT alSourcedSOFT;
static LPALSOURCE3DSOFT alSource3dSOFT;
static LPALSOURCEDVSOFT alSourcedvSOFT;
@@ -52,47 +50,63 @@ static LPALGETSOURCE3I64SOFT alGetSource3i64SOFT;
static LPALGETSOURCEI64VSOFT alGetSourcei64vSOFT;
/* LoadBuffer loads the named audio file into an OpenAL buffer object, and
* returns the new buffer ID. */
* returns the new buffer ID.
*/
static ALuint LoadSound(const char *filename)
{
ALenum err, format, type, channels;
ALuint rate, buffer;
size_t datalen;
void *data;
FilePtr sound;
Sound_Sample *sample;
ALenum err, format;
ALuint buffer;
Uint32 slen;
/* Open the audio file */
sound = openAudioFile(filename, 1000);
if(!sound)
sample = Sound_NewSampleFromFile(filename, NULL, 65536);
if(!sample)
{
fprintf(stderr, "Could not open audio in %s\n", filename);
closeAudioFile(sound);
return 0;
}
/* Get the sound format, and figure out the OpenAL format */
if(getAudioInfo(sound, &rate, &channels, &type) != 0)
if(sample->actual.channels == 1)
{
fprintf(stderr, "Error getting audio info for %s\n", filename);
closeAudioFile(sound);
return 0;
if(sample->actual.format == AUDIO_U8)
format = AL_FORMAT_MONO8;
else if(sample->actual.format == AUDIO_S16SYS)
format = AL_FORMAT_MONO16;
else
{
fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
Sound_FreeSample(sample);
return 0;
}
}
format = GetFormat(channels, type, alIsBufferFormatSupportedSOFT);
if(format == AL_NONE)
else if(sample->actual.channels == 2)
{
fprintf(stderr, "Unsupported format (%s, %s) for %s\n",
ChannelsName(channels), TypeName(type), filename);
closeAudioFile(sound);
if(sample->actual.format == AUDIO_U8)
format = AL_FORMAT_STEREO8;
else if(sample->actual.format == AUDIO_S16SYS)
format = AL_FORMAT_STEREO16;
else
{
fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
Sound_FreeSample(sample);
return 0;
}
}
else
{
fprintf(stderr, "Unsupported channel count: %d\n", sample->actual.channels);
Sound_FreeSample(sample);
return 0;
}
/* Decode the whole audio stream to a buffer. */
data = decodeAudioStream(sound, &datalen);
if(!data)
slen = Sound_DecodeAll(sample);
if(!sample->buffer || slen == 0)
{
fprintf(stderr, "Failed to read audio from %s\n", filename);
closeAudioFile(sound);
Sound_FreeSample(sample);
return 0;
}
@@ -100,17 +114,15 @@ static ALuint LoadSound(const char *filename)
* close the file. */
buffer = 0;
alGenBuffers(1, &buffer);
alBufferSamplesSOFT(buffer, rate, format, BytesToFrames(datalen, channels, type),
channels, type, data);
free(data);
closeAudioFile(sound);
alBufferData(buffer, format, sample->buffer, slen, sample->actual.rate);
Sound_FreeSample(sample);
/* Check if an error occured, and clean up if so. */
err = alGetError();
if(err != AL_NO_ERROR)
{
fprintf(stderr, "OpenAL Error: %s\n", alGetString(err));
if(alIsBuffer(buffer))
if(buffer && alIsBuffer(buffer))
alDeleteBuffers(1, &buffer);
return 0;
}
@@ -158,18 +170,16 @@ int main(int argc, char **argv)
LOAD_PROC(alGetSourcei64SOFT);
LOAD_PROC(alGetSource3i64SOFT);
LOAD_PROC(alGetSourcei64vSOFT);
if(alIsExtensionPresent("AL_SOFT_buffer_samples"))
{
LOAD_PROC(alBufferSamplesSOFT);
LOAD_PROC(alIsBufferFormatSupportedSOFT);
}
#undef LOAD_PROC
/* Initialize SDL_sound. */
Sound_Init();
/* Load the sound into a buffer. */
buffer = LoadSound(argv[0]);
if(!buffer)
{
Sound_Quit();
CloseAL();
return 1;
}
@@ -195,10 +205,11 @@ int main(int argc, char **argv)
} while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
printf("\n");
/* All done. Delete resources, and close OpenAL. */
/* All done. Delete resources, and close down SDL_sound and OpenAL. */
alDeleteSources(1, &source);
alDeleteBuffers(1, &buffer);
Sound_Quit();
CloseAL();
return 0;
examples/alloopback.c
+30 -1
View File
@@ -61,6 +61,35 @@ void SDLCALL RenderSDLSamples(void *userdata, Uint8 *stream, int len)
}
static const char *ChannelsName(ALCenum chans)
{
switch(chans)
{
case ALC_MONO_SOFT: return "Mono";
case ALC_STEREO_SOFT: return "Stereo";
case ALC_QUAD_SOFT: return "Quadraphonic";
case ALC_5POINT1_SOFT: return "5.1 Surround";
case ALC_6POINT1_SOFT: return "6.1 Surround";
case ALC_7POINT1_SOFT: return "7.1 Surround";
}
return "Unknown Channels";
}
static const char *TypeName(ALCenum type)
{
switch(type)
{
case ALC_BYTE_SOFT: return "S8";
case ALC_UNSIGNED_BYTE_SOFT: return "U8";
case ALC_SHORT_SOFT: return "S16";
case ALC_UNSIGNED_SHORT_SOFT: return "U16";
case ALC_INT_SOFT: return "S32";
case ALC_UNSIGNED_INT_SOFT: return "U32";
case ALC_FLOAT_SOFT: return "Float32";
}
return "Unknown Type";
}
/* Creates a one second buffer containing a sine wave, and returns the new
* buffer ID. */
static ALuint CreateSineWave(void)
@@ -169,7 +198,7 @@ int main(int argc, char *argv[])
attrs[6] = 0; /* end of list */
playback.FrameSize = FramesToBytes(1, attrs[1], attrs[3]);
playback.FrameSize = obtained.channels * SDL_AUDIO_BITSIZE(obtained.format) / 8;
/* Initialize OpenAL loopback device, using our format attributes. */
playback.Device = alcLoopbackOpenDeviceSOFT(NULL);
examples/alreverb.c
+51 -38
View File
@@ -27,18 +27,16 @@
#include <stdio.h>
#include <assert.h>
#include <SDL_sound.h>
#include "AL/al.h"
#include "AL/alc.h"
#include "AL/alext.h"
#include "AL/efx-presets.h"
#include "common/alhelpers.h"
#include "common/sdl_sound.h"
static LPALBUFFERSAMPLESSOFT alBufferSamplesSOFT = wrap_BufferSamples;
static LPALISBUFFERFORMATSUPPORTEDSOFT alIsBufferFormatSupportedSOFT;
/* Effect object functions */
static LPALGENEFFECTS alGenEffects;
static LPALDELETEEFFECTS alDeleteEffects;
@@ -145,46 +143,63 @@ static ALuint LoadEffect(const EFXEAXREVERBPROPERTIES *reverb)
/* LoadBuffer loads the named audio file into an OpenAL buffer object, and
* returns the new buffer ID. */
* returns the new buffer ID.
*/
static ALuint LoadSound(const char *filename)
{
ALenum err, format, type, channels;
ALuint rate, buffer;
size_t datalen;
void *data;
FilePtr sound;
Sound_Sample *sample;
ALenum err, format;
ALuint buffer;
Uint32 slen;
/* Open the file and get the first stream from it */
sound = openAudioFile(filename, 1000);
if(!sound)
/* Open the audio file */
sample = Sound_NewSampleFromFile(filename, NULL, 65536);
if(!sample)
{
fprintf(stderr, "Could not open audio in %s\n", filename);
return 0;
}
/* Get the sound format, and figure out the OpenAL format */
if(getAudioInfo(sound, &rate, &channels, &type) != 0)
if(sample->actual.channels == 1)
{
fprintf(stderr, "Error getting audio info for %s\n", filename);
closeAudioFile(sound);
return 0;
if(sample->actual.format == AUDIO_U8)
format = AL_FORMAT_MONO8;
else if(sample->actual.format == AUDIO_S16SYS)
format = AL_FORMAT_MONO16;
else
{
fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
Sound_FreeSample(sample);
return 0;
}
}
format = GetFormat(channels, type, alIsBufferFormatSupportedSOFT);
if(format == AL_NONE)
else if(sample->actual.channels == 2)
{
fprintf(stderr, "Unsupported format (%s, %s) for %s\n",
ChannelsName(channels), TypeName(type), filename);
closeAudioFile(sound);
if(sample->actual.format == AUDIO_U8)
format = AL_FORMAT_STEREO8;
else if(sample->actual.format == AUDIO_S16SYS)
format = AL_FORMAT_STEREO16;
else
{
fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
Sound_FreeSample(sample);
return 0;
}
}
else
{
fprintf(stderr, "Unsupported channel count: %d\n", sample->actual.channels);
Sound_FreeSample(sample);
return 0;
}
/* Decode the whole audio stream to a buffer. */
data = decodeAudioStream(sound, &datalen);
if(!data)
slen = Sound_DecodeAll(sample);
if(!sample->buffer || slen == 0)
{
fprintf(stderr, "Failed to read audio from %s\n", filename);
closeAudioFile(sound);
Sound_FreeSample(sample);
return 0;
}
@@ -192,17 +207,15 @@ static ALuint LoadSound(const char *filename)
* close the file. */
buffer = 0;
alGenBuffers(1, &buffer);
alBufferSamplesSOFT(buffer, rate, format, BytesToFrames(datalen, channels, type),
channels, type, data);
free(data);
closeAudioFile(sound);
alBufferData(buffer, format, sample->buffer, slen, sample->actual.rate);
Sound_FreeSample(sample);
/* Check if an error occured, and clean up if so. */
err = alGetError();
if(err != AL_NO_ERROR)
{
fprintf(stderr, "OpenAL Error: %s\n", alGetString(err));
if(alIsBuffer(buffer))
if(buffer && alIsBuffer(buffer))
alDeleteBuffers(1, &buffer);
return 0;
}
@@ -261,19 +274,17 @@ int main(int argc, char **argv)
LOAD_PROC(alGetAuxiliaryEffectSlotiv);
LOAD_PROC(alGetAuxiliaryEffectSlotf);
LOAD_PROC(alGetAuxiliaryEffectSlotfv);
if(alIsExtensionPresent("AL_SOFT_buffer_samples"))
{
LOAD_PROC(alBufferSamplesSOFT);
LOAD_PROC(alIsBufferFormatSupportedSOFT);
}
#undef LOAD_PROC
/* Initialize SDL_sound. */
Sound_Init();
/* Load the sound into a buffer. */
buffer = LoadSound(argv[0]);
if(!buffer)
{
CloseAL();
Sound_Quit();
return 1;
}
@@ -282,6 +293,7 @@ int main(int argc, char **argv)
if(!effect)
{
alDeleteBuffers(1, &buffer);
Sound_Quit();
CloseAL();
return 1;
}
@@ -316,12 +328,13 @@ int main(int argc, char **argv)
alGetSourcei(source, AL_SOURCE_STATE, &state);
} while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
/* All done. Delete resources, and close OpenAL. */
/* All done. Delete resources, and close down SDL_sound and OpenAL. */
alDeleteSources(1, &source);
alDeleteAuxiliaryEffectSlots(1, &slot);
alDeleteEffects(1, &effect);
alDeleteBuffers(1, &buffer);
Sound_Quit();
CloseAL();
return 0;
examples/alstream.c
+65 -55
View File
@@ -30,16 +30,13 @@
#include <signal.h>
#include <assert.h>
#include <SDL_sound.h>
#include "AL/al.h"
#include "AL/alc.h"
#include "AL/alext.h"
#include "common/alhelpers.h"
#include "common/sdl_sound.h"
static LPALBUFFERSAMPLESSOFT alBufferSamplesSOFT = wrap_BufferSamples;
static LPALISBUFFERFORMATSUPPORTEDSOFT alIsBufferFormatSupportedSOFT;
/* Define the number of buffers and buffer size (in milliseconds) to use. 4
@@ -54,13 +51,11 @@ typedef struct StreamPlayer {
ALuint source;
/* Handle for the audio file */
FilePtr file;
Sound_Sample *sample;
/* The format of the output stream */
ALenum format;
ALenum channels;
ALenum type;
ALuint rate;
ALsizei srate;
} StreamPlayer;
static StreamPlayer *NewPlayer(void);
@@ -77,11 +72,9 @@ static StreamPlayer *NewPlayer(void)
{
StreamPlayer *player;
player = malloc(sizeof(*player));
player = calloc(1, sizeof(*player));
assert(player != NULL);
memset(player, 0, sizeof(*player));
/* Generate the buffers and source */
alGenBuffers(NUM_BUFFERS, player->buffers);
assert(alGetError() == AL_NO_ERROR && "Could not create buffers");
@@ -119,37 +112,63 @@ static void DeletePlayer(StreamPlayer *player)
* it will be closed first. */
static int OpenPlayerFile(StreamPlayer *player, const char *filename)
{
Uint32 frame_size;
ClosePlayerFile(player);
/* Open the file and get the first stream from it */
player->file = openAudioFile(filename, BUFFER_TIME_MS);
if(!player->file)
player->sample = Sound_NewSampleFromFile(filename, NULL, 0);
if(!player->sample)
{
fprintf(stderr, "Could not open audio in %s\n", filename);
goto error;
}
/* Get the stream format, and figure out the OpenAL format */
if(getAudioInfo(player->file, &player->rate, &player->channels, &player->type) != 0)
if(player->sample->actual.channels == 1)
{
fprintf(stderr, "Error getting audio info for %s\n", filename);
if(player->sample->actual.format == AUDIO_U8)
player->format = AL_FORMAT_MONO8;
else if(player->sample->actual.format == AUDIO_S16SYS)
player->format = AL_FORMAT_MONO16;
else
{
fprintf(stderr, "Unsupported sample format: 0x%04x\n", player->sample->actual.format);
goto error;
}
}
else if(player->sample->actual.channels == 2)
{
if(player->sample->actual.format == AUDIO_U8)
player->format = AL_FORMAT_STEREO8;
else if(player->sample->actual.format == AUDIO_S16SYS)
player->format = AL_FORMAT_STEREO16;
else
{
fprintf(stderr, "Unsupported sample format: 0x%04x\n", player->sample->actual.format);
goto error;
}
}
else
{
fprintf(stderr, "Unsupported channel count: %d\n", player->sample->actual.channels);
goto error;
}
player->srate = player->sample->actual.rate;
player->format = GetFormat(player->channels, player->type, alIsBufferFormatSupportedSOFT);
if(player->format == 0)
{
fprintf(stderr, "Unsupported format (%s, %s) for %s\n",
ChannelsName(player->channels), TypeName(player->type),
filename);
goto error;
}
frame_size = player->sample->actual.channels *
SDL_AUDIO_BITSIZE(player->sample->actual.format) / 8;
/* Set the buffer size, given the desired millisecond length. */
Sound_SetBufferSize(player->sample, (Uint32)((Uint64)player->srate*BUFFER_TIME_MS/1000) *
frame_size);
return 1;
error:
closeAudioFile(player->file);
player->file = NULL;
if(player->sample)
Sound_FreeSample(player->sample);
player->sample = NULL;
return 0;
}
@@ -157,8 +176,9 @@ error:
/* Closes the audio file stream */
static void ClosePlayerFile(StreamPlayer *player)
{
closeAudioFile(player->file);
player->file = NULL;
if(player->sample)
Sound_FreeSample(player->sample);
player->sample = NULL;
}
@@ -174,16 +194,12 @@ static int StartPlayer(StreamPlayer *player)
/* Fill the buffer queue */
for(i = 0;i < NUM_BUFFERS;i++)
{
uint8_t *data;
size_t got;
/* Get some data to give it to the buffer */
data = getAudioData(player->file, &got);
if(!data) break;
Uint32 slen = Sound_Decode(player->sample);
if(slen == 0) break;
alBufferSamplesSOFT(player->buffers[i], player->rate, player->format,
BytesToFrames(got, player->channels, player->type),
player->channels, player->type, data);
alBufferData(player->buffers[i], player->format,
player->sample->buffer, slen, player->srate);
}
if(alGetError() != AL_NO_ERROR)
{
@@ -220,20 +236,21 @@ static int UpdatePlayer(StreamPlayer *player)
while(processed > 0)
{
ALuint bufid;
uint8_t *data;
size_t got;
Uint32 slen;
alSourceUnqueueBuffers(player->source, 1, &bufid);
processed--;
if((player->sample->flags&(SOUND_SAMPLEFLAG_EOF|SOUND_SAMPLEFLAG_ERROR)))
continue;
/* Read the next chunk of data, refill the buffer, and queue it
* back on the source */
data = getAudioData(player->file, &got);
if(data != NULL)
slen = Sound_Decode(player->sample);
if(slen > 0)
{
alBufferSamplesSOFT(bufid, player->rate, player->format,
BytesToFrames(got, player->channels, player->type),
player->channels, player->type, data);
alBufferData(bufid, player->format, player->sample->buffer, slen,
player->srate);
alSourceQueueBuffers(player->source, 1, &bufid);
}
if(alGetError() != AL_NO_ERROR)
@@ -281,14 +298,7 @@ int main(int argc, char **argv)
if(InitAL(&argv, &argc) != 0)
return 1;
if(alIsExtensionPresent("AL_SOFT_buffer_samples"))
{
printf("AL_SOFT_buffer_samples supported!\n");
alBufferSamplesSOFT = alGetProcAddress("alBufferSamplesSOFT");
alIsBufferFormatSupportedSOFT = alGetProcAddress("alIsBufferFormatSupportedSOFT");
}
else
printf("AL_SOFT_buffer_samples not supported\n");
Sound_Init();
player = NewPlayer();
@@ -307,9 +317,8 @@ int main(int argc, char **argv)
else
namepart = argv[i];
printf("Playing: %s (%s, %s, %dhz)\n", namepart,
TypeName(player->type), ChannelsName(player->channels),
player->rate);
printf("Playing: %s (%s, %dhz)\n", namepart, FormatName(player->format),
player->srate);
fflush(stdout);
if(!StartPlayer(player))
@@ -326,10 +335,11 @@ int main(int argc, char **argv)
}
printf("Done.\n");
/* All files done. Delete the player, and close OpenAL */
/* All files done. Delete the player, and close down SDL_sound and OpenAL */
DeletePlayer(player);
player = NULL;
Sound_Quit();
CloseAL();
return 0;
examples/common/alhelpers.c
+7 -236
View File
@@ -103,243 +103,14 @@ void CloseAL(void)
}
/* GetFormat retrieves a compatible buffer format given the channel config and
* sample type. If an alIsBufferFormatSupportedSOFT-compatible function is
* provided, it will be called to find the closest-matching format from
* AL_SOFT_buffer_samples. Returns AL_NONE (0) if no supported format can be
* found. */
ALenum GetFormat(ALenum channels, ALenum type, LPALISBUFFERFORMATSUPPORTEDSOFT palIsBufferFormatSupportedSOFT)
const char *FormatName(ALenum format)
{
ALenum format = AL_NONE;
/* If using AL_SOFT_buffer_samples, try looking through its formats */
if(palIsBufferFormatSupportedSOFT)
switch(format)
{
/* AL_SOFT_buffer_samples is more lenient with matching formats. The
* specified sample type does not need to match the returned format,
* but it is nice to try to get something close. */
if(type == AL_UNSIGNED_BYTE_SOFT || type == AL_BYTE_SOFT)
{
if(channels == AL_MONO_SOFT) format = AL_MONO8_SOFT;
else if(channels == AL_STEREO_SOFT) format = AL_STEREO8_SOFT;
else if(channels == AL_QUAD_SOFT) format = AL_QUAD8_SOFT;
else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_8_SOFT;
else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_8_SOFT;
else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_8_SOFT;
}
else if(type == AL_UNSIGNED_SHORT_SOFT || type == AL_SHORT_SOFT)
{
if(channels == AL_MONO_SOFT) format = AL_MONO16_SOFT;
else if(channels == AL_STEREO_SOFT) format = AL_STEREO16_SOFT;
else if(channels == AL_QUAD_SOFT) format = AL_QUAD16_SOFT;
else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_16_SOFT;
else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_16_SOFT;
else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_16_SOFT;
}
else if(type == AL_UNSIGNED_BYTE3_SOFT || type == AL_BYTE3_SOFT ||
type == AL_UNSIGNED_INT_SOFT || type == AL_INT_SOFT ||
type == AL_FLOAT_SOFT || type == AL_DOUBLE_SOFT)
{
if(channels == AL_MONO_SOFT) format = AL_MONO32F_SOFT;
else if(channels == AL_STEREO_SOFT) format = AL_STEREO32F_SOFT;
else if(channels == AL_QUAD_SOFT) format = AL_QUAD32F_SOFT;
else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_32F_SOFT;
else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_32F_SOFT;
else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_32F_SOFT;
}
if(format != AL_NONE && !palIsBufferFormatSupportedSOFT(format))
format = AL_NONE;
/* A matching format was not found or supported. Try 32-bit float. */
if(format == AL_NONE)
{
if(channels == AL_MONO_SOFT) format = AL_MONO32F_SOFT;
else if(channels == AL_STEREO_SOFT) format = AL_STEREO32F_SOFT;
else if(channels == AL_QUAD_SOFT) format = AL_QUAD32F_SOFT;
else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_32F_SOFT;
else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_32F_SOFT;
else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_32F_SOFT;
if(format != AL_NONE && !palIsBufferFormatSupportedSOFT(format))
format = AL_NONE;
}
/* 32-bit float not supported. Try 16-bit int. */
if(format == AL_NONE)
{
if(channels == AL_MONO_SOFT) format = AL_MONO16_SOFT;
else if(channels == AL_STEREO_SOFT) format = AL_STEREO16_SOFT;
else if(channels == AL_QUAD_SOFT) format = AL_QUAD16_SOFT;
else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_16_SOFT;
else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_16_SOFT;
else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_16_SOFT;
if(format != AL_NONE && !palIsBufferFormatSupportedSOFT(format))
format = AL_NONE;
}
/* 16-bit int not supported. Try 8-bit int. */
if(format == AL_NONE)
{
if(channels == AL_MONO_SOFT) format = AL_MONO8_SOFT;
else if(channels == AL_STEREO_SOFT) format = AL_STEREO8_SOFT;
else if(channels == AL_QUAD_SOFT) format = AL_QUAD8_SOFT;
else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_8_SOFT;
else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_8_SOFT;
else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_8_SOFT;
if(format != AL_NONE && !palIsBufferFormatSupportedSOFT(format))
format = AL_NONE;
}
return format;
case AL_FORMAT_MONO8: return "Mono, U8";
case AL_FORMAT_MONO16: return "Mono, S16";
case AL_FORMAT_STEREO8: return "Stereo, U8";
case AL_FORMAT_STEREO16: return "Stereo, S16";
}
/* We use the AL_EXT_MCFORMATS extension to provide output of Quad, 5.1,
* and 7.1 channel configs, AL_EXT_FLOAT32 for 32-bit float samples, and
* AL_EXT_DOUBLE for 64-bit float samples. */
if(type == AL_UNSIGNED_BYTE_SOFT)
{
if(channels == AL_MONO_SOFT)
format = AL_FORMAT_MONO8;
else if(channels == AL_STEREO_SOFT)
format = AL_FORMAT_STEREO8;
else if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
{
if(channels == AL_QUAD_SOFT)
format = alGetEnumValue("AL_FORMAT_QUAD8");
else if(channels == AL_5POINT1_SOFT)
format = alGetEnumValue("AL_FORMAT_51CHN8");
else if(channels == AL_6POINT1_SOFT)
format = alGetEnumValue("AL_FORMAT_61CHN8");
else if(channels == AL_7POINT1_SOFT)
format = alGetEnumValue("AL_FORMAT_71CHN8");
}
}
else if(type == AL_SHORT_SOFT)
{
if(channels == AL_MONO_SOFT)
format = AL_FORMAT_MONO16;
else if(channels == AL_STEREO_SOFT)
format = AL_FORMAT_STEREO16;
else if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
{
if(channels == AL_QUAD_SOFT)
format = alGetEnumValue("AL_FORMAT_QUAD16");
else if(channels == AL_5POINT1_SOFT)
format = alGetEnumValue("AL_FORMAT_51CHN16");
else if(channels == AL_6POINT1_SOFT)
format = alGetEnumValue("AL_FORMAT_61CHN16");
else if(channels == AL_7POINT1_SOFT)
format = alGetEnumValue("AL_FORMAT_71CHN16");
}
}
else if(type == AL_FLOAT_SOFT && alIsExtensionPresent("AL_EXT_FLOAT32"))
{
if(channels == AL_MONO_SOFT)
format = alGetEnumValue("AL_FORMAT_MONO_FLOAT32");
else if(channels == AL_STEREO_SOFT)
format = alGetEnumValue("AL_FORMAT_STEREO_FLOAT32");
else if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
{
if(channels == AL_QUAD_SOFT)
format = alGetEnumValue("AL_FORMAT_QUAD32");
else if(channels == AL_5POINT1_SOFT)
format = alGetEnumValue("AL_FORMAT_51CHN32");
else if(channels == AL_6POINT1_SOFT)
format = alGetEnumValue("AL_FORMAT_61CHN32");
else if(channels == AL_7POINT1_SOFT)
format = alGetEnumValue("AL_FORMAT_71CHN32");
}
}
else if(type == AL_DOUBLE_SOFT && alIsExtensionPresent("AL_EXT_DOUBLE"))
{
if(channels == AL_MONO_SOFT)
format = alGetEnumValue("AL_FORMAT_MONO_DOUBLE");
else if(channels == AL_STEREO_SOFT)
format = alGetEnumValue("AL_FORMAT_STEREO_DOUBLE");
}
/* NOTE: It seems OSX returns -1 from alGetEnumValue for unknown enums, as
* opposed to 0. Correct it. */
if(format == -1)
format = 0;
return format;
}
void AL_APIENTRY wrap_BufferSamples(ALuint buffer, ALuint samplerate,
ALenum internalformat, ALsizei samples,
ALenum channels, ALenum type,
const ALvoid *data)
{
alBufferData(buffer, internalformat, data,
FramesToBytes(samples, channels, type),
samplerate);
}
const char *ChannelsName(ALenum chans)
{
switch(chans)
{
case AL_MONO_SOFT: return "Mono";
case AL_STEREO_SOFT: return "Stereo";
case AL_REAR_SOFT: return "Rear";
case AL_QUAD_SOFT: return "Quadraphonic";
case AL_5POINT1_SOFT: return "5.1 Surround";
case AL_6POINT1_SOFT: return "6.1 Surround";
case AL_7POINT1_SOFT: return "7.1 Surround";
}
return "Unknown Channels";
}
const char *TypeName(ALenum type)
{
switch(type)
{
case AL_BYTE_SOFT: return "S8";
case AL_UNSIGNED_BYTE_SOFT: return "U8";
case AL_SHORT_SOFT: return "S16";
case AL_UNSIGNED_SHORT_SOFT: return "U16";
case AL_INT_SOFT: return "S32";
case AL_UNSIGNED_INT_SOFT: return "U32";
case AL_FLOAT_SOFT: return "Float32";
case AL_DOUBLE_SOFT: return "Float64";
}
return "Unknown Type";
}
ALsizei FramesToBytes(ALsizei size, ALenum channels, ALenum type)
{
switch(channels)
{
case AL_MONO_SOFT: size *= 1; break;
case AL_STEREO_SOFT: size *= 2; break;
case AL_REAR_SOFT: size *= 2; break;
case AL_QUAD_SOFT: size *= 4; break;
case AL_5POINT1_SOFT: size *= 6; break;
case AL_6POINT1_SOFT: size *= 7; break;
case AL_7POINT1_SOFT: size *= 8; break;
}
switch(type)
{
case AL_BYTE_SOFT: size *= sizeof(ALbyte); break;
case AL_UNSIGNED_BYTE_SOFT: size *= sizeof(ALubyte); break;
case AL_SHORT_SOFT: size *= sizeof(ALshort); break;
case AL_UNSIGNED_SHORT_SOFT: size *= sizeof(ALushort); break;
case AL_INT_SOFT: size *= sizeof(ALint); break;
case AL_UNSIGNED_INT_SOFT: size *= sizeof(ALuint); break;
case AL_FLOAT_SOFT: size *= sizeof(ALfloat); break;
case AL_DOUBLE_SOFT: size *= sizeof(ALdouble); break;
}
return size;
}
ALsizei BytesToFrames(ALsizei size, ALenum channels, ALenum type)
{
return size / FramesToBytes(1, channels, type);
return "Unknown Format";
}
examples/common/alhelpers.h
+2 -22
View File
@@ -11,28 +11,8 @@
extern "C" {
#endif /* __cplusplus */
/* Some helper functions to get the name from the channel and type enums. */
const char *ChannelsName(ALenum chans);
const char *TypeName(ALenum type);
/* Helpers to convert frame counts and byte lengths. */
ALsizei FramesToBytes(ALsizei size, ALenum channels, ALenum type);
ALsizei BytesToFrames(ALsizei size, ALenum channels, ALenum type);
/* Retrieves a compatible buffer format given the channel configuration and
* sample type. If an alIsBufferFormatSupportedSOFT-compatible function is
* provided, it will be called to find the closest-matching format from
* AL_SOFT_buffer_samples. Returns AL_NONE (0) if no supported format can be
* found. */
ALenum GetFormat(ALenum channels, ALenum type, LPALISBUFFERFORMATSUPPORTEDSOFT palIsBufferFormatSupportedSOFT);
/* Loads samples into a buffer using the standard alBufferData call, but with a
* LPALBUFFERSAMPLESSOFT-compatible prototype. Assumes internalformat is valid
* for alBufferData, and that channels and type match it. */
void AL_APIENTRY wrap_BufferSamples(ALuint buffer, ALuint samplerate,
ALenum internalformat, ALsizei samples,
ALenum channels, ALenum type,
const ALvoid *data);
/* Some helper functions to get the name from the format enums. */
const char *FormatName(ALenum type);
/* Easy device init/deinit functions. InitAL returns 0 on success. */
int InitAL(char ***argv, int *argc);
examples/common/sdl_sound.c
-164
View File
@@ -1,164 +0,0 @@
/*
* SDL_sound Decoder Helpers
*
* Copyright (c) 2013 by Chris Robinson <chris.kcat@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/* This file contains routines for helping to decode audio using SDL_sound.
* There's very little OpenAL-specific code here.
*/
#include "sdl_sound.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <assert.h>
#include <SDL_sound.h>
#include "AL/al.h"
#include "AL/alc.h"
#include "AL/alext.h"
#include "alhelpers.h"
static int done_init = 0;
FilePtr openAudioFile(const char *fname, size_t buftime_ms)
{
FilePtr file;
ALuint rate;
Uint32 bufsize;
ALenum chans, type;
/* We need to make sure SDL_sound is initialized. */
if(!done_init)
{
Sound_Init();
done_init = 1;
}
file = Sound_NewSampleFromFile(fname, NULL, 0);
if(!file)
{
fprintf(stderr, "Failed to open %s: %s\n", fname, Sound_GetError());
return NULL;
}
if(getAudioInfo(file, &rate, &chans, &type) != 0)
{
Sound_FreeSample(file);
return NULL;
}
bufsize = FramesToBytes((ALsizei)(buftime_ms/1000.0*rate), chans, type);
if(Sound_SetBufferSize(file, bufsize) == 0)
{
fprintf(stderr, "Failed to set buffer size to %u bytes: %s\n", bufsize, Sound_GetError());
Sound_FreeSample(file);
return NULL;
}
return file;
}
void closeAudioFile(FilePtr file)
{
if(file)
Sound_FreeSample(file);
}
int getAudioInfo(FilePtr file, ALuint *rate, ALenum *channels, ALenum *type)
{
if(file->actual.channels == 1)
*channels = AL_MONO_SOFT;
else if(file->actual.channels == 2)
*channels = AL_STEREO_SOFT;
else
{
fprintf(stderr, "Unsupported channel count: %d\n", file->actual.channels);
return 1;
}
if(file->actual.format == AUDIO_U8)
*type = AL_UNSIGNED_BYTE_SOFT;
else if(file->actual.format == AUDIO_S8)
*type = AL_BYTE_SOFT;
else if(file->actual.format == AUDIO_U16LSB || file->actual.format == AUDIO_U16MSB)
*type = AL_UNSIGNED_SHORT_SOFT;
else if(file->actual.format == AUDIO_S16LSB || file->actual.format == AUDIO_S16MSB)
*type = AL_SHORT_SOFT;
else
{
fprintf(stderr, "Unsupported sample format: 0x%04x\n", file->actual.format);
return 1;
}
*rate = file->actual.rate;
return 0;
}
uint8_t *getAudioData(FilePtr file, size_t *length)
{
*length = Sound_Decode(file);
if(*length == 0)
return NULL;
if((file->actual.format == AUDIO_U16LSB && AUDIO_U16LSB != AUDIO_U16SYS) ||
(file->actual.format == AUDIO_U16MSB && AUDIO_U16MSB != AUDIO_U16SYS) ||
(file->actual.format == AUDIO_S16LSB && AUDIO_S16LSB != AUDIO_S16SYS) ||
(file->actual.format == AUDIO_S16MSB && AUDIO_S16MSB != AUDIO_S16SYS))
{
/* Swap bytes if the decoded endianness doesn't match the system. */
char *buffer = file->buffer;
size_t i;
for(i = 0;i < *length;i+=2)
{
char b = buffer[i];
buffer[i] = buffer[i+1];
buffer[i+1] = b;
}
}
return file->buffer;
}
void *decodeAudioStream(FilePtr file, size_t *length)
{
Uint32 got;
char *mem;
got = Sound_DecodeAll(file);
if(got == 0)
{
*length = 0;
return NULL;
}
mem = malloc(got);
memcpy(mem, file->buffer, got);
*length = got;
return mem;
}
examples/common/sdl_sound.h
-43
View File
@@ -1,43 +0,0 @@
#ifndef EXAMPLES_SDL_SOUND_H
#define EXAMPLES_SDL_SOUND_H
#include "AL/al.h"
#include <SDL_sound.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/* Opaque handles to files and streams. Apps don't need to concern themselves
* with the internals */
typedef Sound_Sample *FilePtr;
/* Opens a file with SDL_sound, and specifies the size of the sample buffer in
* milliseconds. */
FilePtr openAudioFile(const char *fname, size_t buftime_ms);
/* Closes/frees an opened file */
void closeAudioFile(FilePtr file);
/* Returns information about the given audio stream. Returns 0 on success. */
int getAudioInfo(FilePtr file, ALuint *rate, ALenum *channels, ALenum *type);
/* Returns a pointer to the next available chunk of decoded audio. The size (in
* bytes) of the returned data buffer is stored in 'length', and the returned
* pointer is only valid until the next call to getAudioData. */
uint8_t *getAudioData(FilePtr file, size_t *length);
/* Decodes all remaining data from the stream and returns a buffer containing
* the audio data, with the size stored in 'length'. The returned pointer must
* be freed with a call to free(). Note that since this decodes the whole
* stream, using it on lengthy streams (eg, music) will use a lot of memory.
* Such streams are better handled using getAudioData to keep smaller chunks in
* memory at any given time. */
void *decodeAudioStream(FilePtr, size_t *length);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* EXAMPLES_SDL_SOUND_H */