The date of releasing 1.0.8

The date of releasing 1.0.8

[Lee, TommyX C]

[-- Attachment #1: Type: text/plain, Size: 76 bytes --]

Please provide the date of ALSA 1.0.8 release. 

 

Thanks,

Tommy


[-- Attachment #2: Type: text/html, Size: 1536 bytes --]

Re: The date of releasing 1.0.8

[Lee Revell]

On Tue, 2005-01-04 at 16:00 -0800, Lee, TommyX C wrote:
> Please provide the date of ALSA 1.0.8 release. 
> 

When it's ready?

Lee



-------------------------------------------------------
The SF.Net email is sponsored by: Beat the post-holiday blues
Get a FREE limited edition SourceForge.net t-shirt from ThinkGeek.
It's fun and FREE -- well, almost....http://www.thinkgeek.com/sfshirt

Re: The date of releasing 1.0.8

[Takashi Iwai]

At Tue, 04 Jan 2005 19:31:25 -0500,
Lee Revell wrote:
> 
> On Tue, 2005-01-04 at 16:00 -0800, Lee, TommyX C wrote:
> > Please provide the date of ALSA 1.0.8 release. 
> > 
> 
> When it's ready?

RC2 will be released soon.
Hopefully 1.0.8-final will get reached in a week or so.


Takashi


-------------------------------------------------------
The SF.Net email is sponsored by: Beat the post-holiday blues
Get a FREE limited edition SourceForge.net t-shirt from ThinkGeek.
It's fun and FREE -- well, almost....http://www.thinkgeek.com/sfshirt

RE: The date of releasing 1.0.8

[Lee, TommyX C]

Hi Takashi,

Thanks for posting me with the 1.0.8 release info.

Please tell me the most stable music players for testing the playback
functionality of ALSA drivers. I am now using XMMS and aplay on RHEL3u3.

Thanks,
Tommy
-----Original Message-----
From: Takashi Iwai [mailto:tiwai@suse.de] 
Sent: Wednesday, January 05, 2005 5:28 AM
To: Lee Revell
Cc: Lee, TommyX C; alsa-devel@lists.sourceforge.net
Subject: Re: [Alsa-devel] The date of releasing 1.0.8

At Tue, 04 Jan 2005 19:31:25 -0500,
Lee Revell wrote:
> 
> On Tue, 2005-01-04 at 16:00 -0800, Lee, TommyX C wrote:
> > Please provide the date of ALSA 1.0.8 release. 
> > 
> 
> When it's ready?

RC2 will be released soon.
Hopefully 1.0.8-final will get reached in a week or so.


Takashi


-------------------------------------------------------
The SF.Net email is sponsored by: Beat the post-holiday blues
Get a FREE limited edition SourceForge.net t-shirt from ThinkGeek.
It's fun and FREE -- well, almost....http://www.thinkgeek.com/sfshirt

Re: The date of releasing 1.0.8

[Frank Barknecht]

Hallo,
Lee, TommyX C hat gesagt: // Lee, TommyX C wrote:

> Please tell me the most stable music players for testing the playback
> functionality of ALSA drivers. I am now using XMMS and aplay on RHEL3u3.

IMO aplay/arecord is the canonical tool to test ALSA. If aplay doesn't
work, something is really wrong.

XMMS however in the past had rather bad ALSA support, at least with
some of the more "difficult" cards like those based on the
ICE-chipsets. I don't know, if this is still valid, but I don't trust
my ogg files to xmms anymore. ;)

XMMS is nice to test OSS emulation compatibility, though. I still like
the good old alsaplayer the most as a general purpose player with good
ALSA support. Another important test is Jack (jackit.sf.net).

Ciao
-- 
 Frank Barknecht                               _ ______footils.org__


-------------------------------------------------------
The SF.Net email is sponsored by: Beat the post-holiday blues
Get a FREE limited edition SourceForge.net t-shirt from ThinkGeek.
It's fun and FREE -- well, almost....http://www.thinkgeek.com/sfshirt

Re: The date of releasing 1.0.8

[Takashi Iwai]

[-- Attachment #1: Type: text/plain, Size: 421 bytes --]

At Tue, 11 Jan 2005 01:21:41 +0100,
Frank Barknecht wrote:
> 
> XMMS however in the past had rather bad ALSA support, at least with
> some of the more "difficult" cards like those based on the
> ICE-chipsets. I don't know, if this is still valid, but I don't trust
> my ogg files to xmms anymore. ;)

Last week I played with xmms a bit, and fixed/improved ALSA output
plugin.  The test patch is attached below.


Takashi

[-- Attachment #2: Type: text/plain, Size: 32006 bytes --]

--- Output/alsa/configure.c-dist	2005-01-09 22:11:33.000000000 +0100
+++ Output/alsa/configure.c	2005-01-09 22:08:07.000000000 +0100
@@ -20,8 +20,8 @@
 #include <stdio.h>
 
 static GtkWidget *configure_win = NULL;
-static GtkWidget *buffer_time_spin, *period_time_spin;
-static GtkWidget *mmap_button, *mixer_card_spin, *softvolume_toggle_button;
+static GtkWidget *buffer_time_spin, *period_time_spin, *thread_buffer_time_spin;
+static GtkWidget *mthread_button, *mmap_button, *mixer_card_spin, *softvolume_toggle_button;
 
 static GtkWidget *devices_combo, *mixer_devices_combo;
 
@@ -36,6 +36,8 @@ static void configure_win_ok_cb(GtkWidge
 	alsa_cfg.pcm_device = GET_CHARS(GTK_COMBO(devices_combo)->entry);
 	alsa_cfg.buffer_time = GET_SPIN_INT(buffer_time_spin);
 	alsa_cfg.period_time = GET_SPIN_INT(period_time_spin);
+	alsa_cfg.thread_buffer_time = GET_SPIN_INT(thread_buffer_time_spin);
+	alsa_cfg.multi_thread = GET_TOGGLE(mthread_button);
 	alsa_cfg.mmap = GET_TOGGLE(mmap_button);
 	alsa_cfg.soft_volume = GET_TOGGLE(softvolume_toggle_button);
 	alsa_cfg.mixer_card = GET_SPIN_INT(mixer_card_spin);
@@ -51,6 +53,8 @@ void alsa_save_config(void)
 	
 	xmms_cfg_write_int(cfgfile, "ALSA", "buffer_time", alsa_cfg.buffer_time);
 	xmms_cfg_write_int(cfgfile, "ALSA", "period_time", alsa_cfg.period_time);
+	xmms_cfg_write_int(cfgfile, "ALSA", "thread_buffer_time", alsa_cfg.thread_buffer_time);
+	xmms_cfg_write_boolean(cfgfile, "ALSA", "multi_thread", alsa_cfg.multi_thread);
 	xmms_cfg_write_boolean(cfgfile,"ALSA","mmap",alsa_cfg.mmap);
 	xmms_cfg_write_string(cfgfile,"ALSA","pcm_device", alsa_cfg.pcm_device);
 	xmms_cfg_write_int(cfgfile, "ALSA", "mixer_card", alsa_cfg.mixer_card);
@@ -212,8 +216,8 @@ void alsa_configure(void)
 	GtkWidget *dev_vbox, *adevice_frame, *adevice_box;
 	GtkWidget *mixer_frame, *mixer_box, *mixer_card_box;
 	GtkWidget *buffer_frame, *buffer_vbox, *buffer_table;
-	GtkWidget *buffer_time_label, *period_time_label;
-	GtkObject *buffer_time_adj, *period_time_adj, *mixer_card_adj;
+	GtkWidget *buffer_time_label, *period_time_label, *thread_buffer_time_label;
+	GtkObject *buffer_time_adj, *period_time_adj, *thread_buffer_time_adj, *mixer_card_adj;
 	GtkWidget *bbox, *ok, *cancel;
 	
 	if (configure_win)
@@ -312,7 +316,7 @@ void alsa_configure(void)
 	
 	gtk_container_set_border_width(GTK_CONTAINER(buffer_vbox), 5);
 
-	buffer_table = gtk_table_new(2, 2, FALSE);
+	buffer_table = gtk_table_new(2, 3, FALSE);
 	gtk_table_set_row_spacings(GTK_TABLE(buffer_table), 5);
 	gtk_table_set_col_spacings(GTK_TABLE(buffer_table), 5);
 	gtk_box_pack_start(GTK_BOX(buffer_vbox), buffer_table, FALSE, FALSE, 0);
@@ -345,6 +349,25 @@ void alsa_configure(void)
 	gtk_table_attach(GTK_TABLE(buffer_table), period_time_spin,
 			 1, 2, 1, 2, 0, 0, 0, 0);
 	
+	thread_buffer_time_label = gtk_label_new(_("Thread buffer time (ms):"));
+	gtk_label_set_justify(GTK_LABEL(thread_buffer_time_label), GTK_JUSTIFY_LEFT);
+	gtk_misc_set_alignment(GTK_MISC(thread_buffer_time_label), 0, 0.5);
+	gtk_table_attach(GTK_TABLE(buffer_table), thread_buffer_time_label,
+			 0, 1, 2, 3, GTK_FILL, 0, 0, 0);
+	thread_buffer_time_adj = gtk_adjustment_new(alsa_cfg.thread_buffer_time,
+						    1000, 1000000, 100, 100, 100);
+	thread_buffer_time_spin = gtk_spin_button_new(GTK_ADJUSTMENT(thread_buffer_time_adj),
+						      8, 0);
+	
+	gtk_widget_set_usize(thread_buffer_time_spin, 60, -1);
+	gtk_table_attach(GTK_TABLE(buffer_table), thread_buffer_time_spin,
+			 1, 2, 2, 3, 0, 0, 0, 0);
+	
+	mthread_button = gtk_check_button_new_with_label(_("Multi-thread mode"));
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mthread_button),
+				     alsa_cfg.multi_thread);
+	gtk_box_pack_start(GTK_BOX(buffer_vbox), mthread_button, FALSE, FALSE, 0);
+	
 	mmap_button = gtk_check_button_new_with_label(_("Mmap mode"));
 	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mmap_button),
 				     alsa_cfg.mmap);
--- Output/alsa/audio.c-dist	2005-01-11 17:57:21.374002224 +0100
+++ Output/alsa/audio.c	2005-01-11 17:58:04.891386576 +0100
@@ -17,36 +17,56 @@
  *  You should have received a copy of the GNU 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.
+ *
+ *
+ *  CHANGES
+ *
+ *  2005.01.05  Takashi Iwai <tiwai@suse.de>
+ *	Impelemented the multi-threaded mode with an audio-thread.
+ *	Many fixes and cleanups.
  */
 
 #include "alsa.h"
 #include <ctype.h>
+#include <pthread.h>
 #include <libxmms/xconvert.h>
 
 static snd_pcm_t		*alsa_pcm 	    = NULL;
-static snd_pcm_status_t		*alsa_status 	    = NULL;
-static snd_pcm_channel_area_t   *areas              = NULL;
 
 static snd_output_t		*logs 		    = NULL;
 
-static int 			 alsa_bps 	    = 0;
-static guint64			 alsa_total_written = 0;
+static guint64			 alsa_total_written = 0;	/* input bytes */
+static guint64			 alsa_hw_written    = 0;	/* output bytes */
+static gint			 output_time_offset = 0;
+
+/* device buffer/period sizes in bytes */
+static int hw_buffer_size, hw_period_size;		/* in output bytes */
+static int hw_buffer_size_in, hw_period_size_in;	/* in input bytes */
 
 /* Set/Get volume */
 static snd_mixer_elem_t 	*pcm_element 	    = NULL;
 static snd_mixer_t 		*mixer 		    = NULL;
 
-static gboolean mmap, force_start, going, paused;
+static gboolean mmap, going, paused, multi_thread;
 
-static gpointer buffer;
+static gboolean alsa_can_pause;
+
+/* for audio thread */
+static pthread_t audio_thread;		/* audio loop thread */
+static int thread_buffer_size;		/* size of intermediate buffer in bytes */
+static char *thread_buffer;		/* audio intermediate buffer */
+static int rd_index, wr_index;		/* current read/write position in int-buffer */
+static gboolean pause_request;		/* pause status currently requested */
+static gint flush_request;		/* flush status (time) currently requested */
 
-static int alsa_can_pause;
 
 struct snd_format {
 	unsigned int rate;
 	unsigned int channels;
 	snd_pcm_format_t format;
 	AFormat xmms_format;
+	int sample_bits;
+	int bps;
 };
 
 static struct snd_format *inputf = NULL;
@@ -55,7 +75,7 @@ static struct snd_format *outputf = NULL
 
 static int alsa_setup(struct snd_format *f);
 static void alsa_mmap_audio(char *data, int length);
-static void alsa_write_audio(gpointer data, int length);
+static void alsa_write_audio(char *data, int length);
 
 static struct snd_format * snd_format_from_xmms(AFormat fmt, int rate, int channels);
 
@@ -71,22 +91,10 @@ static const struct {
 } format_table[] =
 {{FMT_S16_LE, SND_PCM_FORMAT_S16_LE},
  {FMT_S16_BE, SND_PCM_FORMAT_S16_BE},
- {FMT_S16_NE,
-#ifdef WORDS_BIGENDIAN
-  SND_PCM_FORMAT_S16_BE
-#else
-  SND_PCM_FORMAT_S16_LE
-#endif
- },
+ {FMT_S16_NE, SND_PCM_FORMAT_S16},
  {FMT_U16_LE, SND_PCM_FORMAT_U16_LE},
  {FMT_U16_BE, SND_PCM_FORMAT_U16_BE},
- {FMT_U16_NE,
-#ifdef WORDS_BIGENDIAN
-  SND_PCM_FORMAT_U16_BE
-#else
-  SND_PCM_FORMAT_U16_LE
-#endif
- },
+ {FMT_U16_NE, SND_PCM_FORMAT_U16},
  {FMT_U8, SND_PCM_FORMAT_U8},
  {FMT_S8, SND_PCM_FORMAT_S8},
 };
@@ -106,176 +114,9 @@ static void debug(char *str, ...)
 	}
 }
 
-int alsa_playing(void)
-{
-	if (!going || paused)
-		return FALSE;
-
-	return(snd_pcm_state(alsa_pcm) == SND_PCM_STATE_RUNNING);
-}
-
-static void xrun_recover(void)
-{
-	int err;
-
-	if (alsa_cfg.debug)
-	{
-		snd_pcm_status_alloca(&alsa_status);
-		if ((err = snd_pcm_status(alsa_pcm, alsa_status)) < 0)
-			g_warning("xrun_recover(): snd_pcm_status() failed");
-		else
-		{
-			printf("Status:\n");
-			snd_pcm_status_dump(alsa_status, logs);
-		}
-	}
-
-	if (snd_pcm_state(alsa_pcm) == SND_PCM_STATE_XRUN)
-	{
-		if ((err = snd_pcm_prepare(alsa_pcm)) < 0)
-			g_warning("xrun_recover(): snd_pcm_prepare() failed.");
-	}
-}
-
-static snd_pcm_sframes_t alsa_get_avail(void)
-{
-	snd_pcm_sframes_t ret;
-	if ((ret = snd_pcm_avail_update(alsa_pcm)) == -EPIPE)
-		xrun_recover();
-	else if (ret < 0)
-	{
-		g_warning("alsa_get_avail(): snd_pcm_avail_update() failed: %s",
-			  snd_strerror(-ret));
-		return 0;
-	}
-	else
-		return ret;
-	if ((ret = snd_pcm_avail_update(alsa_pcm)) < 0)
-	{
-		g_warning("alsa_get_avail(): snd_pcm_avail_update() failed: %s",
-			  snd_strerror(-ret));
-		return 0;
-	}
-	return ret;
-}
-
-int alsa_free(void)
-{
-	if (paused)
-		return 0;
-	else
-	{
-		int err;
-		if (force_start &&
-		    snd_pcm_state(alsa_pcm) == SND_PCM_STATE_PREPARED)
-		{
-			if ((err = snd_pcm_start(alsa_pcm)) < 0)
-				g_warning("alsa_free(): snd_pcm_start() "
-					  "failed: %s", snd_strerror(-err));
-			else
-				debug("Stream started");
-		}
-		force_start = TRUE;
-
-		return snd_pcm_frames_to_bytes(alsa_pcm, alsa_get_avail());
-	}
-}
-
-void alsa_pause(short p)
-{
-	debug("alsa_pause");
-	if (p)
-		paused = TRUE;
-
-	if (alsa_can_pause)
-		snd_pcm_pause(alsa_pcm, p);
-	else if (p)
-		snd_pcm_drop(alsa_pcm);
-
-	if (!p)
-		paused = FALSE;
-}
-
-void alsa_close(void)
-{
-	int err, started;
-
-	debug("Closing device");
-
-	started = going;
-	going = 0;
-
-	pcm_element = NULL;
-
-	if (mixer)
-	{
-		snd_mixer_close(mixer);
-		mixer = NULL;
-	}
-
-	if (alsa_pcm != NULL)
-	{
-		if (started)
-			if ((err = snd_pcm_drop(alsa_pcm)) < 0)
-				g_warning("alsa_pcm_drop() failed: %s",
-					  snd_strerror(-err));
-
-		if ((err = snd_pcm_close(alsa_pcm)) < 0)
-			g_warning("alsa_pcm_close() failed: %s",
-				  snd_strerror(-err));
-		alsa_pcm = NULL;
-	}
-
-	if (mmap) {
-		g_free(buffer);
-		buffer = NULL;
-
-		g_free(areas);
-		areas = NULL;
-	}
-
-	xmms_convert_buffers_destroy(convertb);
-	convertb = NULL;
-	g_free(inputf);
-	inputf = NULL;
-	g_free(effectf);
-	effectf = NULL;
-
-	alsa_save_config();
-
-	debug("Device closed");
-}
-
-static void alsa_reopen(struct snd_format *f)
-{
-	unsigned int tmp = alsa_get_written_time();
-
-	if (alsa_pcm != NULL)
-	{
-		snd_pcm_close(alsa_pcm);
-		alsa_pcm = NULL;
-	}
-
-	if (mmap) {
-		g_free(buffer);
-		buffer = NULL;
-		
-		g_free(areas);
-		areas = NULL;
-	}
-
-	if (alsa_setup(f) < 0)
-		g_warning("Failed to reopen the audio device");
-
-	alsa_total_written = tmp;
-	snd_pcm_prepare(alsa_pcm);
-}
-
-void alsa_flush(int time)
-{
-	alsa_total_written = (guint64) time * alsa_bps / 1000;
-}
-
+/*
+ * mixer stuff
+ */
 static void parse_mixer_name(char *str, char **name, int *index)
 {
 	char *end;
@@ -337,7 +178,7 @@ int alsa_get_mixer(snd_mixer_t **mixer, 
 }
 	
 
-snd_mixer_elem_t* alsa_get_mixer_elem(snd_mixer_t *mixer, char *name, int index)
+static snd_mixer_elem_t* alsa_get_mixer_elem(snd_mixer_t *mixer, char *name, int index)
 {
 	snd_mixer_selem_id_t *selem_id;
 	snd_mixer_elem_t* elem;
@@ -353,7 +194,7 @@ snd_mixer_elem_t* alsa_get_mixer_elem(sn
 	return elem;
 }
 
-int alsa_setup_mixer(void)
+static int alsa_setup_mixer(void)
 {
 	char *name;
 	long int a, b;
@@ -406,6 +247,15 @@ int alsa_setup_mixer(void)
 	return 0;
 }
 
+static void alsa_cleanup_mixer(void)
+{
+	pcm_element = NULL;
+	if (mixer) {
+		snd_mixer_close(mixer);
+		mixer = NULL;
+	}
+}
+
 void alsa_get_volume(int *l, int *r)
 {
 	static gboolean first = TRUE;
@@ -461,25 +311,216 @@ void alsa_set_volume(int l, int r)
 }
 
 
+/*
+ * audio stuff
+ */
+
+int alsa_playing(void)
+{
+	if (!going || paused || alsa_pcm == NULL)
+		return FALSE;
+
+	return(snd_pcm_state(alsa_pcm) == SND_PCM_STATE_RUNNING);
+}
+
+
+/* handle generic errors */
+static int alsa_handle_error(int err)
+{
+	switch (err) {
+	case -EPIPE: /* XRUN */
+		if (alsa_cfg.debug) {
+			snd_pcm_status_t *alsa_status;
+			snd_pcm_status_alloca(&alsa_status);
+			if (snd_pcm_status(alsa_pcm, alsa_status) < 0)
+				g_warning("xrun_recover(): snd_pcm_status() failed");
+			else {
+				printf("Status:\n");
+				snd_pcm_status_dump(alsa_status, logs);
+			}
+		}
+		return snd_pcm_prepare(alsa_pcm);
+
+	case -ESTRPIPE: /* suspend */
+		while ((err = snd_pcm_resume(alsa_pcm)) == -EAGAIN)
+			sleep(1);	/* wait until suspend flag is released */
+		if (err < 0) {
+			g_warning("suspend_recover(): snd_pcm_resume() failed.");
+			return snd_pcm_prepare(alsa_pcm);
+		}
+		break;
+	}
+
+	return err;
+}
+
+/* update and get the available space on h/w buffer (in frames) */
+static snd_pcm_sframes_t alsa_get_avail(void)
+{
+	snd_pcm_sframes_t ret;
+
+	if (alsa_pcm == NULL)
+		return 0;
+
+	while ((ret = snd_pcm_avail_update(alsa_pcm)) < 0) {
+		ret = alsa_handle_error(ret);
+		if (ret < 0) {
+			g_warning("alsa_get_avail(): snd_pcm_avail_update() failed: %s",
+				  snd_strerror(-ret));
+			return 0;
+		}
+	}
+	return ret;
+}
+
+/* do pause operation */
+static void alsa_do_pause(gboolean p)
+{
+	if (paused == p)
+		return;
+
+	if (alsa_pcm) {
+		if (alsa_can_pause) {
+			snd_pcm_pause(alsa_pcm, p);
+		} else if (p) {
+			snd_pcm_drop(alsa_pcm);
+			snd_pcm_prepare(alsa_pcm);
+		}
+	}
+	paused = p;
+}
+
+void alsa_pause(short p)
+{
+	debug("alsa_pause");
+	if (multi_thread)
+		pause_request = p;
+	else
+		alsa_do_pause(p);
+}
+
+/* close PCM and release associated resources */
+static void alsa_close_pcm(void)
+{
+	if (alsa_pcm) {
+		int err;
+		snd_pcm_drop(alsa_pcm);
+		if ((err = snd_pcm_close(alsa_pcm)) < 0)
+			g_warning("alsa_pcm_close() failed: %s",
+				  snd_strerror(-err));
+		alsa_pcm = NULL;
+	}
+}
+
+/* reopen ALSA PCM */
+static int alsa_reopen(struct snd_format *f)
+{
+	/* remember the current position */
+	output_time_offset += (alsa_hw_written * 1000) / outputf->bps;
+	alsa_hw_written = 0;
+
+	alsa_close_pcm();
+
+	return alsa_setup(f);
+}
+
+/* do flush (drop) operation */
+static void alsa_do_flush(int time)
+{
+	if (alsa_pcm) {
+		snd_pcm_drop(alsa_pcm);
+		snd_pcm_prepare(alsa_pcm);
+	}
+	/* correct the offset */
+	output_time_offset = time;
+	alsa_total_written = (guint64) time * inputf->bps / 1000;
+	rd_index = wr_index = alsa_hw_written = 0;
+}
+
+void alsa_flush(int time)
+{
+	if (multi_thread) {
+		flush_request = time;
+		while (flush_request != -1)
+			xmms_usleep(10000);
+	} else
+		alsa_do_flush(time);
+}
+
+void alsa_close(void)
+{
+	if (! going)
+		return;
+
+	debug("Closing device");
+
+	going = 0;
+
+	if (multi_thread)
+		pthread_join(audio_thread, NULL);
+	else
+		alsa_close_pcm();
+
+	alsa_cleanup_mixer();
+
+	xmms_convert_buffers_destroy(convertb);
+	convertb = NULL;
+	g_free(inputf);
+	inputf = NULL;
+	g_free(effectf);
+	effectf = NULL;
+	g_free(outputf);
+	outputf = NULL;
+
+	alsa_save_config();
+
+	if (alsa_cfg.debug)
+		snd_output_close(logs);
+	debug("Device closed");
+}
+
+/* return the size of audio data filled in the audio thread buffer */
+static int get_thread_buffer_filled(void)
+{
+	if (wr_index >= rd_index)
+		return wr_index - rd_index;
+	return thread_buffer_size - (rd_index - wr_index);
+}
+
+/* get the free space on buffer */
+int alsa_free(void)
+{
+	int result = 0;
+	if (multi_thread)
+		result = thread_buffer_size - get_thread_buffer_filled() - 1;
+	else if (! paused && alsa_pcm)
+		result = snd_pcm_frames_to_bytes(alsa_pcm, alsa_get_avail());
+	return result;
+}
+
 int alsa_get_output_time(void)
 {
 	snd_pcm_sframes_t delay;
-	ssize_t db = 0;
+	guint64 bytes = 0;
 
-	if (!going)
+	if (!going || alsa_pcm == NULL)
 		return 0;
 
-	if (!snd_pcm_delay(alsa_pcm, &delay))
-		db = snd_pcm_frames_to_bytes(alsa_pcm, delay);
-	
-	if (db < alsa_total_written)
-		return ((alsa_total_written - db) * 1000 / alsa_bps);
-	return 0;
+	if (!snd_pcm_delay(alsa_pcm, &delay)) {
+		bytes = snd_pcm_frames_to_bytes(alsa_pcm, delay);
+		if (alsa_hw_written < bytes)
+			bytes = 0;
+		else
+			bytes = alsa_hw_written - bytes;
+	}
+	return output_time_offset + (bytes * 1000) / outputf->bps;
 }
 
 int alsa_get_written_time(void)
 {
-	return (alsa_total_written * 1000 / alsa_bps);
+	if (!going)
+		return 0;
+	return (alsa_total_written * 1000) / inputf->bps;
 }
 
 #define STEREO_ADJUST(type, type2, endian)					\
@@ -584,53 +625,47 @@ static void volume_adjust(void* data, in
 }
 
 
-void alsa_write(gpointer data, int length)
+/* transfer data to audio h/w; length is given in bytes
+ *
+ * data can be modified via effect plugin, rate conversion or
+ * software volume before passed to audio h/w
+ */
+static void alsa_do_write(gpointer data, int length)
 {
-	EffectPlugin *ep;
+	EffectPlugin *ep = NULL;
+	int new_freq;
+	int new_chn;
+	AFormat f;
 
 	if (paused)
 		return;
 
-	force_start = FALSE;
-
-	if (effects_enabled() && (ep = get_current_effect_plugin()))
-	{
-		int new_freq = inputf->rate;
-		int new_chn = inputf->channels;
-		AFormat f = inputf->xmms_format;
+	new_freq = inputf->rate;
+	new_chn = inputf->channels;
+	f = inputf->xmms_format;
 		
-		if (ep->query_format)
-		{
-			ep->query_format(&f, &new_freq, &new_chn);
-			
-			if (f != effectf->xmms_format ||
-			    new_freq != effectf->rate ||
-			    new_chn != effectf->channels)
-			{
-				debug("Changing audio format for effect plugin");
-
-				g_free(effectf);
-				effectf = snd_format_from_xmms(f, new_freq,
-							       new_chn);
-				alsa_reopen(effectf);
-			}
-			
-		}
+	if (effects_enabled() && (ep = get_current_effect_plugin()) &&
+	    ep->query_format)
+		ep->query_format(&f, &new_freq, &new_chn);
 	
+	if (f != effectf->xmms_format || new_freq != effectf->rate ||
+	    new_chn != effectf->channels) {
+		debug("Changing audio format for effect plugin");
+		g_free(effectf);
+		effectf = snd_format_from_xmms(f, new_freq, new_chn);
+		if (alsa_reopen(effectf) < 0) {
+			/* fatal error... */
+			alsa_close();
+			return;
+		}
+	}
+
+	if (ep) {
 		length = ep->mod_samples(&data, length,
 					 inputf->xmms_format,
 					 inputf->rate,
 					 inputf->channels);
 	}
-	else if (effectf)
-	{
-		g_free(effectf);
-		effectf = NULL;
-		effectf = snd_format_from_xmms(inputf->xmms_format,
-					       inputf->rate,
-					       inputf->channels);
-		alsa_reopen(inputf);
-	}
 
 	if (alsa_convert_func != NULL)
 		length = alsa_convert_func(convertb, &data, length);
@@ -650,7 +685,31 @@ void alsa_write(gpointer data, int lengt
 		alsa_write_audio(data, length);
 }
 
-static void alsa_write_audio(gpointer data, int length)
+/* write callback */
+void alsa_write(gpointer data, int length)
+{
+	if (multi_thread) {
+		int cnt;
+		char *src = (char *)data;
+
+		alsa_total_written += length;
+		while (length > 0) {
+			int wr;
+			cnt = MIN(length, thread_buffer_size - wr_index);
+			memcpy(thread_buffer + wr_index, src, cnt);
+			wr = (wr_index + cnt) % thread_buffer_size;
+			wr_index = wr;
+			length -= cnt;
+			src += cnt;
+		}
+	} else {
+		alsa_do_write(data, length);
+		alsa_total_written += length;
+	}
+}
+
+/* transfer data to audio h/w via normal write */
+static void alsa_write_audio(char *data, int length)
 {
 	snd_pcm_sframes_t written_frames;
 
@@ -663,73 +722,153 @@ static void alsa_write_audio(gpointer da
 		{
 			int written = snd_pcm_frames_to_bytes(alsa_pcm,
 							      written_frames);
-			alsa_total_written += written;
 			length -= written;
-			data = (char*) data + written;
+			data += written;
+			alsa_hw_written += written;
 		}
-		else if (written_frames == -EPIPE)
-			xrun_recover();
-		else
-		{
-			g_warning("alsa_write_audio(): write error: %s",
-				  snd_strerror(-written_frames));
-			break;
+		else {
+			int err = alsa_handle_error((int)written_frames);
+			if (err < 0) {
+				g_warning("alsa_write_audio(): write error: %s",
+					  snd_strerror(-err));
+				break;
+			}
 		}
 	}
 }
 
+/* transfer data to audio h/w via mmap
+ *
+ * basically, it makes sense only in the single thread mode.
+ * also, don't expect too much efficiency over mmap...
+ */
 static void alsa_mmap_audio(char *data, int length)
 {
-	int cnt = 0, err;
-	snd_pcm_uframes_t offset, frames, frame;
-	const snd_pcm_channel_area_t *chan_areas = areas;
-	int channel_offset = 0, channel;
-	ssize_t sample_size, offset_bytes, step;
+	int cnt, err;
+	snd_pcm_uframes_t offset, frames;
+	const snd_pcm_channel_area_t *chan_areas;
+	snd_pcm_channel_area_t src_area;
+	int ch, channels, sample_bits;
+
+	if (snd_pcm_state(alsa_pcm) == SND_PCM_STATE_XRUN)
+		alsa_handle_error(-EPIPE);
 
+	/* need to call this before snd_pcm_mmap_begin() */
 	alsa_get_avail();
 
+	channels = outputf->channels;
+	sample_bits = outputf->sample_bits;
 	while (length > 0)
 	{
 		frames = snd_pcm_bytes_to_frames(alsa_pcm, length);
-		if ((err = snd_pcm_mmap_begin(alsa_pcm, &chan_areas, &offset, &frames) < 0))
+		if ((err = snd_pcm_mmap_begin(alsa_pcm, &chan_areas, &offset, &frames) < 0)) {
 			g_warning("alsa_mmap_audio(): snd_pcm_mmap_begin() "
 				  "failed: %s", snd_strerror(-err));
+			break;
+		}
 
 		cnt = snd_pcm_frames_to_bytes(alsa_pcm, frames);
 
-		sample_size = snd_pcm_samples_to_bytes(alsa_pcm, 1);
-		step = chan_areas[0].step / 8;
-		offset_bytes = offset * step;
-
-		for (frame = 0; frame < frames; frame++)
-		{
-			for (channel = 0; channel < outputf->channels; channel++)
-			{
-				char *ptr = chan_areas[channel].addr;
-				memcpy(ptr + chan_areas[channel].first / 8 +
-				       offset_bytes,
-				       data + channel_offset, sample_size);
-				channel_offset += sample_size;
-			}
-			offset_bytes += step;
+		src_area.addr = data;
+		src_area.first = 0;
+		src_area.step = channels * sample_bits;
+		for (ch = 0; ch < channels; ch++) {
+			snd_pcm_area_copy(&chan_areas[ch], offset,
+					  &src_area, 0, frames, outputf->format);
+			src_area.first += sample_bits;
 		}
 			
 		err = snd_pcm_mmap_commit(alsa_pcm, offset, frames);
-		if (err == -EPIPE)
-			xrun_recover();
-		else if (err < 0)
-			g_warning("alsa_mmap_audio(): snd_pcm_mmap_commit() "
-				  "failed: %s", snd_strerror(-err));
-		else if (err != frames)
-			g_warning("alsa_mmap_audio(): snd_pcm_mmap_commit "
-				  "returned %d, expected %d", err, (int)frames);
-		
-		alsa_total_written += cnt;
-		
+		if (err < 0) {
+			err = alsa_handle_error(err);
+			if (err < 0)
+				g_warning("alsa_mmap_audio(): snd_pcm_mmap_commit() "
+					  "failed: %s", snd_strerror(-err));
+		}
+		else {
+			if (err != frames)
+				g_warning("alsa_mmap_audio(): snd_pcm_mmap_commit "
+					  "returned %d, expected %d", err, (int)frames);
+			data += cnt;
+			length -= cnt;
+			alsa_hw_written += cnt;
+		}
+	}
+
+	/* PCM isn't started automatically in the case of mmap mode, so
+	 * we need to trigger manually
+	 */
+	if (snd_pcm_state(alsa_pcm) == SND_PCM_STATE_PREPARED) {
+		if (alsa_hw_written >= hw_period_size)
+			snd_pcm_start(alsa_pcm);
+	}
+}
+
+/* transfer audio data from thread buffer to h/w */
+static void alsa_write_out_thread_data(void)
+{
+	gint length, cnt, avail;
+
+	length = MIN(hw_period_size_in, get_thread_buffer_filled());
+	avail = snd_pcm_frames_to_bytes(alsa_pcm, alsa_get_avail());
+	length = MIN(length, avail);
+	while (length > 0) {
+		int rd;
+		cnt = MIN(length, thread_buffer_size - rd_index);
+		alsa_do_write(thread_buffer + rd_index, cnt);
+		rd = (rd_index + cnt) % thread_buffer_size;
+		rd_index = rd;
 		length -= cnt;
 	}
 }
 
+/* audio thread loop */
+/* FIXME: proper lock? */
+static void *alsa_loop(void *arg)
+{
+	int npfds = snd_pcm_poll_descriptors_count(alsa_pcm);
+	struct pollfd *pfds;
+	unsigned short *revents;
+
+	if (npfds <= 0)
+		goto _error;
+	pfds = alloca(sizeof(*pfds) * npfds);
+	revents = alloca(sizeof(*revents) * npfds);
+	while (going && alsa_pcm) {
+		if (! paused && get_thread_buffer_filled() > hw_period_size_in) {
+			snd_pcm_poll_descriptors(alsa_pcm, pfds, npfds);
+			if (poll(pfds, npfds, 10) > 0) { 
+				/* need to check revents.  poll() with dmix returns
+				 * a postive value even if no data is available
+				 */
+				int i;
+				snd_pcm_poll_descriptors_revents(alsa_pcm, pfds, npfds, revents);
+				for (i = 0; i < npfds; i++)
+					if (revents[i] & POLLOUT) {
+						alsa_write_out_thread_data();
+						break;
+					}
+			}
+		} else
+			xmms_usleep(10000);
+
+		if (pause_request != paused)
+			alsa_do_pause(pause_request);
+
+		if (flush_request != -1) {
+			alsa_do_flush(flush_request);
+			flush_request = -1;
+		}
+	}
+
+ _error:
+	alsa_close_pcm();
+	g_free(thread_buffer);
+	thread_buffer = NULL;
+	pthread_exit(NULL);
+}
+
+/* open callback */
 int alsa_open(AFormat fmt, int rate, int nch)
 {
 	debug("Opening device");
@@ -751,13 +890,30 @@ int alsa_open(AFormat fmt, int rate, int
 
 	convertb = xmms_convert_buffers_new();
 	
-	alsa_total_written = 0;
+	output_time_offset = 0;
+	alsa_total_written = alsa_hw_written = 0;
 	going = TRUE;
 	paused = FALSE;
-	force_start = FALSE;
 	
-	snd_pcm_prepare(alsa_pcm);
+	multi_thread = alsa_cfg.multi_thread;
+	debug("ALSA: multi_thread = %d\n", multi_thread);
 	
+	if (multi_thread) {
+		thread_buffer_size = (guint64)alsa_cfg.thread_buffer_time * inputf->bps / 1000;
+		if (thread_buffer_size < hw_buffer_size)
+			thread_buffer_size = hw_buffer_size * 2;
+		if (thread_buffer_size < 8192)
+			thread_buffer_size = 8192;
+		thread_buffer_size += hw_buffer_size;
+		thread_buffer_size -= thread_buffer_size % hw_period_size;
+		thread_buffer = g_malloc0(thread_buffer_size);
+		wr_index = rd_index = 0;
+		pause_request = FALSE;
+		flush_request = -1;
+
+		pthread_create(&audio_thread, NULL, alsa_loop, NULL);
+	}
+
 	return 1;
 }
 
@@ -787,6 +943,8 @@ static struct snd_format * snd_format_fr
 
 	f->rate = rate;
 	f->channels = channels;
+	f->sample_bits = snd_pcm_format_physical_width(f->format);
+	f->bps = (rate * f->sample_bits * channels) >> 3;
 
 	return f;
 }
@@ -806,7 +964,7 @@ static int alsa_setup(struct snd_format 
 	int err;
 	snd_pcm_hw_params_t *hwparams;
 	snd_pcm_sw_params_t *swparams;
-	int alsa_buffer_time, bits_per_sample;
+	int alsa_buffer_time;
 	unsigned int alsa_period_time;
 	snd_pcm_uframes_t alsa_buffer_size, alsa_period_size;
 
@@ -816,9 +974,8 @@ static int alsa_setup(struct snd_format 
 	alsa_stereo_convert_func = NULL;
 	alsa_frequency_convert_func = NULL;
 
-	outputf = snd_format_from_xmms(effectf->xmms_format,
-				       effectf->rate,
-				       effectf->channels);
+	g_free(outputf);
+	outputf = snd_format_from_xmms(f->xmms_format, f->rate, f->channels);
 
 	debug("Opening device: %s", alsa_cfg.pcm_device);
 	/* FIXME: Can snd_pcm_open() return EAGAIN? */
@@ -829,10 +986,14 @@ static int alsa_setup(struct snd_format 
 		g_warning("alsa_setup(): Failed to open pcm device (%s): %s",
 			  alsa_cfg.pcm_device, snd_strerror(-err));
 		alsa_pcm = NULL;
+		g_free(outputf);
+		outputf = NULL;
 		return -1;
 	}
-	snd_pcm_nonblock(alsa_pcm, FALSE);
 
+	/* doesn't care about non-blocking */
+	/* snd_pcm_nonblock(alsa_pcm, 0); */
+	
 	if (alsa_cfg.debug)
 	{
 		snd_pcm_info_t *info;
@@ -894,17 +1055,17 @@ static int alsa_setup(struct snd_format 
 				break;
 			}
 		}
-		if (outputf->format != effectf->format)
+		if (outputf->format != f->format)
 		{
 			outputf->xmms_format =
 				format_from_alsa(outputf->format);
 			debug("Converting format from %d to %d",
-			      effectf->xmms_format, outputf->xmms_format);
+			      f->xmms_format, outputf->xmms_format);
 			if (outputf->xmms_format < 0)
 				return -1;
 			alsa_convert_func =
 				xmms_convert_get_func(outputf->xmms_format,
-						      effectf->xmms_format);
+						      f->xmms_format);
 			if (alsa_convert_func == NULL)
 				return -1;
 		}
@@ -918,14 +1079,14 @@ static int alsa_setup(struct snd_format 
 	}
 
 	snd_pcm_hw_params_set_channels_near(alsa_pcm, hwparams, &outputf->channels);
-	if (outputf->channels != effectf->channels)
+	if (outputf->channels != f->channels)
 	{
 		debug("Converting channels from %d to %d",
-		      effectf->channels, outputf->channels);
+		      f->channels, outputf->channels);
 		alsa_stereo_convert_func =
 			xmms_convert_get_channel_func(outputf->xmms_format,
 						      outputf->channels,
-						      effectf->channels);
+						      f->channels);
 		if (alsa_stereo_convert_func == NULL)
 			return -1;
 	}
@@ -936,10 +1097,10 @@ static int alsa_setup(struct snd_format 
 		g_warning("alsa_setup(): No usable samplerate available.");
 		return -1;
 	}
-	if (outputf->rate != effectf->rate)
+	if (outputf->rate != f->rate)
 	{
 		debug("Converting samplerate from %d to %d",
-		      effectf->rate, outputf->rate);
+		      f->rate, outputf->rate);
 		alsa_frequency_convert_func =
 			xmms_convert_get_frequency_func(outputf->xmms_format,
 							outputf->channels);
@@ -947,6 +1108,9 @@ static int alsa_setup(struct snd_format 
 			return -1;
 	}
 
+	outputf->sample_bits = snd_pcm_format_physical_width(outputf->format);
+	outputf->bps = (outputf->rate * outputf->sample_bits * outputf->channels) >> 3;
+
 	alsa_buffer_time = alsa_cfg.buffer_time * 1000;
 	if ((err = snd_pcm_hw_params_set_buffer_time_near(alsa_pcm, hwparams,
 							  &alsa_buffer_time, 0)) < 0)
@@ -1011,27 +1175,25 @@ static int alsa_setup(struct snd_format 
 		snd_pcm_dump(alsa_pcm, logs);
 	}
 
-	bits_per_sample = snd_pcm_format_physical_width(outputf->format);
-	alsa_bps = (outputf->rate * bits_per_sample * outputf->channels) >> 3;
-
-	if (mmap)
-	{
-		int chn;
-		buffer = g_malloc(alsa_period_size * bits_per_sample / 8 * outputf->channels);
-		areas = g_malloc0(outputf->channels * sizeof(snd_pcm_channel_area_t));
-		
-		for (chn = 0; chn < outputf->channels; chn++)
-		{
-			areas[chn].addr = buffer;
-			areas[chn].first = chn * bits_per_sample;
-			areas[chn].step = outputf->channels * bits_per_sample;
-		}
+	hw_buffer_size = snd_pcm_frames_to_bytes(alsa_pcm, alsa_buffer_size);
+	hw_period_size = snd_pcm_frames_to_bytes(alsa_pcm, alsa_period_size);
+	if (inputf->bps != outputf->bps) {
+		hw_buffer_size_in = ((guint64)hw_buffer_size * inputf->bps +
+				     outputf->bps/2) / outputf->bps;
+		hw_period_size_in = ((guint64)hw_period_size * inputf->bps +
+				     outputf->bps/2) / outputf->bps;
+	} else {
+		hw_buffer_size_in = hw_buffer_size;
+		hw_period_size_in = hw_period_size;
 	}
 
 	debug("Device setup: buffer time: %i, size: %i.", alsa_buffer_time,
-	      snd_pcm_frames_to_bytes(alsa_pcm, alsa_buffer_size));
+	      hw_buffer_size);
+	debug("Device setup: period time: %i, size: %i.", alsa_period_time,
+	      hw_period_size);
 	debug("bits per sample: %i; frame size: %i; Bps: %i",
-	      bits_per_sample, snd_pcm_frames_to_bytes(alsa_pcm, 1), alsa_bps);
+	      snd_pcm_format_physical_width(outputf->format),
+	      snd_pcm_frames_to_bytes(alsa_pcm, 1), outputf->bps);
 
 	return 0;
 }
--- Output/alsa/init.c-dist	2005-01-09 22:11:33.000000000 +0100
+++ Output/alsa/init.c	2005-01-09 22:09:40.000000000 +0100
@@ -29,8 +29,10 @@ void alsa_init(void)
 	memset(&alsa_cfg, 0, sizeof (alsa_cfg));
 	alsa_cfg.buffer_time = 500;
 	alsa_cfg.period_time = 50;
+	alsa_cfg.thread_buffer_time = 3000;
 	alsa_cfg.debug = 0;
-	alsa_cfg.mmap = 1;
+	alsa_cfg.multi_thread = 1;
+	alsa_cfg.mmap = 0;
 	alsa_cfg.vol.left = 100;
 	alsa_cfg.vol.right = 100;
 
@@ -44,8 +46,9 @@ void alsa_init(void)
 	xmms_cfg_read_int(cfgfile, "ALSA", "mixer_card", &alsa_cfg.mixer_card);
 	xmms_cfg_read_int(cfgfile, "ALSA", "buffer_time", &alsa_cfg.buffer_time);
 	xmms_cfg_read_int(cfgfile, "ALSA", "period_time", &alsa_cfg.period_time);
+	xmms_cfg_read_int(cfgfile, "ALSA", "thread_buffer_time", &alsa_cfg.thread_buffer_time);
+	xmms_cfg_read_boolean(cfgfile, "ALSA", "multi_thread", &alsa_cfg.multi_thread);
 	xmms_cfg_read_boolean(cfgfile, "ALSA", "mmap", &alsa_cfg.mmap);
-	xmms_cfg_read_int(cfgfile, "ALSA", "period_time", &alsa_cfg.period_time);
 	xmms_cfg_read_boolean(cfgfile, "ALSA", "soft_volume",
 			      &alsa_cfg.soft_volume);
 	xmms_cfg_read_int(cfgfile, "ALSA", "volume_left", &alsa_cfg.vol.left);
--- Output/alsa/alsa.h-dist	2005-01-09 22:11:32.000000000 +0100
+++ Output/alsa/alsa.h	2005-01-09 21:51:07.000000000 +0100
@@ -50,7 +50,9 @@ struct alsa_config
 	char *mixer_device;
 	int buffer_time;
 	int period_time;
+	int thread_buffer_time;
 	gboolean debug;
+	gboolean multi_thread;
 	gboolean mmap;
 	struct
 	{
@@ -65,8 +67,6 @@ void alsa_init(void);
 void alsa_about(void);
 void alsa_configure(void);
 int alsa_get_mixer(snd_mixer_t **mixer, int card);
-snd_mixer_elem_t* alsa_get_mixer_elem(snd_mixer_t *mixer, char *name, int index);
-int alsa_setup_mixer(void);
 void alsa_save_config(void);
 
 void alsa_get_volume(int *l, int *r);

Re: The date of releasing 1.0.8

[Thierry Vignaud]

Takashi Iwai <tiwai@suse.de> writes:

> > XMMS however in the past had rather bad ALSA support, at least
> > with some of the more "difficult" cards like those based on the
> > ICE-chipsets. I don't know, if this is still valid, but I don't
> > trust my ogg files to xmms anymore. ;)
> 
> Last week I played with xmms a bit, and fixed/improved ALSA output
> plugin.  The test patch is attached below.

could you the sale for the beep media player (gtk+2 player based on
xmms codebase)?



-------------------------------------------------------
The SF.Net email is sponsored by: Beat the post-holiday blues
Get a FREE limited edition SourceForge.net t-shirt from ThinkGeek.
It's fun and FREE -- well, almost....http://www.thinkgeek.com/sfshirt

Re: The date of releasing 1.0.8

[Takashi Iwai]

At Thu, 13 Jan 2005 20:40:02 +0100,
Thierry Vignaud wrote:
> 
> Takashi Iwai <tiwai@suse.de> writes:
> 
> > > XMMS however in the past had rather bad ALSA support, at least
> > > with some of the more "difficult" cards like those based on the
> > > ICE-chipsets. I don't know, if this is still valid, but I don't
> > > trust my ogg files to xmms anymore. ;)
> > 
> > Last week I played with xmms a bit, and fixed/improved ALSA output
> > plugin.  The test patch is attached below.
> 
> could you the sale for the beep media player (gtk+2 player based on
> xmms codebase)?

Sorry, I have no time atm, but will take a look later.
Feel free to adapt my changes to beep player (I guess the basis isn't
much different?)...


Takashi


-------------------------------------------------------
The SF.Net email is sponsored by: Beat the post-holiday blues
Get a FREE limited edition SourceForge.net t-shirt from ThinkGeek.
It's fun and FREE -- well, almost....http://www.thinkgeek.com/sfshirt

Re: The date of releasing 1.0.8

[Thierry Vignaud]

[-- Attachment #1: Type: text/plain, Size: 781 bytes --]

Takashi Iwai <tiwai@suse.de> writes:

> > > > XMMS however in the past had rather bad ALSA support, at least
> > > > with some of the more "difficult" cards like those based on
> > > > the ICE-chipsets. I don't know, if this is still valid, but I
> > > > don't trust my ogg files to xmms anymore. ;)
> > > 
> > > Last week I played with xmms a bit, and fixed/improved ALSA
> > > output plugin.  The test patch is attached below.
> > 
> > could you the sale for the beep media player (gtk+2 player based
> > on xmms codebase)?
> 
> Sorry, I have no time atm, but will take a look later.
> Feel free to adapt my changes to beep player

here it's (it's playing sound smoothly whereas previously both xmms
and bmp got paused after half a minute [though xmms was lately fixed
in CVS]):

[-- Attachment #2: bmp-0.9.7-alsa-fixes.patch.bz2 --]
[-- Type: application/octet-stream, Size: 7642 bytes --]

[-- Attachment #3: Type: text/plain, Size: 84 bytes --]


> (I guess the basis isn't much different?)...

actually it was a little different

Re: The date of releasing 1.0.8

[Thierry Vignaud]

Takashi Iwai <tiwai@suse.de> writes:

> > XMMS however in the past had rather bad ALSA support, at least
> > with some of the more "difficult" cards like those based on the
> > ICE-chipsets. I don't know, if this is still valid, but I don't
> > trust my ogg files to xmms anymore. ;)
> 
> Last week I played with xmms a bit, and fixed/improved ALSA output
> plugin.  The test patch is attached below.

btw, have you send it to upstream author so that it got included in
next xmms's releases?



-------------------------------------------------------
This SF.Net email is sponsored by: IntelliVIEW -- Interactive Reporting
Tool for open source databases. Create drag-&-drop reports. Save time
by over 75%! Publish reports on the web. Export to DOC, XLS, RTF, etc.
Download a FREE copy at http://www.intelliview.com/go/osdn_nl