# HG changeset patch # User koda # Date 1255787476 0 # Node ID 51e5df1c846257146c1bf711dba48806462f6908 # Parent a1e0306b9cd13af3a50a0554f27f4d06301902b2 restore openalbridge to r2489 diff -r a1e0306b9cd1 -r 51e5df1c8462 openalbridge/CMakeLists.txt --- a/openalbridge/CMakeLists.txt Sat Oct 17 13:47:58 2009 +0000 +++ b/openalbridge/CMakeLists.txt Sat Oct 17 13:51:16 2009 +0000 @@ -8,7 +8,7 @@ #list of source files for libraries set(openal_src - openalbridge.c loaders.c wrappers.c errlib.c + openalbridge.c loaders.c wrappers.c errlib.c ) #build a static library for human systems @@ -18,7 +18,7 @@ if(WIN32) #workaround for visualstudio (wants headers in the source list) set(openal_src - openalbridge.h loaders.h wrappers.h common.h oggvorbis.h errlib.h ${openal_src} + openalbridge.h loaders.h wrappers.h globals.h oggvorbis.h errlib.h ${openal_src} ) #deps for the shared library link_libraries(${VORBISFILE_LIBRARY}) diff -r a1e0306b9cd1 -r 51e5df1c8462 openalbridge/common.h --- a/openalbridge/common.h Sat Oct 17 13:47:58 2009 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,145 +0,0 @@ -/* - * OpenAL Bridge - a simple portable library for OpenAL interface - * Copyright (c) 2009 Vittorio Giovara , - * Mario Liebisch - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation; version 2 of the License - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA - */ - - -#ifndef _COMMON_H -#define _COMMON_H - -#include -#include -#include -#include -#include -#include -#include "al.h" -#include "errlib.h" - -#ifndef _WIN32 -#include -#include -#else -#include -#define syslog(x,y) fprintf(stderr,y) -#define LOG_INFO 6 -#define LOG_ERR 3 -#endif - - -/* magics */ -#define OGG_FILE_FORMAT 0x4F676753 -#define WAV_FILE_FORMAT 0x52494646 -#define WAV_HEADER_SUBCHUNK2ID 0x64617461 - -/* max allocations */ -#define MAX_SOUNDS 1024 -#define MAX_SOURCES 16 - -/* check compiler requirements */ /*FIXME*/ -#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) -#warning __BIG_ENDIAN__ or __LITTLE_ENDIAN__ not found, going to set __LITTLE_ENDIAN__ as default -#define __LITTLE_ENDIAN__ 1 -//#error Do not know the endianess of this architecture -#endif - -/* use byteswap macros from the host system, hopefully optimized ones ;-) - * or define our own version, simple, stupid, straight-forward... */ -#ifdef HAVE_BYTESWAP_H -#include -#else -#define bswap_16(x) ((((x) & 0xFF00) >> 8) | (((x) & 0x00FF) << 8)) -#define bswap_32(x) ((((x) & 0xFF000000) >> 24) | (((x) & 0x00FF0000) >> 8) | \ - (((x) & 0x0000FF00) << 8) | (((x) & 0x000000FF) << 24) ) -#endif /* HAVE_BYTESWAP_H */ - -/* swap numbers accordingly to architecture automatically */ -#ifdef __LITTLE_ENDIAN__ -#define ENDIAN_LITTLE_32(x) x -#define ENDIAN_BIG_32(x) bswap_32(x) -#define ENDIAN_LITTLE_16(x) x -#define ENDIAN_BIG_16(x) bswap_16(x) -#elif __BIG_ENDIAN__ -#define ENDIAN_LITTLE_32(x) bswap_32(x) -#define ENDIAN_BIG_32(x) x -#define ENDIAN_LITTLE_16(x) bswap_16(x) -#define ENDIAN_BIG_16(x) x -#endif - -/** 1.0 02/03/10 - Defines cross-platform sleep, usleep, etc. [Wu Yongwei] **/ -#ifndef _SLEEP_H -#define _SLEEP_H -#ifdef _WIN32 -# if defined(_NEED_SLEEP_ONLY) && (defined(_MSC_VER) || defined(__MINGW32__)) -# include -# define sleep(t) _sleep((t) * 1000) -# else -# define WIN32_LEAN_AND_MEAN -# include -# define sleep(t) Sleep((t) * 1000) -# endif -# ifndef _NEED_SLEEP_ONLY -# define msleep(t) Sleep(t) -# define usleep(t) Sleep((t) / 1000) -# endif -#else -# include -# ifndef _NEED_SLEEP_ONLY -# define msleep(t) usleep((t) * 1000) -# endif -#endif -#endif /* _SLEEP_H */ - -#pragma pack(1) -typedef struct _WAV_header_t { - uint32_t ChunkID; - uint32_t ChunkSize; - uint32_t Format; - uint32_t Subchunk1ID; - uint32_t Subchunk1Size; - uint16_t AudioFormat; - uint16_t NumChannels; - uint32_t SampleRate; - uint32_t ByteRate; - uint16_t BlockAlign; - uint16_t BitsPerSample; - uint32_t Subchunk2ID; - uint32_t Subchunk2Size; -} WAV_header_t; -#pragma pack() - -#pragma pack(1) -typedef struct _SSound_t { - int isLoaded; - int sourceIndex; - char *filename; - ALuint Buffer; -} SSound_t; -#pragma pack() - -/*data type for passing data between threads*/ -#pragma pack(1) -typedef struct _fade_t { - uint32_t index; - uint16_t quantity; -} fade_t; -#pragma pack() - -#define FADE_IN 0 -#define FADE_OUT 1 - -#endif /* _COMMON_H*/ diff -r a1e0306b9cd1 -r 51e5df1c8462 openalbridge/errlib.c --- a/openalbridge/errlib.c Sat Oct 17 13:47:58 2009 +0000 +++ b/openalbridge/errlib.c Sat Oct 17 13:51:16 2009 +0000 @@ -10,79 +10,87 @@ #include "errlib.h" + #define MAXLINE 4095 -int daemon_proc = 0; /* set to 0 if stdout/stderr available, else set to 1 */ - -static void err_doit (int errnoflag, int level, const char *fmt, va_list ap) -{ - int errno_save = errno, n; - char buf[MAXLINE+1]; +#ifdef __CPLUSPLUS +extern "C" { +#endif + + int daemon_proc = 0; /* set to 0 if stdout/stderr available, else set to 1 */ - vsnprintf (buf, MAXLINE, fmt, ap); - n = strlen(buf); - if (errnoflag) - snprintf (buf+n, MAXLINE-n, ": %s", strerror(errno_save)); - strcat (buf, "\n"); + static void err_doit (int errnoflag, int level, const char *fmt, va_list ap) + { + int errno_save = errno, n; + char buf[MAXLINE+1]; + + vsnprintf (buf, MAXLINE, fmt, ap); + n = strlen(buf); + if (errnoflag) + snprintf (buf+n, MAXLINE-n, ": %s", strerror(errno_save)); + strcat (buf, "\n"); + + if (daemon_proc) + syslog (level, buf); + else { + fflush (stdout); + fprintf (stderr, buf); + fflush (stderr); + } + + return; + } - if (daemon_proc) - syslog (level, buf); - else { - fflush (stdout); - fprintf (stderr, buf); - fflush (stderr); + void err_ret (const char *fmt, ...) + { + va_list ap; + + va_start (ap, fmt); + err_doit (1, LOG_INFO, fmt, ap); + va_end (ap); + return; } - return; -} - -void err_ret (const char *fmt, ...) -{ - va_list ap; + void err_sys (const char *fmt, ...) + { + va_list ap; + + va_start (ap, fmt); + err_doit (1, LOG_ERR, fmt, ap); + va_end (ap); + exit (1); + } - va_start (ap, fmt); - err_doit (1, LOG_INFO, fmt, ap); - va_end (ap); - return; -} - -void err_sys (const char *fmt, ...) -{ - va_list ap; - - va_start (ap, fmt); - err_doit (1, LOG_ERR, fmt, ap); - va_end (ap); - exit (1); -} - -void err_msg (const char *fmt, ...) -{ - va_list ap; + void err_msg (const char *fmt, ...) + { + va_list ap; + + va_start (ap, fmt); + err_doit (0, LOG_INFO, fmt, ap); + va_end (ap); + return; + } - va_start (ap, fmt); - err_doit (0, LOG_INFO, fmt, ap); - va_end (ap); - return; -} - -void err_quit (const char *fmt, ...) -{ - va_list ap; + void err_quit (const char *fmt, ...) + { + va_list ap; + + va_start (ap, fmt); + err_doit (0, LOG_ERR, fmt, ap); + va_end (ap); + exit (1); + } - va_start (ap, fmt); - err_doit (0, LOG_ERR, fmt, ap); - va_end (ap); - exit (1); + void err_dump (const char *fmt, ...) + { + va_list ap; + + va_start (ap, fmt); + err_doit (1, LOG_ERR, fmt, ap); + va_end (ap); + abort(); + } + +#ifdef __CPLUSPLUS } - -void err_dump (const char *fmt, ...) -{ - va_list ap; - - va_start (ap, fmt); - err_doit (1, LOG_ERR, fmt, ap); - va_end (ap); - abort(); -} - +#endif diff -r a1e0306b9cd1 -r 51e5df1c8462 openalbridge/errlib.h --- a/openalbridge/errlib.h Sat Oct 17 13:47:58 2009 +0000 +++ b/openalbridge/errlib.h Sat Oct 17 13:51:16 2009 +0000 @@ -11,15 +11,23 @@ #ifndef _ERRLIB_H #define _ERRLIB_H -#include "common.h" +#include "globals.h" + +#ifdef __CPLUSPLUS +extern "C" { +#endif -extern int daemon_proc; + extern int daemon_proc; -void err_msg (const char *fmt, ...); -void err_quit (const char *fmt, ...); -void err_ret (const char *fmt, ...); -void err_sys (const char *fmt, ...); -void err_dump (const char *fmt, ...); + void err_msg (const char *fmt, ...); + void err_quit (const char *fmt, ...); + void err_ret (const char *fmt, ...); + void err_sys (const char *fmt, ...); + void err_dump (const char *fmt, ...); + +#ifdef __CPLUSPLUS +} +#endif #endif /*_ERRLIB_H*/ diff -r a1e0306b9cd1 -r 51e5df1c8462 openalbridge/globals.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/openalbridge/globals.h Sat Oct 17 13:51:16 2009 +0000 @@ -0,0 +1,154 @@ +/* + * OpenAL Bridge - a simple portable library for OpenAL interface + * Copyright (c) 2009 Vittorio Giovara + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; version 2 of the License + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ + +#ifndef _OALB_GLOBALS_H +#define _OALB_GLOBALS_H + +#include +#include +#include +#include +#include +#include + +#ifndef _WIN32 +#include +#include +#else +#include +#define syslog(x,y) fprintf(stderr,y) +#define LOG_INFO 6 +#define LOG_ERR 3 +#endif + +#include "al.h" +#include "errlib.h" + + +/*control debug verbosity*/ +#ifdef TRACE +#ifndef DEBUG +#define DEBUG +#endif +#endif + +/** 1.0 02/03/10 - Defines cross-platform sleep, usleep, etc. [Wu Yongwei] **/ +#ifndef _SLEEP_H +#define _SLEEP_H +#ifdef _WIN32 +# if defined(_NEED_SLEEP_ONLY) && (defined(_MSC_VER) || defined(__MINGW32__)) +# include +# define sleep(t) _sleep((t) * 1000) +# else +# define WIN32_LEAN_AND_MEAN +# include +# define sleep(t) Sleep((t) * 1000) +# endif +# ifndef _NEED_SLEEP_ONLY +# define msleep(t) Sleep(t) +# define usleep(t) Sleep((t) / 1000) +# endif +#else +# include +# ifndef _NEED_SLEEP_ONLY +# define msleep(t) usleep((t) * 1000) +# endif +#endif +#endif /* _SLEEP_H */ + + +/* check compiler requirements */ /*FIXME*/ +#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) +#warning __BIG_ENDIAN__ or __LITTLE_ENDIAN__ not found, going to set __LITTLE_ENDIAN__ as default +#define __LITTLE_ENDIAN__ 1 +//#error Do not know the endianess of this architecture +#endif + +/* use byteswap macros from the host system, hopefully optimized ones ;-) + * or define our own version, simple, stupid, straight-forward... */ +#ifdef HAVE_BYTESWAP_H +#include +#else +#define bswap_16(x) ((((x) & 0xFF00) >> 8) | (((x) & 0x00FF) << 8)) +#define bswap_32(x) ((((x) & 0xFF000000) >> 24) | (((x) & 0x00FF0000) >> 8) | \ +(((x) & 0x0000FF00) << 8) | (((x) & 0x000000FF) << 24) ) +#endif /* HAVE_BYTESWAP_H */ + +/* swap numbers accordingly to architecture automatically */ +#ifdef __LITTLE_ENDIAN__ +#define ENDIAN_LITTLE_32(x) x +#define ENDIAN_BIG_32(x) bswap_32(x) +#define ENDIAN_LITTLE_16(x) x +#define ENDIAN_BIG_16(x) bswap_16(x) +#elif __BIG_ENDIAN__ +#define ENDIAN_LITTLE_32(x) bswap_32(x) +#define ENDIAN_BIG_32(x) x +#define ENDIAN_LITTLE_16(x) bswap_16(x) +#define ENDIAN_BIG_16(x) x +#endif + + +#ifdef __CPLUSPLUS +extern "C" { +#endif + + /*data type for WAV header*/ +#pragma pack(1) + typedef struct _WAV_header_t { + uint32_t ChunkID; + uint32_t ChunkSize; + uint32_t Format; + uint32_t Subchunk1ID; + uint32_t Subchunk1Size; + uint16_t AudioFormat; + uint16_t NumChannels; + uint32_t SampleRate; + uint32_t ByteRate; + uint16_t BlockAlign; + uint16_t BitsPerSample; + uint32_t Subchunk2ID; + uint32_t Subchunk2Size; + } WAV_header_t; +#pragma pack() + + /*data type for passing data between threads*/ +#pragma pack(1) + typedef struct _fade_t { + uint32_t index; + uint16_t quantity; + } fade_t; +#pragma pack() + + + /*file format defines*/ +#define OGG_FILE_FORMAT 0x4F676753 +#define WAV_FILE_FORMAT 0x52494646 +#define WAV_HEADER_SUBCHUNK2ID 0x64617461 + + + /*other defines*/ +#define FADE_IN 0 +#define FADE_OUT 1 + + char *prog; + +#ifdef __CPLUSPLUS +} +#endif + +#endif /*_OALB_GLOBALS_H*/ diff -r a1e0306b9cd1 -r 51e5df1c8462 openalbridge/loaders.c --- a/openalbridge/loaders.c Sat Oct 17 13:47:58 2009 +0000 +++ b/openalbridge/loaders.c Sat Oct 17 13:51:16 2009 +0000 @@ -1,7 +1,6 @@ /* * OpenAL Bridge - a simple portable library for OpenAL interface - * Copyright (c) 2009 Vittorio Giovara , - * Mario Liebisch + * Copyright (c) 2009 Vittorio Giovara * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by @@ -20,223 +19,229 @@ #include "loaders.h" -int load_wavpcm (const char *filename, ALenum *format, char ** data, ALsizei *bitsize, ALsizei *freq) { - WAV_header_t WAVHeader; - FILE *wavfile; - int32_t t; - uint32_t n = 0; - uint8_t sub0, sub1, sub2, sub3; - - wavfile = Fopen(filename, "rb"); - - fread(&WAVHeader.ChunkID, sizeof(uint32_t), 1, wavfile); /*RIFF*/ - fread(&WAVHeader.ChunkSize, sizeof(uint32_t), 1, wavfile); - fread(&WAVHeader.Format, sizeof(uint32_t), 1, wavfile); /*WAVE*/ - -#ifdef DEBUG - fprintf(stderr, "ChunkID: %X\n", ENDIAN_BIG_32(WAVHeader.ChunkID)); - fprintf(stderr, "ChunkSize: %d\n", ENDIAN_LITTLE_32(WAVHeader.ChunkSize)); - fprintf(stderr, "Format: %X\n", ENDIAN_BIG_32(WAVHeader.Format)); -#endif - - fread(&WAVHeader.Subchunk1ID, sizeof(uint32_t), 1, wavfile); /*fmt */ - fread(&WAVHeader.Subchunk1Size, sizeof(uint32_t), 1, wavfile); - fread(&WAVHeader.AudioFormat, sizeof(uint16_t), 1, wavfile); - fread(&WAVHeader.NumChannels, sizeof(uint16_t), 1, wavfile); - fread(&WAVHeader.SampleRate, sizeof(uint32_t), 1, wavfile); - fread(&WAVHeader.ByteRate, sizeof(uint32_t), 1, wavfile); - fread(&WAVHeader.BlockAlign, sizeof(uint16_t), 1, wavfile); - fread(&WAVHeader.BitsPerSample, sizeof(uint16_t), 1, wavfile); - -#ifdef DEBUG - fprintf(stderr, "Subchunk1ID: %X\n", ENDIAN_BIG_32(WAVHeader.Subchunk1ID)); - fprintf(stderr, "Subchunk1Size: %d\n", ENDIAN_LITTLE_32(WAVHeader.Subchunk1Size)); - fprintf(stderr, "AudioFormat: %d\n", ENDIAN_LITTLE_16(WAVHeader.AudioFormat)); - fprintf(stderr, "NumChannels: %d\n", ENDIAN_LITTLE_16(WAVHeader.NumChannels)); - fprintf(stderr, "SampleRate: %d\n", ENDIAN_LITTLE_32(WAVHeader.SampleRate)); - fprintf(stderr, "ByteRate: %d\n", ENDIAN_LITTLE_32(WAVHeader.ByteRate)); - fprintf(stderr, "BlockAlign: %d\n", ENDIAN_LITTLE_16(WAVHeader.BlockAlign)); - fprintf(stderr, "BitsPerSample: %d\n", ENDIAN_LITTLE_16(WAVHeader.BitsPerSample)); -#endif +#ifdef __CPLUSPLUS +extern "C" { +#endif - /*remove useless header chunks by looking for the WAV_HEADER_SUBCHUNK2ID integer */ - do { - t = fread(&sub0, sizeof(uint8_t), 1, wavfile); - if(sub0 == 0x64) { - t = fread(&sub1, sizeof(uint8_t), 1, wavfile); - if(sub1 == 0x61) { - t = fread(&sub2, sizeof(uint8_t), 1, wavfile); - if(sub2 == 0x74) { - t = fread(&sub3, sizeof(uint8_t), 1, wavfile); - if(sub3 == 0x61) { - WAVHeader.Subchunk2ID = WAV_HEADER_SUBCHUNK2ID; - break; - } - } - } - } + int load_wavpcm (const char *filename, ALenum *format, char ** data, ALsizei *bitsize, ALsizei *freq) { + WAV_header_t WAVHeader; + FILE *wavfile; + int32_t t; + uint32_t n = 0; + uint8_t sub0, sub1, sub2, sub3; + + wavfile = Fopen(filename, "rb"); + + fread(&WAVHeader.ChunkID, sizeof(uint32_t), 1, wavfile); /*RIFF*/ + fread(&WAVHeader.ChunkSize, sizeof(uint32_t), 1, wavfile); + fread(&WAVHeader.Format, sizeof(uint32_t), 1, wavfile); /*WAVE*/ - if (t <= 0) { - /*eof*/ - errno = EILSEQ; - err_ret("(%s) ERROR - wrong WAV header", prog); - return AL_FALSE; - } - } while (1); - - fread(&WAVHeader.Subchunk2Size, sizeof(uint32_t), 1, wavfile); - +#ifdef DEBUG + fprintf(stderr, "ChunkID: %X\n", ENDIAN_BIG_32(WAVHeader.ChunkID)); + fprintf(stderr, "ChunkSize: %d\n", ENDIAN_LITTLE_32(WAVHeader.ChunkSize)); + fprintf(stderr, "Format: %X\n", ENDIAN_BIG_32(WAVHeader.Format)); +#endif + + fread(&WAVHeader.Subchunk1ID, sizeof(uint32_t), 1, wavfile); /*fmt */ + fread(&WAVHeader.Subchunk1Size, sizeof(uint32_t), 1, wavfile); + fread(&WAVHeader.AudioFormat, sizeof(uint16_t), 1, wavfile); + fread(&WAVHeader.NumChannels, sizeof(uint16_t), 1, wavfile); + fread(&WAVHeader.SampleRate, sizeof(uint32_t), 1, wavfile); + fread(&WAVHeader.ByteRate, sizeof(uint32_t), 1, wavfile); + fread(&WAVHeader.BlockAlign, sizeof(uint16_t), 1, wavfile); + fread(&WAVHeader.BitsPerSample, sizeof(uint16_t), 1, wavfile); + #ifdef DEBUG - fprintf(stderr, "Subchunk2ID: %X\n", ENDIAN_LITTLE_32(WAVHeader.Subchunk2ID)); - fprintf(stderr, "Subchunk2Size: %d\n", ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size)); + fprintf(stderr, "Subchunk1ID: %X\n", ENDIAN_BIG_32(WAVHeader.Subchunk1ID)); + fprintf(stderr, "Subchunk1Size: %d\n", ENDIAN_LITTLE_32(WAVHeader.Subchunk1Size)); + fprintf(stderr, "AudioFormat: %d\n", ENDIAN_LITTLE_16(WAVHeader.AudioFormat)); + fprintf(stderr, "NumChannels: %d\n", ENDIAN_LITTLE_16(WAVHeader.NumChannels)); + fprintf(stderr, "SampleRate: %d\n", ENDIAN_LITTLE_32(WAVHeader.SampleRate)); + fprintf(stderr, "ByteRate: %d\n", ENDIAN_LITTLE_32(WAVHeader.ByteRate)); + fprintf(stderr, "BlockAlign: %d\n", ENDIAN_LITTLE_16(WAVHeader.BlockAlign)); + fprintf(stderr, "BitsPerSample: %d\n", ENDIAN_LITTLE_16(WAVHeader.BitsPerSample)); #endif - - *data = (char*) Malloc (sizeof(char) * ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size)); - - /*read the actual sound data*/ - do { - n += fread(&((*data)[n]), sizeof(uint8_t), 4, wavfile); - } while (n < ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size)); - - fclose(wavfile); - -#ifdef DEBUG - err_msg("(%s) INFO - WAV data loaded", prog); -#endif - - /*set parameters for OpenAL*/ - /*Valid formats are AL_FORMAT_MONO8, AL_FORMAT_MONO16, AL_FORMAT_STEREO8, and AL_FORMAT_STEREO16*/ - if (ENDIAN_LITTLE_16(WAVHeader.NumChannels) == 1) { - if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 8) - *format = AL_FORMAT_MONO8; - else { - if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 16) - *format = AL_FORMAT_MONO16; - else { + + /*remove useless header chunks by looking for the WAV_HEADER_SUBCHUNK2ID integer */ + do { + t = fread(&sub0, sizeof(uint8_t), 1, wavfile); + if(sub0 == 0x64) { + t = fread(&sub1, sizeof(uint8_t), 1, wavfile); + if(sub1 == 0x61) { + t = fread(&sub2, sizeof(uint8_t), 1, wavfile); + if(sub2 == 0x74) { + t = fread(&sub3, sizeof(uint8_t), 1, wavfile); + if(sub3 == 0x61) { + WAVHeader.Subchunk2ID = WAV_HEADER_SUBCHUNK2ID; + break; + } + } + } + } + + if (t <= 0) { + /*eof*/ errno = EILSEQ; - err_ret("(%s) ERROR - wrong WAV header [bitsample value]", prog); + err_ret("(%s) ERROR - wrong WAV header", prog); return AL_FALSE; } - } - } else { - if (ENDIAN_LITTLE_16(WAVHeader.NumChannels) == 2) { + } while (1); + + fread(&WAVHeader.Subchunk2Size, sizeof(uint32_t), 1, wavfile); + +#ifdef DEBUG + fprintf(stderr, "Subchunk2ID: %X\n", ENDIAN_LITTLE_32(WAVHeader.Subchunk2ID)); + fprintf(stderr, "Subchunk2Size: %d\n", ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size)); +#endif + + *data = (char*) Malloc (sizeof(char) * ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size)); + + /*read the actual sound data*/ + do { + n += fread(&((*data)[n]), sizeof(uint8_t), 4, wavfile); + } while (n < ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size)); + + fclose(wavfile); + +#ifdef DEBUG + err_msg("(%s) INFO - WAV data loaded", prog); +#endif + + /*set parameters for OpenAL*/ + /*Valid formats are AL_FORMAT_MONO8, AL_FORMAT_MONO16, AL_FORMAT_STEREO8, and AL_FORMAT_STEREO16*/ + if (ENDIAN_LITTLE_16(WAVHeader.NumChannels) == 1) { if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 8) - *format = AL_FORMAT_STEREO8; + *format = AL_FORMAT_MONO8; else { if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 16) - *format = AL_FORMAT_STEREO16; + *format = AL_FORMAT_MONO16; else { errno = EILSEQ; err_ret("(%s) ERROR - wrong WAV header [bitsample value]", prog); return AL_FALSE; - } - } + } + } } else { - errno = EILSEQ; - err_ret("(%s) ERROR - wrong WAV header [format value]", prog); - return AL_FALSE; + if (ENDIAN_LITTLE_16(WAVHeader.NumChannels) == 2) { + if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 8) + *format = AL_FORMAT_STEREO8; + else { + if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 16) + *format = AL_FORMAT_STEREO16; + else { + errno = EILSEQ; + err_ret("(%s) ERROR - wrong WAV header [bitsample value]", prog); + return AL_FALSE; + } + } + } else { + errno = EILSEQ; + err_ret("(%s) ERROR - wrong WAV header [format value]", prog); + return AL_FALSE; + } } + + *bitsize = ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size); + *freq = ENDIAN_LITTLE_32(WAVHeader.SampleRate); + return AL_TRUE; } - *bitsize = ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size); - *freq = ENDIAN_LITTLE_32(WAVHeader.SampleRate); - return AL_TRUE; -} - - -int load_oggvorbis (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq) { - /*implementation inspired from http://www.devmaster.net/forums/showthread.php?t=1153 */ - /*stream handle*/ - OggVorbis_File oggStream; - /*some formatting data*/ - vorbis_info *vorbisInfo; - /*length of the decoded data*/ - int64_t pcm_length; - /*other vars*/ - int section, result, size, endianness; + int load_oggvorbis (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq) { + /*implementation inspired from http://www.devmaster.net/forums/showthread.php?t=1153 */ + + /*stream handle*/ + OggVorbis_File oggStream; + /*some formatting data*/ + vorbis_info *vorbisInfo; + /*length of the decoded data*/ + int64_t pcm_length; + /*other vars*/ + int section, result, size, endianness; #ifdef DEBUG - int i; - /*other less useful data*/ - vorbis_comment *vorbisComment; + int i; + /*other less useful data*/ + vorbis_comment *vorbisComment; #endif - - result = ov_fopen((char*) filename, &oggStream); - if (result < 0) { - errno = EINVAL; - err_ret("(%s) ERROR - ov_fopen() failed with %X", prog, result); - ov_clear(&oggStream); - return AL_FALSE; - } - - /*load OGG header and determine the decoded data size*/ - vorbisInfo = ov_info(&oggStream, -1); - pcm_length = ov_pcm_total(&oggStream, -1) << vorbisInfo->channels; - -#ifdef DEBUG - vorbisComment = ov_comment(&oggStream, -1); - fprintf(stderr, "Version: %d\n", vorbisInfo->version); - fprintf(stderr, "Channels: %d\n", vorbisInfo->channels); - fprintf(stderr, "Rate (Hz): %ld\n", vorbisInfo->rate); - fprintf(stderr, "Bitrate Upper: %ld\n", vorbisInfo->bitrate_upper); - fprintf(stderr, "Bitrate Nominal: %ld\n", vorbisInfo->bitrate_nominal); - fprintf(stderr, "Bitrate Lower: %ld\n", vorbisInfo->bitrate_lower); - fprintf(stderr, "Bitrate Windows: %ld\n", vorbisInfo->bitrate_window); - fprintf(stderr, "Vendor: %s\n", vorbisComment->vendor); - fprintf(stderr, "PCM data size: %lld\n", pcm_length); - fprintf(stderr, "# comment: %d\n", vorbisComment->comments); - for (i = 0; i < vorbisComment->comments; i++) - fprintf(stderr, "\tComment %d: %s\n", i, vorbisComment->user_comments[i]); -#endif - - /*allocates enough room for the decoded data*/ - *data = (char*) Malloc (sizeof(char) * pcm_length); - - /*there *should* not be ogg at 8 bits*/ - if (vorbisInfo->channels == 1) - *format = AL_FORMAT_MONO16; - else { - if (vorbisInfo->channels == 2) - *format = AL_FORMAT_STEREO16; - else { - errno = EILSEQ; - err_ret("(%s) ERROR - wrong OGG header [channel %d]", prog, vorbisInfo->channels); + + result = ov_fopen((char*) filename, &oggStream); + if (result < 0) { + errno = EINVAL; + err_ret("(%s) ERROR - ov_fopen() failed with %X", prog, result); ov_clear(&oggStream); return AL_FALSE; } - } - - size = 0; -#ifdef __LITTLE_ENDIAN__ - endianness = 0; -#elif __BIG_ENDIAN__ - endianness = 1; + + /*load OGG header and determine the decoded data size*/ + vorbisInfo = ov_info(&oggStream, -1); + pcm_length = ov_pcm_total(&oggStream, -1) << vorbisInfo->channels; + +#ifdef DEBUG + vorbisComment = ov_comment(&oggStream, -1); + fprintf(stderr, "Version: %d\n", vorbisInfo->version); + fprintf(stderr, "Channels: %d\n", vorbisInfo->channels); + fprintf(stderr, "Rate (Hz): %ld\n", vorbisInfo->rate); + fprintf(stderr, "Bitrate Upper: %ld\n", vorbisInfo->bitrate_upper); + fprintf(stderr, "Bitrate Nominal: %ld\n", vorbisInfo->bitrate_nominal); + fprintf(stderr, "Bitrate Lower: %ld\n", vorbisInfo->bitrate_lower); + fprintf(stderr, "Bitrate Windows: %ld\n", vorbisInfo->bitrate_window); + fprintf(stderr, "Vendor: %s\n", vorbisComment->vendor); + fprintf(stderr, "PCM data size: %lld\n", pcm_length); + fprintf(stderr, "# comment: %d\n", vorbisComment->comments); + for (i = 0; i < vorbisComment->comments; i++) + fprintf(stderr, "\tComment %d: %s\n", i, vorbisComment->user_comments[i]); #endif - while (size < pcm_length) { - /*ov_read decodes the ogg stream and storse the pcm in data*/ - result = ov_read (&oggStream, *data + size, pcm_length - size, endianness, 2, 1, §ion); - if (result > 0) { - size += result; - } else { - if (result == 0) - break; - else { + + /*allocates enough room for the decoded data*/ + *data = (char*) Malloc (sizeof(char) * pcm_length); + + /*there *should* not be ogg at 8 bits*/ + if (vorbisInfo->channels == 1) + *format = AL_FORMAT_MONO16; + else { + if (vorbisInfo->channels == 2) + *format = AL_FORMAT_STEREO16; + else { errno = EILSEQ; - err_ret("(%s) ERROR - End of file from OGG stream", prog); + err_ret("(%s) ERROR - wrong OGG header [channel %d]", prog, vorbisInfo->channels); ov_clear(&oggStream); return AL_FALSE; } } + + size = 0; +#ifdef __LITTLE_ENDIAN__ + endianness = 0; +#elif __BIG_ENDIAN__ + endianness = 1; +#endif + while (size < pcm_length) { + /*ov_read decodes the ogg stream and storse the pcm in data*/ + result = ov_read (&oggStream, *data + size, pcm_length - size, endianness, 2, 1, §ion); + if (result > 0) { + size += result; + } else { + if (result == 0) + break; + else { + errno = EILSEQ; + err_ret("(%s) ERROR - End of file from OGG stream", prog); + ov_clear(&oggStream); + return AL_FALSE; + } + } + } + + /*set the last fields*/ + *bitsize = size; + *freq = vorbisInfo->rate; + + /*cleaning time*/ + ov_clear(&oggStream); + + return AL_TRUE; } - /*set the last fields*/ - *bitsize = size; - *freq = vorbisInfo->rate; - - /*cleaning time*/ - ov_clear(&oggStream); - - return AL_TRUE; +#ifdef __CPLUSPLUS } - - +#endif diff -r a1e0306b9cd1 -r 51e5df1c8462 openalbridge/loaders.h --- a/openalbridge/loaders.h Sat Oct 17 13:47:58 2009 +0000 +++ b/openalbridge/loaders.h Sat Oct 17 13:51:16 2009 +0000 @@ -1,7 +1,6 @@ /* * OpenAL Bridge - a simple portable library for OpenAL interface - * Copyright (c) 2009 Vittorio Giovara , - * Mario Liebisch + * Copyright (c) 2009 Vittorio Giovara * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by @@ -20,13 +19,20 @@ #ifndef _OALB_LOADERS_H #define _OALB_LOADERS_H -#include "common.h" +#include "globals.h" #include "wrappers.h" #include "oggvorbis.h" -extern char *prog; -int load_wavpcm (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq); -int load_oggvorbis (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq); +#ifdef __CPLUSPLUS +extern "C" { +#endif + + int load_wavpcm (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq); + int load_oggvorbis (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq); + +#ifdef __CPLUSPLUS +} +#endif #endif /*_OALB_LOADERS_H*/ diff -r a1e0306b9cd1 -r 51e5df1c8462 openalbridge/openalbridge.c --- a/openalbridge/openalbridge.c Sat Oct 17 13:47:58 2009 +0000 +++ b/openalbridge/openalbridge.c Sat Oct 17 13:51:16 2009 +0000 @@ -18,566 +18,481 @@ #include "openalbridge.h" -char oalbReady = 0; -int iNumSounds = 0; -char *prog; -/*Sources are points emitting sound*/ -ALuint Sources[MAX_SOURCES]; -/*structure that holds information about sounds*/ -SSound_t *theSounds; - -ALfloat SourcePos[] = { 0.0, 0.0, 0.0 }; /*Position of the source sound*/ -ALfloat SourceVel[] = { 0.0, 0.0, 0.0 }; /*Velocity of the source sound*/ - -/** - * const char oalb_init (const char* programname, const char usehardware) - * - * ARGUMENTS - * programname [const char*]: name of the program invoking OpenAL - * usehardware [const char] : flag to enable audio hardware acceleration - * DESCRIPTION - * - * RETURN - * 1 success - * 2 error - */ - -const char oalb_init (const char* programname, const char usehardware) { - /*Initialize an OpenAL contex and allocate memory space for data and buffers*/ - ALCcontext *context; - ALCdevice *device; - const ALCchar *default_device; - int i; +#ifdef __CPLUSPLUS +extern "C" { +#endif + + /*Sources are points emitting sound*/ + ALuint *Sources; + /*Buffers hold sound data*/ + ALuint *Buffers; + /*index for Sources and Buffers*/ + ALuint globalindex, globalsize, increment; + + ALboolean openalReady = AL_FALSE; - prog = (char *) programname; - - /*Position of the listener*/ - ALfloat ListenerPos[] = {0.0, 0.0, 0.0}; - /*Velocity of the listener*/ - ALfloat ListenerVel[] = {0.0, 0.0, 0.0}; - /*Orientation of the listener. (first 3 elements are "at", second 3 are "up")*/ - ALfloat ListenerOri[] = {0.0, 0.0, -1.0, 0.0, 1.0, 0.0}; - - if (oalbReady == 1) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL already initialized", prog); - return AL_FALSE; + ALboolean openal_close (void) { + /*Stop all sounds, deallocate all memory and close OpenAL */ + ALCcontext *context; + ALCdevice *device; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + alSourceStopv (globalsize, Sources); + alDeleteSources (globalsize, Sources); + alDeleteBuffers (globalsize, Buffers); + + free(Sources); + free(Buffers); + + context = alcGetCurrentContext(); + device = alcGetContextsDevice(context); + + alcMakeContextCurrent(NULL); + alcDestroyContext(context); + alcCloseDevice(device); + + openalReady = AL_FALSE; + + return AL_TRUE; } -#ifdef _WIN32 - /* Hardware acceleration is broken on some windows card*/ - if (usehardware != 0) - device = alcOpenDevice(NULL); - else - { - device = alcOpenDevice("Generic Software"); - if(!device) - { - err_msg("(%s) WARN - Failed to open software device", prog); - device = alcOpenDevice(NULL); - } - } -#else - /*always hardware for UNIX systems*/ - device = alcOpenDevice(NULL); -#endif - - if (device == NULL) { - errno = ENODEV; - err_ret("(%s) WARN - Failed to open sound device", prog); - return AL_FALSE; - } - err_msg("(%s) INFO - Output device: %s", prog, alcGetString(device, ALC_DEVICE_SPECIFIER)); - - context = alcCreateContext(device, NULL); - alcMakeContextCurrent(context); - alcProcessContext(context); - - if (AlGetError("(%s) ERROR - Failed to create a new contex") != AL_TRUE) - return AL_FALSE; - - /*set the listener gain, position (on xyz axes), velocity (one value for each axe) and orientation*/ - alListenerf (AL_GAIN, 1.0f ); - alListenerfv(AL_POSITION, ListenerPos); - alListenerfv(AL_VELOCITY, ListenerVel); - alListenerfv(AL_ORIENTATION, ListenerOri); - - if (AlGetError("(%s) WARN - Failed to set Listener properties") != AL_TRUE) - return AL_FALSE; - - theSounds = (SSound_t*) Malloc(sizeof(SSound_t)*MAX_SOUNDS); - for (i = 0; i < MAX_SOUNDS; i++) { - theSounds->isLoaded = 0; - theSounds->sourceIndex = -1; - } - - alGenSources(MAX_SOURCES, Sources); - oalbReady = 1; - - alGetError(); /* clear any AL errors beforehand */ - return AL_TRUE; -} - - -/** - * void oalb_close (void) - * - * ARGUMENTS - * - - * DESCRIPTION - * Stop all sounds, deallocate all memory and close OpenAL - * RETURN - * - - */ - -void oalb_close (void) { - /*Stop all sounds, deallocate all memory and close OpenAL */ - ALCcontext *context; - ALCdevice *device; - int i; - - if (oalbReady == 0) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; + ALboolean openal_ready(void) { + return openalReady; } - alSourceStopv (MAX_SOURCES, Sources); - alDeleteSources (MAX_SOURCES, Sources); - - for (i = 0; i < MAX_SOUNDS; i++) { - free(theSounds[i].filename); - alDeleteBuffers (1, &theSounds[i].Buffer); + ALboolean openal_init(char* programname, ALboolean usehardware, uint32_t memorysize) { + /*Initialize an OpenAL contex and allocate memory space for data and buffers*/ + ALCcontext *context; + ALCdevice *device; + const ALCchar *default_device; + + prog = programname; + + /*Position of the listener*/ + ALfloat ListenerPos[] = { 0.0, 0.0, 0.0 }; + /*Velocity of the listener*/ + ALfloat ListenerVel[] = { 0.0, 0.0, 0.0 }; + /*Orientation of the listener. (first 3 elements are "at", second 3 are "up")*/ + ALfloat ListenerOri[] = { 0.0, 0.0, -1.0, 0.0, 1.0, 0.0 }; + + if (openalReady == AL_TRUE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL already initialized", prog); + return AL_FALSE; + } + + if (usehardware == AL_TRUE) + device = alcOpenDevice(NULL); + else + device = alcOpenDevice("Generic Software"); + + if (device == NULL) { + errno = ENODEV; + err_ret("(%s) WARN - Failed to open sound device", prog); + return AL_FALSE; + } + err_msg("(%s) INFO - Output device: %s", prog, alcGetString(device, ALC_DEVICE_SPECIFIER)); + + context = alcCreateContext(device, NULL); + alcMakeContextCurrent(context); + alcProcessContext(context); + + if (AlGetError("(%s) WARN - Failed to create a new contex") != AL_TRUE) + return AL_FALSE; + + /*allocate memory space for buffers and sources*/ + if (memorysize == 0) + globalsize = 50; + else + globalsize = memorysize; + increment = globalsize; + + Buffers = (ALuint*) Malloc(sizeof(ALuint)*globalsize); + Sources = (ALuint*) Malloc(sizeof(ALuint)*globalsize); + + /*set the listener gain, position (on xyz axes), velocity (one value for each axe) and orientation*/ + alListenerf (AL_GAIN, 1.0f ); + alListenerfv(AL_POSITION, ListenerPos); + alListenerfv(AL_VELOCITY, ListenerVel); + alListenerfv(AL_ORIENTATION, ListenerOri); + + if (AlGetError("(%s) WARN - Failed to set Listener properties") != AL_TRUE) + return AL_FALSE; + + openalReady = AL_TRUE; + + alGetError(); /* clear any AL errors beforehand */ + return AL_TRUE; } - free(theSounds); - - context = alcGetCurrentContext(); - device = alcGetContextsDevice(context); - - alcMakeContextCurrent(NULL); - alcDestroyContext(context); - alcCloseDevice(device); - - oalbReady = 0; - return; -} - -/** - * char oalb_ready (void) - * - * ARGUMENTS - * - - * DESCRIPTION - * - * RETURN - * - - */ - -char oalb_ready (void) { - return oalbReady; -} -/* - ALboolean helper_realloc (void) { - expands allocated memory when loading more sound files than expected - int oldsize = globalsize; - globalsize += increment; - - #ifdef DEBUG - err_msg("(%s) INFO - Realloc in process from %d to %d\n", prog, oldsize, globalsize); - #endif - - Buffers = (ALuint*) Realloc(Buffers, sizeof(ALuint)*globalsize); - Sources = (ALuint*) Realloc(Sources, sizeof(ALuint)*globalsize); - - return AL_TRUE; - }*/ - -/** - * const int32_t oalb_loadfile (const char *filename) - * - * ARGUMENTS - * - - * DESCRIPTION - * - * RETURN - * - - */ - -const int32_t oalb_loadfile (const char *filename){ - /*Open a file, load into memory and allocate the Source buffer for playing*/ - ALenum format, error; - ALsizei bitsize, freq; - char *data; - int namelength, i; - uint32_t magic; - FILE *fp; - - if (oalbReady == 0) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return -1; + ALboolean helper_realloc (void) { + /*expands allocated memory when loading more sound files than expected*/ + int oldsize = globalsize; + globalsize += increment; + +#ifdef DEBUG + err_msg("(%s) INFO - Realloc in process from %d to %d\n", prog, oldsize, globalsize); +#endif + + Buffers = (ALuint*) Realloc(Buffers, sizeof(ALuint)*globalsize); + Sources = (ALuint*) Realloc(Sources, sizeof(ALuint)*globalsize); + + return AL_TRUE; } - /*when the buffers are all used, we can expand memory to accept new files*/ - // if (globalindex == globalsize) - // helper_realloc(); - namelength=strlen(filename); - /*if this sound is already loaded return the index from theSounds*/ - for (i = 0; i < iNumSounds; i++){ - if (theSounds[iNumSounds].isLoaded == 1) { - if (strncmp(theSounds[iNumSounds].filename, filename, namelength) == 0) - return i; + ALint openal_loadfile (const char *filename){ + /*Open a file, load into memory and allocate the Source buffer for playing*/ + ALfloat SourcePos[] = { 0.0, 0.0, 0.0 }; /*Position of the source sound*/ + ALfloat SourceVel[] = { 0.0, 0.0, 0.0 }; /*Velocity of the source sound*/ + ALenum format; + ALsizei bitsize, freq; + char *data; + uint32_t fileformat; + ALenum error; + FILE *fp; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*when the buffers are all used, we can expand memory to accept new files*/ + if (globalindex == globalsize) + helper_realloc(); + + /*detect the file format, as written in the first 4 bytes of the header*/ + fp = Fopen (filename, "rb"); + + if (fp == NULL) + return -1; + + error = fread (&fileformat, sizeof(uint32_t), 1, fp); + fclose (fp); + + if (error < 0) { + errno = EIO; + err_ret("(%s) ERROR - File %s is too short", prog, filename); + return -2; } - } - - /*else load it and store it into a theSounds cell*/ - - /*detect the file format, as written in the first 4 bytes of the header*/ - fp = Fopen (filename, "rb"); - - if (fp == NULL) - return -1; - - error = fread (&magic, sizeof(uint32_t), 1, fp); - fclose (fp); - - if (error < 0) { - errno = EIO; - err_ret("(%s) ERROR - File %s is too short", prog, filename); - return -2; - } - - switch (ENDIAN_BIG_32(magic)) { - case OGG_FILE_FORMAT: - error = load_oggvorbis (filename, &format, &data, &bitsize, &freq); - break; - case WAV_FILE_FORMAT: - error = load_wavpcm (filename, &format, &data, &bitsize, &freq); - break; - default: - errno = EINVAL; - err_ret ("(%s) ERROR - File format (%08X) not supported", prog, ENDIAN_BIG_32(magic)); - return -5; - break; - } - - theSounds[iNumSounds].filename = (char*) Malloc(sizeof(char) * namelength); - strncpy(theSounds[iNumSounds].filename, filename, namelength); - theSounds[iNumSounds].isLoaded = 1; - - /*prepare the buffer to receive data*/ - alGenBuffers(1, &theSounds[iNumSounds].Buffer); - - if (AlGetError("(%s) ERROR - Failed to allocate memory for buffers") != AL_TRUE) - return -3; - - /*copy pcm data in one buffer*/ - alBufferData(theSounds[iNumSounds].Buffer, format, data, bitsize, freq); - /*deallocate data to save memory*/ - free(data); - - if (AlGetError("(%s) ERROR - Failed to write data to buffers") != AL_TRUE) - return -6; - - alGetError(); /* clear any AL errors beforehand */ - - /*returns the index of the source you just loaded, increments it and exits*/ - return iNumSounds++; -} - - - -void oalb_setvolume (const uint32_t iIndex, const char cPercentage) { - float percentage; - - if (oalbReady == 0) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; + + /*prepare the buffer to receive data*/ + alGenBuffers(1, &Buffers[globalindex]); + + if (AlGetError("(%s) ERROR - Failed to allocate memory for buffers") != AL_TRUE) + return -3; + + /*prepare the source to emit sound*/ + alGenSources(1, &Sources[globalindex]); + + if (AlGetError("(%s) ERROR - Failed to allocate memory for sources") != AL_TRUE) + return -4; + + + switch (ENDIAN_BIG_32(fileformat)) { + case OGG_FILE_FORMAT: + error = load_oggvorbis (filename, &format, &data, &bitsize, &freq); + break; + case WAV_FILE_FORMAT: + error = load_wavpcm (filename, &format, &data, &bitsize, &freq); + break; + default: + errno = EINVAL; + err_ret ("(%s) ERROR - File format (%08X) not supported", prog, ENDIAN_BIG_32(fileformat)); + return -5; + break; + } + + + /*copy pcm data in one buffer*/ + alBufferData(Buffers[globalindex], format, data, bitsize, freq); + free(data); /*deallocate data to save memory*/ + + if (AlGetError("(%s) ERROR - Failed to write data to buffers") != AL_TRUE) + return -6; + + /*set source properties that it will use when it's in playback*/ + alSourcei (Sources[globalindex], AL_BUFFER, Buffers[globalindex] ); + alSourcef (Sources[globalindex], AL_PITCH, 1.0f ); + alSourcef (Sources[globalindex], AL_GAIN, 1.0f ); + alSourcefv(Sources[globalindex], AL_POSITION, SourcePos ); + alSourcefv(Sources[globalindex], AL_VELOCITY, SourceVel ); + alSourcei (Sources[globalindex], AL_LOOPING, 0 ); + + if (AlGetError("(%s) ERROR - Failed to set Source properties") != AL_TRUE) + return -7; + + alGetError(); /* clear any AL errors beforehand */ + + /*returns the index of the source you just loaded, increments it and exits*/ + return globalindex++; } - /*Set volume for sound number index*/ - if(iIndex < 0 || iIndex >= iNumSounds) { - errno = EINVAL; - err_ret("(%s) ERROR - Index (%d) out of bounds", prog, iIndex); - return; - } - if(cPercentage > 100) - percentage = 1.0f; - else - percentage = cPercentage / 100.0f; - - alSourcef(Sources[theSounds[iIndex].sourceIndex], AL_GAIN, percentage); - - if (AlGetError2("(%s) ERROR - Failed to set volume for sound %d\n", iIndex) != AL_TRUE) - return; - - alGetError(); /* clear any AL errors beforehand */ - - return; -} - - - -void oalb_setglobalvolume (const char cPercentage) { - if (oalbReady == 0) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; - } - - /*Set volume for all sounds*/ - if(cPercentage > 100) - alListenerf (AL_GAIN, 1.0f); - else - alListenerf (AL_GAIN, cPercentage / 100.0f); - - if (AlGetError("(%s) ERROR - Failed to set global volume") != AL_TRUE) - return; - - alGetError(); /* clear any AL errors beforehand */ - - return; -} - -void oalb_togglemute (void) { - /*Mute or unmute sound*/ - ALfloat mute; - - if (oalbReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; + ALboolean openal_toggleloop (uint32_t index){ + /*Set or unset looping mode*/ + ALint loop; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + + alGetSourcei (Sources[index], AL_LOOPING, &loop); + alSourcei (Sources[index], AL_LOOPING, !((uint8_t) loop) & 0x00000001); + if (AlGetError("(%s) ERROR - Failed to get or set loop property") != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } - alGetListenerf (AL_GAIN, &mute); - if (mute > 0) - mute = 0; - else - mute = 1.0; - alListenerf (AL_GAIN, mute); - - if (AlGetError("(%s) ERROR - Failed to set mute property") != AL_TRUE) - return; - - alGetError(); /* clear any AL errors beforehand */ - - return; -} - - -void oalb_fade (uint32_t iIndex, uint16_t quantity, ALboolean direction) { - /*Fade in or out by calling a helper thread*/ -#ifndef _WIN32 - pthread_t thread; -#else - HANDLE Thread; - DWORD threadID; -#endif - fade_t *fade; - - if (oalbReady == 0) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return ; + ALboolean openal_setvolume (uint32_t index, uint8_t percentage) { + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Set volume for sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + + if (percentage > 100) + percentage = 100; + alSourcef (Sources[index], AL_GAIN, (float) percentage/100.0f); + if (AlGetError2("(%s) ERROR - Failed to set volume for sound %d\n", index) != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } - fade = (fade_t*) Malloc(sizeof(fade_t)); - fade->index = theSounds[iIndex].sourceIndex; - fade->quantity = quantity; - if(iIndex < 0 || iIndex >= iNumSounds) { - errno = EINVAL; - err_ret("(%s) ERROR - Index (%d) out of bounds", prog, iIndex); - return; + ALboolean openal_setglobalvolume (uint8_t percentage) { + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Set volume for all sounds*/ + if (percentage > 100) + percentage = 100; + alListenerf (AL_GAIN, (float) percentage/100.0f); + if (AlGetError("(%s) ERROR - Failed to set global volume") != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } - switch (direction) { - case FADE_IN: -#ifndef _WIN32 - pthread_create(&thread, NULL, helper_fadein, (void*) fade); -#else - Thread = _beginthread(&helper_fadein, 0, (void*) fade); -#endif - break; - case FADE_OUT: -#ifndef _WIN32 - pthread_create(&thread, NULL, helper_fadeout, (void*) fade); -#else - Thread = _beginthread(&helper_fadeout, 0, (void*) fade); -#endif - break; - default: - errno = EINVAL; - err_ret("(%s) ERROR - Unknown direction for fading", prog, iIndex); - free(fade); - return; - break; + + ALboolean openal_togglemute () { + /*Mute or unmute sound*/ + ALfloat mute; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + alGetListenerf (AL_GAIN, &mute); + if (mute > 0) + mute = 0; + else + mute = 1.0; + alListenerf (AL_GAIN, mute); + if (AlGetError("(%s) ERROR - Failed to set mute property") != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } + + ALboolean openal_fade (uint32_t index, uint16_t quantity, ALboolean direction) { + /*Fade in or out by calling a helper thread*/ #ifndef _WIN32 - pthread_detach(thread); + pthread_t thread; +#else + HANDLE Thread; + DWORD threadID; #endif - - alGetError(); /* clear any AL errors beforehand */ - - return; -} - - -void oalb_fadeout (uint32_t index, uint16_t quantity) { - /*wrapper for fadeout*/ - oalb_fade(index, quantity, FADE_OUT); - return; -} - - -void oalb_fadein (uint32_t index, uint16_t quantity) { - /*wrapper for fadein*/ - oalb_fade(index, quantity, FADE_IN); - return; -} - - -/* ALboolean openal_setposition (uint32_t index, float x, float y, float z) { - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - if (index >= globalsize) { - errno = EINVAL; - err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); - return AL_FALSE; - } - - alSource3f(Sources[index], AL_POSITION, x, y, z); - if (AlGetError2("(%s) ERROR - Failed to set position for sound %d)", index) != AL_TRUE) - return AL_FALSE; - - return AL_TRUE; - }*/ - - -void oalb_playsound (const uint32_t iIndex, const char bLoop){ - int findNewSource; - int i, j, state; - - if (oalbReady == 0) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; + fade_t *fade; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + fade = (fade_t*) Malloc(sizeof(fade_t)); + fade->index = index; + fade->quantity = quantity; + + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + + switch (direction) { + case FADE_IN: +#ifndef _WIN32 + pthread_create(&thread, NULL, helper_fadein, (void*) fade); +#else + Thread = _beginthread(&helper_fadein, 0, (void*) fade); +#endif + break; + case FADE_OUT: +#ifndef _WIN32 + pthread_create(&thread, NULL, helper_fadeout, (void*) fade); +#else + Thread = _beginthread(&helper_fadeout, 0, (void*) fade); +#endif + break; + default: + errno = EINVAL; + err_ret("(%s) ERROR - Unknown direction for fading", prog, index, globalindex); + free(fade); + return AL_FALSE; + break; + } + +#ifndef _WIN32 + pthread_detach(thread); +#endif + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } - /*Play sound number index*/ - if(iIndex < 0 || iIndex >= iNumSounds) { - errno = EINVAL; - err_ret("(%s) ERROR - Index (%d) out of bounds", prog, iIndex); - return; + + ALboolean openal_fadeout (uint32_t index, uint16_t quantity) { + /*wrapper for fadeout*/ + return openal_fade(index, quantity, FADE_OUT); } - /*check if sound has already a source*/ - if (theSounds[iIndex].sourceIndex == -1) { - /*needs a new source*/ - findNewSource = 1; - } else { - /*already has a source -- check it's not playing*/ - alGetSourcei(Sources[theSounds[iIndex].sourceIndex], AL_SOURCE_STATE, &state); - if(state == AL_PLAYING || state == AL_PAUSED) { - /*it is being played, so we have to allocate a new source*/ - findNewSource = 1; - } else { - /*it is not being played, so we can use it safely*/ - findNewSource = 0; - } + + ALboolean openal_fadein (uint32_t index, uint16_t quantity) { + /*wrapper for fadein*/ + return openal_fade(index, quantity, FADE_IN); } - if (findNewSource == 1) { -#ifdef DEBUG - err_msg("(%s) DEBUG - Looking for a source for sound %d", prog, iIndex); -#endif - for (i = 0; i < MAX_SOURCES; i++) { - alGetSourcei(Sources[i], AL_SOURCE_STATE, &state); - if(state != AL_PLAYING && state != AL_PAUSED) { - // alSourceStop(Sources[i]); - // alGetError(); - for(j = 0; j < iNumSounds; j++) - if(theSounds[j].isLoaded && theSounds[j].sourceIndex == i) - theSounds[j].sourceIndex = -1; - break; - } else { - //TODO: what happens when all 16 sources are busy? - } + + ALboolean openal_setposition (uint32_t index, float x, float y, float z) { + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; } - theSounds[iIndex].sourceIndex = i; + + alSource3f(Sources[index], AL_POSITION, x, y, z); + if (AlGetError2("(%s) ERROR - Failed to set position for sound %d)", index) != AL_TRUE) + return AL_FALSE; + + return AL_TRUE; + } + + + ALboolean openal_playsound (uint32_t index){ + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Play sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + alSourcePlay(Sources[index]); + if (AlGetError2("(%s) ERROR - Failed to play sound %d)", index) != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } - alSourcei (Sources[theSounds[iIndex].sourceIndex], AL_BUFFER, theSounds[iIndex].Buffer); - alSourcef (Sources[theSounds[iIndex].sourceIndex], AL_PITCH, 1.0f ); - alSourcef (Sources[theSounds[iIndex].sourceIndex], AL_GAIN, 1.0f ); - alSourcefv(Sources[theSounds[iIndex].sourceIndex], AL_POSITION, SourcePos ); - alSourcefv(Sources[theSounds[iIndex].sourceIndex], AL_VELOCITY, SourceVel ); - alSourcei (Sources[theSounds[iIndex].sourceIndex], AL_LOOPING, bLoop ); - if (AlGetError("(%s) ERROR - Failed to set Source properties") != AL_TRUE) - return; - alSourcePlay(Sources[theSounds[iIndex].sourceIndex]); - if (AlGetError2("(%s) ERROR - Failed to play sound %d)", iIndex) != AL_TRUE) - return; - - alGetError(); /* clear any AL errors beforehand */ - - return; -} - - -void oalb_pausesound (const uint32_t iIndex) { - if (oalbReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; + ALboolean openal_pausesound(uint32_t index){ + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Pause sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + alSourcePause(Sources[index]); + if (AlGetError2("(%s) ERROR - Failed to pause sound %d)", index) != AL_TRUE) + return AL_FALSE; + + return AL_TRUE; } - /*Pause sound number index*/ - if(iIndex < 0 || iIndex >= iNumSounds) { - errno = EINVAL; - err_ret("(%s) ERROR - Index (%d) out of bounds", prog, iIndex); - return; - } - alSourcePause(Sources[theSounds[iIndex].sourceIndex]); - if (AlGetError2("(%s) ERROR - Failed to pause sound %d)", iIndex) != AL_TRUE) - return; - return; -} - - -void oalb_stopsound (const uint32_t iIndex) { - if (oalbReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return; + ALboolean openal_stopsound(uint32_t index){ + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Stop sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + alSourceStop(Sources[index]); + if (AlGetError2("(%s) ERROR - Failed to stop sound %d)", index) != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; } - /*Stop sound number index*/ - if(iIndex < 0 || iIndex >= iNumSounds) { - errno = EINVAL; - err_ret("(%s) ERROR - Index (%d) out of bounds", prog, iIndex); - return; - } - alSourceStop(Sources[theSounds[iIndex].sourceIndex]); - - if (AlGetError2("(%s) ERROR - Failed to stop sound %d)", iIndex) != AL_TRUE) - return; - - alGetError(); /* clear any AL errors beforehand */ - - return; +#ifdef __CPLUSPLUS } +#endif diff -r a1e0306b9cd1 -r 51e5df1c8462 openalbridge/openalbridge.h --- a/openalbridge/openalbridge.h Sat Oct 17 13:47:58 2009 +0000 +++ b/openalbridge/openalbridge.h Sat Oct 17 13:51:16 2009 +0000 @@ -19,35 +19,33 @@ #ifndef _OALB_INTERFACE_H #define _OALB_INTERFACE_H -#include "common.h" +#include "globals.h" #include "wrappers.h" +#include "alc.h" #include "loaders.h" -#include "alc.h" -#ifdef __cplusplus +#ifdef __CPLUSPLUS extern "C" { #endif - const char oalb_init (const char* programname, const char usehardware); - void oalb_close (void); - char oalb_ready (void); - const int32_t oalb_loadfile (const char* cFilename); - void oalb_playsound (const uint32_t iIndex, const char bLoop); - void oalb_pausesound (const uint32_t iIndex); - void oalb_stopsound (const uint32_t iIndex); - void oalb_setvolume (const uint32_t iIndex, const char cPercentage); - void oalb_setglobalvolume (const char cPercentage); - void oalb_togglemute (void); - void oalb_fade (uint32_t iIndex, uint16_t quantity, ALboolean direction); - void oalb_fadein (uint32_t iIndex, uint16_t quantity); - void oalb_fadeout (uint32_t iIndex, uint16_t quantity); - - /* + ALboolean openal_init (char* programname, ALboolean usehardware, unsigned int memorysize); + ALboolean openal_close (void); + ALboolean openal_ready (void); + ALint openal_loadfile (const char *filename); + ALboolean openal_toggleloop (unsigned int index); ALboolean openal_setposition (unsigned int index, float x, float y, float z); - */ + ALboolean openal_setvolume (unsigned int index, unsigned char percentage); + ALboolean openal_setglobalvolume (unsigned char percentage); + ALboolean openal_togglemute (void); + ALboolean openal_fadeout (unsigned int index, unsigned short int quantity); + ALboolean openal_fadein (unsigned int index, unsigned short int quantity); + ALboolean openal_fade (unsigned int index, unsigned short int quantity, ALboolean direction); + ALboolean openal_playsound (unsigned int index); + ALboolean openal_pausesound (unsigned int index); + ALboolean openal_stopsound (unsigned int index); -#ifdef __cplusplus +#ifdef __CPLUSPLUS } #endif diff -r a1e0306b9cd1 -r 51e5df1c8462 openalbridge/wrappers.c --- a/openalbridge/wrappers.c Sat Oct 17 13:47:58 2009 +0000 +++ b/openalbridge/wrappers.c Sat Oct 17 13:51:16 2009 +0000 @@ -18,64 +18,67 @@ #include "wrappers.h" -extern char *prog; -extern ALint Sources[MAX_SOURCES]; - -void *Malloc (size_t nbytes) { - void *aptr; +#ifdef __CPLUSPLUS +extern "C" { +#endif - if ((aptr = malloc(nbytes)) == NULL) - err_dump("(%s) FATAL - not enough memory"); + extern ALint *Sources; - return aptr; -} - - -void *Realloc (void *aptr, size_t nbytes) { - aptr = realloc(aptr, nbytes); + void *Malloc (size_t nbytes) { + void *aptr; + + if ((aptr = malloc(nbytes)) == NULL) + err_dump("(%s) FATAL - not enough memory"); + + return aptr; + } + - if (aptr == NULL) - err_dump("(%s) FATAL - not enough memory"); + void *Realloc (void *aptr, size_t nbytes) { + aptr = realloc(aptr, nbytes); + + if (aptr == NULL) + err_dump("(%s) FATAL - not enough memory"); + + return aptr; + } - return aptr; -} - - -FILE *Fopen (const char *fname, char *mode) { - FILE *fp; - fp = fopen(fname,mode); - if (fp == NULL) - err_ret("(%s) ERROR - can't open file %s in mode '%s'", prog, fname, mode); - - return fp; -} - -/*TODO make a proper error reporting routine*/ -ALint AlGetError (const char *str) { - ALenum error; + FILE *Fopen (const char *fname, char *mode) { + FILE *fp; + + fp = fopen(fname,mode); + if (fp == NULL) + err_ret("(%s) ERROR - can't open file %s in mode '%s'", prog, fname, mode); + + return fp; + } - error = alGetError(); - if (error != AL_NO_ERROR) { - err_msg(str, prog); - return error; - } else - return AL_TRUE; -} - -ALint AlGetError2 (const char *str, int num) { - ALenum error; + /*TODO make a proper error reporting routine*/ + ALint AlGetError (const char *str) { + ALenum error; + + error = alGetError(); + if (error != AL_NO_ERROR) { + err_msg(str, prog); + return error; + } else + return AL_TRUE; + } - error = alGetError(); - if (error != AL_NO_ERROR) { - err_msg(str, prog, num); - return error; - } else - return AL_TRUE; -} - - void *helper_fadein(void *tmp) { + ALint AlGetError2 (const char *str, int num) { + ALenum error; + + error = alGetError(); + if (error != AL_NO_ERROR) { + err_msg(str, prog, num); + return error; + } else + return AL_TRUE; + } + + void *helper_fadein(void *tmp) { ALfloat gain; ALfloat target_gain; fade_t *fade; @@ -93,7 +96,7 @@ /*save the volume desired after the fade*/ alGetSourcef(Sources[index], AL_GAIN, &target_gain); - if (target_gain > 1.0f || target_gain < 0.0f) + if (target_gain > 1.0f || target_gain <= 0.0f) target_gain = 1.0f; alSourcePlay(Sources[index]); @@ -156,3 +159,7 @@ return 0; } + +#ifdef __CPLUSPLUS +} +#endif diff -r a1e0306b9cd1 -r 51e5df1c8462 openalbridge/wrappers.h --- a/openalbridge/wrappers.h Sat Oct 17 13:47:58 2009 +0000 +++ b/openalbridge/wrappers.h Sat Oct 17 13:51:16 2009 +0000 @@ -19,7 +19,7 @@ #ifndef _OALB_WRAPPERS_H #define _OALB_WRAPPERS_H -#include "common.h" +#include "globals.h" #ifdef __CPLUSPLUS