hedgewars-draft: comparison openalbridge/openalbridge.c

equal deleted inserted replaced

-:f7ed1ea25050
+:538a777f90c4
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
 #include "openalbridge.h"
-#include "wrappers.h"
-#include "alc.h"
-#include "loaders.h"
-#include "endianness.h"
 #ifdef __CPLUSPLUS
 extern "C" {
 #endif
 ALuint globalindex, globalsize, increment;
 ALboolean openalReady = AL_FALSE;
 ALboolean openal_close (void) {
 /*Stop all sounds, deallocate all memory and close OpenAL */
 ALCcontext *context;
 ALCdevice  *device;
-if(openalReady == AL_FALSE) {
+if (openalReady == AL_FALSE) {
-fprintf(stderr, "ERROR: OpenAL not initialized\n");
+errno = EPERM;
-return AL_FALSE;
+err_ret("(%s) WARN - OpenAL not initialized", prog);
-}
+return AL_FALSE;
+}
 alSourceStopv	(globalsize, Sources);
 alDeleteSources (globalsize, Sources);
 alDeleteBuffers (globalsize, Buffers);
 free(Sources);
 ALboolean openal_ready(void) {
 return openalReady;
 }
-ALboolean openal_init(uint32_t usehardware, uint32_t memorysize) {
+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) {
+if (openalReady == AL_TRUE) {
-fprintf(stderr, "ERROR 'openal_init()': OpenAL already initialized\n");
+errno = EPERM;
-return AL_FALSE;
+err_ret("(%s) WARN - OpenAL already initialized", prog);
-}
+return AL_FALSE;
+}
-		if(usehardware)
-		{
+if (usehardware)
-			if ((device = alcOpenDevice(NULL)) == NULL) {
+device = alcOpenDevice(NULL);
-				fprintf(stderr, "ERROR 'openal_init()': Failed to open sound device\n");
+else
-				return AL_FALSE;
+device = alcOpenDevice("Generic Software");
-			}
-		}
+if (device == NULL) {
-		else
+errno = ENODEV;
-		{
+err_ret("(%s) WARN - Failed to open sound device", prog);
-			if ((device = alcOpenDevice("Generic Software")) == NULL) {
+return AL_FALSE;
-				fprintf(stderr, "ERROR 'openal_init()': Failed to open sound device\n");
+}
-				return AL_FALSE;
+err_msg("(%s) INFO - output device: %s", prog, alcGetString(device, ALC_DEVICE_SPECIFIER));
-			}
-		}
+context = alcCreateContext(device, NULL);
-		fprintf(stderr, "Using default device: %s\n", alcGetString(device, ALC_DEVICE_SPECIFIER));
+alcMakeContextCurrent(context);
+alcProcessContext(context);
-context = alcCreateContext(device, NULL);
-alcMakeContextCurrent(context);
+if (AlGetError("(%s) WARN - Failed to create a new contex") != AL_TRUE)
-alcProcessContext(context);
-if (AlGetError("ERROR %d in 'openal_init()': Creating a new contex\n") != AL_TRUE)
 return AL_FALSE;
 /*allocate memory space for buffers and sources*/
 	if (memorysize == 0)
 	    globalsize = 50;
 alListenerf (AL_GAIN,        1.0f       );
 alListenerfv(AL_POSITION,    ListenerPos);
 alListenerfv(AL_VELOCITY,    ListenerVel);
 alListenerfv(AL_ORIENTATION, ListenerOri);
-if (AlGetError("ERROR %d: Setting Listener properties\n") != AL_TRUE)
+if (AlGetError("(%s) WARN - Failed to set Listener properties") != AL_TRUE)
 return AL_FALSE;
 openalReady = AL_TRUE;
 alGetError();  /* clear any AL errors beforehand */
 /*expands allocated memory when loading more sound files than expected*/
 int oldsize = globalsize;
 globalsize += increment;
 #ifdef DEBUG
-fprintf(stderr, "OpenALBridge: Realloc in process from %d to %d\n", oldsize, globalsize);
+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);
 char *data;
 uint32_t fileformat;
 ALenum error;
 FILE *fp;
-if(openalReady == AL_FALSE) {
+if (openalReady == AL_FALSE) {
-fprintf(stderr, "ERROR 'openal_loadfile()': OpenAL not initialized\n");
+errno = EPERM;
-return AL_FALSE;
+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) {
-fprintf(stderr, "ERROR 'openal_loadfile()': file %s is too short \n", filename);
+errno = EIO;
-return -2;
+err_ret("(%s) ERROR - file %s is too short", prog, filename);
+return -2;
 }
 /*prepare the buffer to receive data*/
 alGenBuffers(1, &Buffers[globalindex]);
-if (AlGetError("ERROR %d in 'openal_loadfile()': Allocating memory for buffers\n") != AL_TRUE)
+if (AlGetError("(%s) ERROR - allocating memory for buffers") != AL_TRUE)
 return -3;
 /*prepare the source to emit sound*/
 alGenSources(1, &Sources[globalindex]);
-if (AlGetError("ERROR %d in 'openal_loadfile()': Allocating memory for sources\n") != AL_TRUE)
+if (AlGetError("(%s) ERROR - allocating memory for sources") != AL_TRUE)
 return -4;
 switch (ENDIAN_BIG_32(fileformat)) {
 case OGG_FILE_FORMAT:
 break;
 case WAV_FILE_FORMAT:
 error = load_wavpcm (filename, &format, &data, &bitsize, &freq);
 break;
 default:
-fprintf(stderr, "ERROR 'openal_loadfile()': File format (%08X) not supported!\n", ENDIAN_BIG_32(fileformat));
+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("ERROR %d in 'openal_loadfile()': Writing data to buffer\n") != AL_TRUE)
+if (AlGetError("(%s) ERROR - writing 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("ERROR %d in 'openal_loadfile()': Setting source properties\n") != AL_TRUE)
+if (AlGetError("(%s) ERROR - setting 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*/
 ALboolean openal_toggleloop (uint32_t index){
 /*Set or unset looping mode*/
 ALint loop;
-if(openalReady == AL_FALSE) {
+if (openalReady == AL_FALSE) {
-fprintf(stderr, "ERROR 'openal_toggleloop()': OpenAL not initialized\n");
+errno = EPERM;
-return AL_FALSE;
+err_ret("(%s) WARN - OpenAL not initialized", prog);
-}
+return AL_FALSE;
+}
 if (index >= globalsize) {
-fprintf(stderr, "ERROR 'openal_toggleloop()': index out of bounds (got %d, max %d)\n", index, globalindex);
+errno = EINVAL;
-return AL_FALSE;
+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("ERROR %d in 'openal_toggleloop()': Getting or setting loop property\n") != AL_TRUE)
+if (AlGetError("(%s) ERROR - getting or setting loop property") != AL_TRUE)
 return AL_FALSE;
 alGetError();  /* clear any AL errors beforehand */
 return AL_TRUE;
 }
 ALboolean openal_setvolume (uint32_t index, uint8_t percentage) {
-if(openalReady == AL_FALSE) {
+if (openalReady == AL_FALSE) {
-fprintf(stderr, "ERROR 'openal_setvolume()': OpenAL not initialized\n");
+errno = EPERM;
-return AL_FALSE;
+err_ret("(%s) WARN - OpenAL not initialized", prog);
-}
+return AL_FALSE;
+}
 /*Set volume for sound number index*/
 if (index >= globalindex) {
 fprintf(stderr, "ERROR 'openal_setvolume()': index out of bounds (got %d, max %d)\n", index, globalindex);
 return AL_FALSE;
 return AL_TRUE;
 }
 ALboolean openal_setglobalvolume (uint8_t percentage) {
-if(openalReady == AL_FALSE) {
+if (openalReady == AL_FALSE) {
-fprintf(stderr, "ERROR 'openal_setglobalvolume()': OpenAL not initialized\n");
+errno = EPERM;
-return AL_FALSE;
+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);
 ALboolean openal_togglemute () {
 /*Mute or unmute sound*/
 ALfloat mute;
-if(openalReady == AL_FALSE) {
+if (openalReady == AL_FALSE) {
-fprintf(stderr, "ERROR 'openal_togglemute()': OpenAL not initialized\n");
+errno = EPERM;
-return AL_FALSE;
+err_ret("(%s) WARN - OpenAL not initialized", prog);
-}
+return AL_FALSE;
+}
 alGetListenerf (AL_GAIN, &mute);
 if (mute > 0)
 mute = 0;
 else
 HANDLE Thread;
 DWORD threadID;
 #endif
 fade_t *fade;
-if(openalReady == AL_FALSE) {
+if (openalReady == AL_FALSE) {
-fprintf(stderr, "ERROR 'openal_fade()': OpenAL not initialized\n");
+errno = EPERM;
-return AL_FALSE;
+err_ret("(%s) WARN - OpenAL not initialized", prog);
-}
+return AL_FALSE;
+}
 fade = (fade_t*) Malloc(sizeof(fade_t));
 fade->index = index;
 fade->quantity = quantity;
 return openal_fade(index, quantity, FADE_IN);
 }
 ALboolean openal_setposition (uint32_t index, float x, float y, float z) {
-if(openalReady == AL_FALSE) {
+if (openalReady == AL_FALSE) {
-fprintf(stderr, "ERROR 'openal_setposition()': OpenAL not initialized\n");
+errno = EPERM;
-return AL_FALSE;
+err_ret("(%s) WARN - OpenAL not initialized", prog);
-}
+return AL_FALSE;
+}
 if (index >= globalindex) {
 fprintf(stderr, "ERROR 'openal_setposition()': index out of bounds (got %d, max %d)\n", index, globalindex);
 return AL_FALSE;
 }
 return AL_TRUE;
 }
 ALboolean openal_playsound (uint32_t index){
-if(openalReady == AL_FALSE) {
+if (openalReady == AL_FALSE) {
-fprintf(stderr, "ERROR 'openal_playsound()': OpenAL not initialized\n");
+errno = EPERM;
-return AL_FALSE;
+err_ret("(%s) WARN - OpenAL not initialized", prog);
-}
+return AL_FALSE;
+}
 /*Play sound number index*/
 if (index >= globalindex) {
 fprintf(stderr, "ERROR 'openal_playsound()': index out of bounds (got %d, max %d)\n", index, globalindex);
 return AL_FALSE;
 return AL_TRUE;
 }
 ALboolean openal_pausesound(uint32_t index){
-if(openalReady == AL_FALSE) {
+if (openalReady == AL_FALSE) {
-fprintf(stderr, "ERROR 'openal_pausesound()': OpenAL not initialized\n");
+errno = EPERM;
-return AL_FALSE;
+err_ret("(%s) WARN - OpenAL not initialized", prog);
-}
+return AL_FALSE;
+}
 /*Pause sound number index*/
 if (index >= globalindex) {
 fprintf(stderr, "ERROR 'openal_pausesound()': index out of bounds (got %d, max %d)\n", index, globalindex);
 return AL_FALSE;
 return AL_TRUE;
 }
 ALboolean openal_stopsound(uint32_t index){
-if(openalReady == AL_FALSE) {
+if (openalReady == AL_FALSE) {
-fprintf(stderr, "ERROR 'openal_stopsound()': OpenAL not initialized\n");
+errno = EPERM;
-return AL_FALSE;
+err_ret("(%s) WARN - OpenAL not initialized", prog);
-}
+return AL_FALSE;
+}
 /*Stop sound number index*/
 if (index >= globalindex) {
 fprintf(stderr, "ERROR 'openal_stopsound()': index out of bounds (got %d, max %d)\n", index, globalindex);
 return AL_FALSE;

changeset 2418	538a777f90c4
parent 2415	35d09cbf819a
child 2419	dbaaba09146d