File openal-0.0.8-alsa-backend-fix.diff of Package openal

Overview Repositories Revisions Requests Users Attributes Meta

File openal-0.0.8-alsa-backend-fix.diff of Package openal

# HG changeset patch
# User tiwai
# Date 1182851580 -7200
# Node ID abe8ba9de91a4d173209ec750df3de6f3e7389fb
# Parent  1a2b02ef84229cfc1e650b51c95a0a9acd761b00
Fix ALSA backend

diff -r 1a2b02ef8422 -r abe8ba9de91a src/Makefile.am
--- a/src/Makefile.am	Mon Jun 25 15:21:50 2007 +0200
+++ b/src/Makefile.am	Tue Jun 26 11:53:00 2007 +0200
@@ -219,4 +219,9 @@ libopenal_la_LDFLAGS = -no-undefined $(P
 # We use sin and friends, so we might need -lm, autoconf takes care of this.
 libopenal_la_LIBADD = $(LIBM) $(asm_ldadd)
 
+if USEBACKENDALSA
+libopenal_la_LIBADD += -lasound
+endif
+
+
 SUBDIRS = $(X86_SUBDIR)
diff -r 1a2b02ef8422 -r abe8ba9de91a src/backends/alc_backend_alsa.c
--- a/src/backends/alc_backend_alsa.c	Mon Jun 25 15:21:50 2007 +0200
+++ b/src/backends/alc_backend_alsa.c	Tue Jun 26 11:53:00 2007 +0200
@@ -43,117 +43,8 @@
 
 #include <alsa/asoundlib.h>
 
-static void *alsa_lib_handle = NULL;
-static int (*psnd_pcm_hw_params_malloc)(snd_pcm_hw_params_t **ptr) = NULL;
-static void (*psnd_pcm_hw_params_free)(snd_pcm_hw_params_t *obj) = NULL;
-static const char *(*psnd_strerror)(int errnum) = NULL;
-static size_t (*psnd_pcm_info_sizeof)(void) = NULL;
-static int (*psnd_pcm_close)(snd_pcm_t *pcm) = NULL;
-static int (*psnd_pcm_hw_params)(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) = NULL;
-static int (*psnd_pcm_hw_params_any)(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) = NULL;
-static int (*psnd_pcm_hw_params_set_access)(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t acc) = NULL;
-static int (*psnd_pcm_hw_params_set_buffer_size_near)(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *val) = NULL;
-static int (*psnd_pcm_hw_params_set_channels)(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val) = NULL;
-static int (*psnd_pcm_hw_params_set_format)(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_format_t val) = NULL;
-static int (*psnd_pcm_hw_params_set_periods_near)(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir) = NULL;
-static int (*psnd_pcm_hw_params_set_rate_near)(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir) = NULL;
-static size_t (*psnd_pcm_hw_params_sizeof)(void) = NULL;
-static int (*psnd_pcm_prepare)(snd_pcm_t *pcm) = NULL;
-static snd_pcm_sframes_t (*psnd_pcm_readi)(snd_pcm_t *pcm, void *buffer, snd_pcm_uframes_t size) = NULL;
-static int (*psnd_pcm_resume)(snd_pcm_t *pcm) = NULL;
-static snd_pcm_sframes_t (*psnd_pcm_writei)(snd_pcm_t *pcm, const void *buffer, snd_pcm_uframes_t size) = NULL;
-static int (*psnd_pcm_hw_params_set_period_size_near)(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *val, int *dir) = NULL;
-static int (*psnd_pcm_open)(snd_pcm_t **pcm, const char *name,
-                     snd_pcm_stream_t stream, int mode) = NULL;
-static int (*psnd_pcm_nonblock)(snd_pcm_t * pcm, int nonblock) = NULL;
-
-/* !!! FIXME: hhm...this is a problem. */
-#if (SND_LIB_MAJOR == 0)
-static int (*psnd_pcm_hw_params_get_buffer_size)(const snd_pcm_hw_params_t *params) = NULL;
-static int (*psnd_pcm_hw_params_get_channels)(const snd_pcm_hw_params_t *params) = NULL;
-static snd_pcm_sframes_t (*psnd_pcm_hw_params_get_period_size)(const snd_pcm_hw_params_t *params, int *dir) = NULL;
-#else
-static int (*psnd_pcm_hw_params_get_buffer_size)(const snd_pcm_hw_params_t *params,
-                                          snd_pcm_uframes_t *val) = NULL;
-static int (*psnd_pcm_hw_params_get_channels)(const snd_pcm_hw_params_t *params, unsigned int *val) = NULL;
-static int (*psnd_pcm_hw_params_get_period_size)(const snd_pcm_hw_params_t *params, snd_pcm_uframes_t *frames, int *dir) = NULL;
-#endif
-
-static int openal_load_alsa_library(void)
-{
-#ifdef OPENAL_DLOPEN_ALSA
-        char * error = NULL;
-#endif
-    
-	if (alsa_lib_handle != NULL)
-		return 1;  /* already loaded. */
-
-        /* versioned symbol fetching macro, or NULL if no dlvsym available */
-#ifdef _GNU_SOURCE
-#define AL_DLVSYM dlvsym
-#else
-#define AL_DLVSYM(a,b,c) NULL
-#endif
-
-        /* ALSA uses symbol versioning, which is usually a good thing except
-           that it turns dlsym() into a lottery.  So, we look for known-good
-           symbol versions first before falling back to unversioned symbols. */
-        /* this is our current preferred symbol versioning order:
-           ALSA_0.9.0rc4 > (generic) */
-	#ifdef OPENAL_DLOPEN_ALSA
-		#define OPENAL_LOAD_ALSA_SYMBOL(x) p##x = AL_DLVSYM(alsa_lib_handle, #x, "ALSA_0.9.0rc4"); \
-                                                   error = dlerror(); \
-                                                   if ((error != NULL)||(p##x == NULL)) { \
-                                                           p##x = dlsym(alsa_lib_handle, #x); \
-                                                           error = dlerror(); \
-                                                           if ((error != NULL)||(p##x == NULL)) { \
-                                                                   fprintf(stderr,"Could not resolve ALSA symbol %s: %s\n", #x, ((error!=NULL)?(error):("(null)"))); \
-                                                                   dlclose(alsa_lib_handle); alsa_lib_handle = NULL; \
-                                                                   return 0; } else _alDebug(ALD_MAXIMUS, __FILE__, __LINE__, "got %s", #x); \
-                                                   } else _alDebug(ALD_MAXIMUS, __FILE__, __LINE__, "got %s", #x "@ALSA_0.9rc4");
-                dlerror(); /* clear error state */
-		alsa_lib_handle = dlopen("libasound.so.2", RTLD_LAZY | RTLD_GLOBAL);
-                error = dlerror();
-		if (alsa_lib_handle == NULL) {
-                        fprintf(stderr,"Could not open ALSA library: %s\n",((error!=NULL)?(error):("(null)")));
-			return 0;
-                }
-	#else
-		#define OPENAL_LOAD_ALSA_SYMBOL(x) p##x = x;
-		alsa_lib_handle = (void *) 0xF00DF00D;
-	#endif
-
-	OPENAL_LOAD_ALSA_SYMBOL(snd_strerror);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_info_sizeof);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_malloc);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_free);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_open);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_close);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_any);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_get_buffer_size);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_get_channels);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_get_period_size);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_set_access);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_set_buffer_size_near);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_set_channels);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_set_format);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_set_period_size_near);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_set_periods_near);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_set_rate_near);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_hw_params_sizeof);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_open);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_nonblock);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_prepare);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_readi);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_resume);
-	OPENAL_LOAD_ALSA_SYMBOL(snd_pcm_writei);
-
-	return 1;
-}
-
 /* alsa stuff */
-#define DEFAULT_DEVICE "plughw:0,0"
+#define DEFAULT_DEVICE "default"
 
 /* convert from AL to ALSA format */
 static int AL2ALSAFMT(ALenum format);
@@ -185,7 +76,7 @@ void release_alsa(void *handle)
 	struct alsa_info *ai = handle;
 	if(handle == NULL)
 	  return;
-	psnd_pcm_close(ai->handle);
+	snd_pcm_close(ai->handle);
 	free(ai);
 }
 
@@ -196,15 +87,12 @@ static void *grab_read_alsa( void )
 	char card_name[256];
 	int err;
 
-	if (!openal_load_alsa_library())
-		return NULL;
-
 	get_in_device_name(card_name, 256);
 
-	err = psnd_pcm_open(&handle, card_name, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
-	if(err < 0)
-	{
-		const char *serr = psnd_strerror(err);
+	err = snd_pcm_open(&handle, card_name, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
+	if(err < 0)
+	{
+		const char *serr = snd_strerror(err);
 
 		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
 				"grab_alsa: init failed: %s", serr);
@@ -280,18 +168,15 @@ static void *grab_write_alsa( void )
 	char card_name[256];
 	int err;
 
-	if (!openal_load_alsa_library())
-		return NULL;
-
 	get_out_device_name(card_name, 256);
 
         /* Try to open the device without blocking, so we can 
          * try other backends even if this would block.
          */
-	err = psnd_pcm_open(&handle, card_name, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
-	if(err < 0)
-	{
-		const char *serr = psnd_strerror(err);
+	err = snd_pcm_open(&handle, card_name, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
+	if(err < 0)
+	{
+		const char *serr = snd_strerror(err);
 
 		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
 			"grab_alsa: init failed: %s", serr);
@@ -302,10 +187,10 @@ static void *grab_write_alsa( void )
         /* Now that we have successfully opened the device, 
          * we can put it into blocking mode.
          */
-        err = psnd_pcm_nonblock(handle,0);
-	if(err < 0)
-	{
-		const char *serr = psnd_strerror(err);
+        err = snd_pcm_nonblock(handle,0);
+	if(err < 0)
+	{
+		const char *serr = snd_strerror(err);
 
 		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
 			"grab_alsa: could not put device into blocking mode: %s", serr);
@@ -367,105 +252,96 @@ static ALboolean set_read_alsa( void *ha
 
 	phandle = ai->handle;
 
-	psnd_pcm_hw_params_malloc(&setup);
-	err = psnd_pcm_hw_params_any(phandle, setup);
-	if(err < 0)
-	{
-		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_read_alsa: Could not query parameters: %s",psnd_strerror(err));
-
-		psnd_pcm_hw_params_free(setup);
+	snd_pcm_hw_params_malloc(&setup);
+	err = snd_pcm_hw_params_any(phandle, setup);
+	if(err < 0)
+	{
+		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
+				"set_read_alsa: Could not query parameters: %s",snd_strerror(err));
+
+		snd_pcm_hw_params_free(setup);
 		return AL_FALSE;
 	}
 
 	/* set the interleaved read format */
-	err = psnd_pcm_hw_params_set_access(phandle, setup, SND_PCM_ACCESS_RW_INTERLEAVED);
+	err = snd_pcm_hw_params_set_access(phandle, setup, SND_PCM_ACCESS_RW_INTERLEAVED);
 	if (err < 0) {
 		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_read_alsa: Could not set access type: %s",psnd_strerror(err));
-		psnd_pcm_hw_params_free(setup);
+				"set_read_alsa: Could not set access type: %s",snd_strerror(err));
+		snd_pcm_hw_params_free(setup);
 		return AL_FALSE;
 	}
 
 	/* set format */
-	err = psnd_pcm_hw_params_set_format(phandle, setup, ai->format);
-	if(err < 0)
-	{
-		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_read_alsa: could not set format: %s",psnd_strerror(err));
-
-		psnd_pcm_hw_params_free(setup);
+	err = snd_pcm_hw_params_set_format(phandle, setup, ai->format);
+	if(err < 0)
+	{
+		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
+				"set_read_alsa: could not set format: %s",snd_strerror(err));
+
+		snd_pcm_hw_params_free(setup);
 		return AL_FALSE;
 	}
 
 
 	/* channels */
-	err = psnd_pcm_hw_params_set_channels(phandle, setup, ai->channels);
+	err = snd_pcm_hw_params_set_channels(phandle, setup, ai->channels);
 	if(err < 0)
 	{
 		unsigned int ch;
-#if (SND_LIB_MAJOR == 0)
-		ch = err = psnd_pcm_hw_params_get_channels(setup);
-#else
-		err = psnd_pcm_hw_params_get_channels(setup, &ch);
-#endif
+		err = snd_pcm_hw_params_get_channels(setup, &ch);
 
 		if (ch != ai->channels) {
 			_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-					"set_read_alsa: could not set channels: %s",psnd_strerror(err));
-
-			psnd_pcm_hw_params_free(setup);
+					"set_read_alsa: could not set channels: %s",snd_strerror(err));
+
+			snd_pcm_hw_params_free(setup);
 			return AL_FALSE;
 		}
 	}
 
 
 	/* sampling rate */
-	err = psnd_pcm_hw_params_set_rate_near(phandle, setup, &ai->speed, NULL);
-	if(err < 0)
-	{
-		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_read_alsa: could not set speed: %s",psnd_strerror(err));
-
-		psnd_pcm_hw_params_free(setup);
+	err = snd_pcm_hw_params_set_rate_near(phandle, setup, &ai->speed, NULL);
+	if(err < 0)
+	{
+		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
+				"set_read_alsa: could not set speed: %s",snd_strerror(err));
+
+		snd_pcm_hw_params_free(setup);
 		return AL_FALSE;
 	}
 
 	/* Set number of periods. Periods used to be called fragments. */
 	{ snd_pcm_uframes_t val = 4096;
-	err = psnd_pcm_hw_params_set_period_size_near(phandle, setup, &val, NULL);
+	err = snd_pcm_hw_params_set_period_size_near(phandle, setup, &val, NULL);
 	if (err < 0) {
 		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_read_alsa: %s", psnd_strerror(err));
-		psnd_pcm_hw_params_free(setup);
-		return AL_FALSE;
-	}
-	}
-
-	err = psnd_pcm_hw_params_set_periods_near(phandle, setup, &ai->periods, 0);
+				"set_read_alsa: %s", snd_strerror(err));
+		snd_pcm_hw_params_free(setup);
+		return AL_FALSE;
+	}
+	}
+
+	err = snd_pcm_hw_params_set_periods_near(phandle, setup, &ai->periods, 0);
 	if (err < 0) {
 		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_read_alsa: %s", psnd_strerror(err));
-		psnd_pcm_hw_params_free(setup);
-		return AL_FALSE;
-	}
-
-	err = psnd_pcm_hw_params_set_buffer_size_near(phandle, setup, &ai->bufframesize);
+				"set_read_alsa: %s", snd_strerror(err));
+		snd_pcm_hw_params_free(setup);
+		return AL_FALSE;
+	}
+
+	err = snd_pcm_hw_params_set_buffer_size_near(phandle, setup, &ai->bufframesize);
 	if (err < 0) {
 		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
 				"set_read_alsa: %s, size: %lu, speed: %d",
-				psnd_strerror(err), ai->bufframesize, ai->speed);
-		psnd_pcm_hw_params_free(setup);
-		return AL_FALSE;
-	}
-
-#if (SND_LIB_MAJOR == 0)
-	buffer_size = psnd_pcm_hw_params_get_buffer_size(setup);
-	period_size = psnd_pcm_hw_params_get_period_size(setup, &dir);
-#else
-	psnd_pcm_hw_params_get_buffer_size(setup, &buffer_size);
-	psnd_pcm_hw_params_get_period_size(setup, &period_size, &dir);
-#endif
+				snd_strerror(err), ai->bufframesize, ai->speed);
+		snd_pcm_hw_params_free(setup);
+		return AL_FALSE;
+	}
+
+	snd_pcm_hw_params_get_buffer_size(setup, &buffer_size);
+	snd_pcm_hw_params_get_period_size(setup, &period_size, &dir);
 
 	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
 			"set_read_alsa (info): Buffersize = %lu (%u)",buffer_size, *bufsiz);
@@ -473,21 +349,21 @@ static ALboolean set_read_alsa( void *ha
 			"set_read_alsa (info): Periodsize = %lu", period_size);
 	*bufsiz = buffer_size * ai->framesize;
 
-	err = psnd_pcm_hw_params(phandle, setup);
-	if(err < 0)
-	{
-		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_read_alsa: %s", psnd_strerror(err));
-		psnd_pcm_hw_params_free(setup);
-		return AL_FALSE;
-	}
-
-	err = psnd_pcm_prepare(phandle);
+	err = snd_pcm_hw_params(phandle, setup);
+	if(err < 0)
+	{
+		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
+				"set_read_alsa: %s", snd_strerror(err));
+		snd_pcm_hw_params_free(setup);
+		return AL_FALSE;
+	}
+
+	err = snd_pcm_prepare(phandle);
 	if(err < 0)
 	{
 		_alDebug(ALD_MAXIMUS,  __FILE__, __LINE__,
-				"set_read_alsa %s", psnd_strerror(err));
-		psnd_pcm_hw_params_free(setup);
+				"set_read_alsa %s", snd_strerror(err));
+		snd_pcm_hw_params_free(setup);
 		return AL_FALSE;
 	}
 
@@ -495,7 +371,7 @@ static ALboolean set_read_alsa( void *ha
 		 "set_read_alsa: handle: %p, phandle: %p", handle, (void*)phandle);
 	ai->setup_read = 1;
 
-	psnd_pcm_hw_params_free(setup);
+	snd_pcm_hw_params_free(setup);
 	return AL_TRUE;
 }
 
@@ -508,7 +384,7 @@ static ALboolean set_write_alsa(void *ha
 	snd_pcm_hw_params_t *setup;
 	snd_pcm_uframes_t buffer_size, period_size;
 	snd_pcm_t *phandle = 0;
-	int err, dir;
+	int err, dir = 0;
 
 	if( (ai == NULL) || (ai->handle == NULL) )
 		return AL_FALSE;
@@ -517,7 +393,7 @@ static ALboolean set_write_alsa(void *ha
 	ai->format      = (unsigned int) AL2ALSAFMT(*fmt);
 	ai->speed       = (unsigned int) *speed;
 	ai->framesize   = (unsigned int) FRAMESIZE(ai->format, ai->channels);
-	ai->bufframesize= (snd_pcm_uframes_t) *bufsiz / ai->framesize * 4;
+	ai->bufframesize= *bufsiz / ai->framesize;
 	ai->periods     = 2;
 
 	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
@@ -526,67 +402,63 @@ static ALboolean set_write_alsa(void *ha
 
 	phandle = ai->handle;
 
-	psnd_pcm_hw_params_malloc(&setup);
-	err = psnd_pcm_hw_params_any(phandle, setup);
-	if(err < 0)
-	{
-		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_write_alsa: Could not query parameters: %s",psnd_strerror(err));
-
-		psnd_pcm_hw_params_free(setup);
+	snd_pcm_hw_params_malloc(&setup);
+	err = snd_pcm_hw_params_any(phandle, setup);
+	if(err < 0)
+	{
+		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
+				"set_write_alsa: Could not query parameters: %s",snd_strerror(err));
+
+		snd_pcm_hw_params_free(setup);
 		return AL_FALSE;
 	}
 
 	/* set the interleaved write format */
-	err = psnd_pcm_hw_params_set_access(phandle, setup, SND_PCM_ACCESS_RW_INTERLEAVED);
+	err = snd_pcm_hw_params_set_access(phandle, setup, SND_PCM_ACCESS_RW_INTERLEAVED);
 	if (err < 0) {
 		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_write_alsa: Could not set access type: %s",psnd_strerror(err));
-		psnd_pcm_hw_params_free(setup);
+				"set_write_alsa: Could not set access type: %s",snd_strerror(err));
+		snd_pcm_hw_params_free(setup);
 		return AL_FALSE;
 	}
 
 	/* set format */
-	err = psnd_pcm_hw_params_set_format(phandle, setup, ai->format);
-	if(err < 0)
-	{
-		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_write_alsa: could not set format: %s",psnd_strerror(err));
-
-		psnd_pcm_hw_params_free(setup);
+	err = snd_pcm_hw_params_set_format(phandle, setup, ai->format);
+	if(err < 0)
+	{
+		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
+				"set_write_alsa: could not set format: %s",snd_strerror(err));
+
+		snd_pcm_hw_params_free(setup);
 		return AL_FALSE;
 	}
 
 
 	/* channels */
-	err = psnd_pcm_hw_params_set_channels(phandle, setup, ai->channels);
+	err = snd_pcm_hw_params_set_channels(phandle, setup, ai->channels);
 	if(err < 0)
 	{
 		unsigned int ch;
-#if (SND_LIB_MAJOR == 0)
-		ch = err = psnd_pcm_hw_params_get_channels(setup);
-#else
-		err = psnd_pcm_hw_params_get_channels(setup, &ch);
-#endif
+		err = snd_pcm_hw_params_get_channels(setup, &ch);
 
 		if (ch != ai->channels) {
 			_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-					"set_write_alsa: could not set channels: %s",psnd_strerror(err));
-
-			psnd_pcm_hw_params_free(setup);
+					"set_write_alsa: could not set channels: %s",snd_strerror(err));
+
+			snd_pcm_hw_params_free(setup);
 			return AL_FALSE;
 		}
 	}
 
 
 	/* sampling rate */
-	err = psnd_pcm_hw_params_set_rate_near(phandle, setup, &ai->speed,
+	err = snd_pcm_hw_params_set_rate_near(phandle, setup, &ai->speed,
                                                NULL);
 	if(err < 0) {
 		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
                          "set_write_alsa: could not set speed: %s",
-                         psnd_strerror(err));
-		psnd_pcm_hw_params_free(setup);
+                         snd_strerror(err));
+		snd_pcm_hw_params_free(setup);
 		return AL_FALSE;
 	} else if (err > 0) {
                 /* sampling rate is in 'err' */
@@ -602,58 +474,70 @@ static ALboolean set_write_alsa(void *ha
                            updating. */
                         _alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
                                  "set_write_alsa: hw speed %u not sane.  failing.", ai->speed);
-                        psnd_pcm_hw_params_free(setup);
+                        snd_pcm_hw_params_free(setup);
                         return AL_FALSE; 
                 }
         }
 
+	err = snd_pcm_hw_params_set_period_size_near(phandle, setup, &ai->bufframesize, NULL);
+	if (err < 0) {
+		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
+				"set_write_alsa: %s, size: %lu, speed: %d",
+				snd_strerror(err), ai->bufframesize, ai->speed);
+		snd_pcm_hw_params_free(setup);
+		return AL_FALSE;
+	}
 
 	/* Set number of periods. Periods used to be called fragments. */
-	err = psnd_pcm_hw_params_set_periods_near(phandle, setup, &ai->periods, 0);
+	err = snd_pcm_hw_params_set_periods_near(phandle, setup, &ai->periods, 0);
 	if (err < 0) {
 		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_write_alsa: %s", psnd_strerror(err));
-		psnd_pcm_hw_params_free(setup);
-		return AL_FALSE;
-	}
-
-	err = psnd_pcm_hw_params_set_buffer_size_near(phandle, setup, &ai->bufframesize);
-	if (err < 0) {
-		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_write_alsa: %s, size: %lu, speed: %d",
-				psnd_strerror(err), ai->bufframesize, ai->speed);
-		psnd_pcm_hw_params_free(setup);
-		return AL_FALSE;
-	}
-
-#if (SND_LIB_MAJOR == 0)
-	buffer_size = psnd_pcm_hw_params_get_buffer_size(setup);
-	period_size = psnd_pcm_hw_params_get_period_size(setup, &dir);
-#else
-	psnd_pcm_hw_params_get_buffer_size(setup, &buffer_size);
-	psnd_pcm_hw_params_get_period_size(setup, &period_size, &dir);
-#endif
+				"set_write_alsa: %s", snd_strerror(err));
+		snd_pcm_hw_params_free(setup);
+		return AL_FALSE;
+	}
+
+	snd_pcm_hw_params_get_buffer_size(setup, &buffer_size);
+	snd_pcm_hw_params_get_period_size(setup, &period_size, &dir);
 
 	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
 			"set_write_alsa (info): Buffersize = %lu (%u)",buffer_size, *bufsiz);
 	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
 			"set_write_alsa (info): Periodsize = %lu", period_size);
 
-	err = psnd_pcm_hw_params(phandle, setup);
-	if(err < 0)
-	{
-		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
-				"set_alsa: %s", psnd_strerror(err));
-		psnd_pcm_hw_params_free(setup);
-		return AL_FALSE;
-	}
-
-	err = psnd_pcm_prepare(phandle);
+	ai->bufframesize = buffer_size;
+
+	/* we put back the actual buffer size because the buffer isn't
+	 * always aligned to the power-of-two, for example, in the case
+	 * of 5.1 output
+	 */
+	*bufsiz = period_size * ai->framesize;
+
+	err = snd_pcm_hw_params(phandle, setup);
+	if(err < 0)
+	{
+		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
+				"set_alsa: %s", snd_strerror(err));
+		snd_pcm_hw_params_free(setup);
+		return AL_FALSE;
+	}
+
+	{
+		snd_pcm_sw_params_t *sw;
+		snd_pcm_uframes_t val;
+		snd_pcm_sw_params_alloca(&sw);
+		snd_pcm_sw_params_current(phandle, sw);
+		snd_pcm_sw_params_set_start_threshold(phandle, sw, 1);
+		snd_pcm_sw_params(phandle, sw);
+	}
+
+
+	err = snd_pcm_prepare(phandle);
 	if(err < 0)
 	{
 		_alDebug(ALD_MAXIMUS,  __FILE__, __LINE__,
-				"set_alsa %s", psnd_strerror(err));
-		psnd_pcm_hw_params_free(setup);
+				"set_alsa %s", snd_strerror(err));
+		snd_pcm_hw_params_free(setup);
 		return AL_FALSE;
 	}
 
@@ -661,7 +545,7 @@ static ALboolean set_write_alsa(void *ha
 		 "set_write_alsa: handle: %p, phandle: %p", handle, (void*)phandle);
 	ai->setup_write = 1;
 
-	psnd_pcm_hw_params_free(setup);
+	snd_pcm_hw_params_free(setup);
 	return AL_TRUE;
 }
 
@@ -692,9 +576,9 @@ void alsa_blitbuffer(void *handle, void 
 	channels= ai->channels;
 	frames  = (snd_pcm_uframes_t) bytes / ai->framesize;
 
-	while(data_len > 0)
-	{
-		err = psnd_pcm_writei(phandle, pdata, frames);
+	while(frames > 0)
+	{
+		err = snd_pcm_writei(phandle, pdata, frames);
 		switch(err)
 		{
 			case -EAGAIN:
@@ -703,7 +587,7 @@ void alsa_blitbuffer(void *handle, void 
 			case -ESTRPIPE:
 				do
 				{
-					err = psnd_pcm_resume(phandle);
+					err = snd_pcm_resume(phandle);
 				} while ( err == -EAGAIN );
 				break;
                         case -EPIPE:
@@ -711,7 +595,7 @@ void alsa_blitbuffer(void *handle, void 
 			default:
                                 if (err<0) {
                                         fprintf(stderr,"alsa_blitbuffer: Could not write audio data to sound device: %s\n",
-                                        	psnd_strerror(err));
+                                        	snd_strerror(err));
                                         break;
                                 }
                                 pdata += err * ai->framesize;
@@ -721,10 +605,10 @@ void alsa_blitbuffer(void *handle, void 
 		}
 		if(err < 0)
 		{
-                        err = psnd_pcm_prepare(phandle);
+                        err = snd_pcm_prepare(phandle);
 			if(err < 0)
 			{
-				const char *serr = psnd_strerror(err);
+				const char *serr = snd_strerror(err);
 
 				_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
                                  "alsa_blitbuffer: %s", serr);
@@ -755,13 +639,13 @@ ALsizei capture_alsa(void *handle,
 	frames = (snd_pcm_uframes_t) bufsize / ai->framesize;
 
 grab:
-	ret = psnd_pcm_readi (phandle, pdata, frames);
+	ret = snd_pcm_readi (phandle, pdata, frames);
 	if (ret < 0) {
 		if (ret == -EAGAIN)
 			return 0;
 		else if (ret == -EPIPE) {
 			fprintf(stderr, "Error, overrun occurred, trying to recover.\n");
-			ret = psnd_pcm_prepare(phandle);
+			ret = snd_pcm_prepare(phandle);
 			if (ret < 0)
 				fprintf(stderr, "Unable to recover: %d\n", ret);
 			else

Places

File openal-0.0.8-alsa-backend-fix.diff of Package openal

Places