diff --git a/audacious-plugins-1.5.1-0006-alsa-plugin-Fix-last-second-s-of-songs-getting-los.patch b/audacious-plugins-1.5.1-0006-alsa-plugin-Fix-last-second-s-of-songs-getting-los.patch new file mode 100644 index 0000000..d176d73 --- /dev/null +++ b/audacious-plugins-1.5.1-0006-alsa-plugin-Fix-last-second-s-of-songs-getting-los.patch @@ -0,0 +1,82 @@ +From 53306659a71bd4b49a560a7197f2fd0a7ba71ca0 Mon Sep 17 00:00:00 2001 +From: Hans de Goede +Date: Fri, 8 May 2009 11:59:33 +0200 +Subject: [PATCH 6/9] alsa plugin: Fix last second(s) of songs getting lost + +There are 2 problems with the alsa plugin, which cause the end of a song +to get lost: +1) alsa_playing contains the following check: + get_thread_buffer_filled() > hw_period_size_in + This will cause alsa_playing to return 0 when there are still + frames left in the thread buffer, and once the input plugin then calls + alsa_close, these frames will get lost. + +2) alsa_close_pcm() calls snd_pcm_drop() which will cause all the frames + still in the buffers of the card to be dropped + +Fixing this: +1) Can be fixed by replacing the check with just: + get_thread_buffer_filled() + +2) However is harder to fix, one could replace snd_pcm_drop() with + snd_pcm_drain(), but this will cause delays when we want to + close immediately (stop/prev song/next song) + +After some fiddling I've come the conclusing that 2 is not really a problem, +the problem is that alsa_playing should return 1 as long as there is data +in either the thread buffer or in the hardware buffer of the card. + +For this to work we also need to change the: +get_thread_buffer_filled() > hw_period_size_in +check in alsa_loop with just get_thread_buffer_filled() + +Last this patch also removes the write max hw_period_size_in at a time +bytes check, if there is more then one period_size worth of data available +in the cards buffers its quite alright to write multiple periods at a time. +--- + src/alsa/audio.c | 13 +++++-------- + 1 files changed, 5 insertions(+), 8 deletions(-) + +diff --git a/src/alsa/audio.c b/src/alsa/audio.c +index 8dacdf2..80b92a5 100644 +--- a/src/alsa/audio.c ++++ b/src/alsa/audio.c +@@ -131,13 +131,11 @@ static void debug(char *str, ...) + + int alsa_playing(void) + { +- if (!going || paused || alsa_pcm == NULL) ++ if (!going || paused || prebuffer || alsa_pcm == NULL) + return FALSE; + +- return snd_pcm_state(alsa_pcm) == SND_PCM_STATE_RUNNING && +- !paused && +- !prebuffer && +- get_thread_buffer_filled() > hw_period_size_in; ++ return snd_pcm_state(alsa_pcm) == SND_PCM_STATE_RUNNING || ++ get_thread_buffer_filled(); + } + + static int +@@ -637,7 +635,7 @@ static void alsa_write_out_thread_data(void) + { + gint length, cnt, avail; + +- length = MIN(hw_period_size_in, get_thread_buffer_filled()); ++ length = get_thread_buffer_filled(); + avail = snd_pcm_frames_to_bytes(alsa_pcm, alsa_get_avail()); + length = MIN(length, avail); + while (length > 0) +@@ -667,8 +665,7 @@ static void *alsa_loop(void *arg) + { + if (get_thread_buffer_filled() > prebuffer_size) + prebuffer = FALSE; +- if (!paused && !prebuffer && +- get_thread_buffer_filled() > hw_period_size_in) ++ if (!paused && !prebuffer && get_thread_buffer_filled()) + { + wr = snd_pcm_wait(alsa_pcm, 10); + if (wr > 0) +-- +1.6.2.2 + diff --git a/audacious-plugins-1.5.1-0007-Fix-alsa-plugin-locking.patch b/audacious-plugins-1.5.1-0007-Fix-alsa-plugin-locking.patch new file mode 100644 index 0000000..43db74d --- /dev/null +++ b/audacious-plugins-1.5.1-0007-Fix-alsa-plugin-locking.patch @@ -0,0 +1,232 @@ +From 7910820018fd598e31b969510be407b6dc4fb127 Mon Sep 17 00:00:00 2001 +From: Hans de Goede +Date: Mon, 11 May 2009 16:28:27 +0200 +Subject: [PATCH 7/9] Fix alsa plugin locking + +audacious sometimes hung after playing the first 3 secs of a song, +this patch fixes this. +--- + src/alsa/audio.c | 113 ++++++++++++++++++++++++++++++++++++------------------ + 1 files changed, 75 insertions(+), 38 deletions(-) + +diff --git a/src/alsa/audio.c b/src/alsa/audio.c +index 80b92a5..c50548b 100644 +--- a/src/alsa/audio.c ++++ b/src/alsa/audio.c +@@ -131,11 +131,19 @@ static void debug(char *str, ...) + + int alsa_playing(void) + { ++ int ret; ++ ++ g_static_mutex_lock(&alsa_mutex); ++ + if (!going || paused || prebuffer || alsa_pcm == NULL) +- return FALSE; ++ ret = FALSE; ++ else ++ ret = snd_pcm_state(alsa_pcm) == SND_PCM_STATE_RUNNING || ++ get_thread_buffer_filled(); + +- return snd_pcm_state(alsa_pcm) == SND_PCM_STATE_RUNNING || +- get_thread_buffer_filled(); ++ g_static_mutex_unlock(&alsa_mutex); ++ ++ return ret; + } + + static int +@@ -215,6 +223,10 @@ static snd_pcm_sframes_t alsa_get_avail(void) + /* get the free space on buffer */ + int alsa_free(void) + { ++ int ret; ++ ++ g_static_mutex_lock(&alsa_mutex); ++ + if (remove_prebuffer && prebuffer) + { + prebuffer = FALSE; +@@ -223,7 +235,11 @@ int alsa_free(void) + if (prebuffer) + remove_prebuffer = TRUE; + +- return thread_buffer_size - get_thread_buffer_filled() - 1; ++ ret = thread_buffer_size - get_thread_buffer_filled() - 1; ++ ++ g_static_mutex_unlock(&alsa_mutex); ++ ++ return ret; + } + + /* do pause operation */ +@@ -276,8 +292,6 @@ void alsa_close(void) + + g_thread_join(audio_thread); + +- g_static_mutex_lock(&alsa_mutex); /* alsa_loop locks alsa_mutex! */ +- + alsa_cleanup_mixer(); + + g_free(inputf); +@@ -290,8 +304,6 @@ void alsa_close(void) + if (alsa_cfg.debug) + snd_output_close(logs); + debug("Device closed"); +- +- g_static_mutex_unlock(&alsa_mutex); + } + + /* reopen ALSA PCM */ +@@ -541,28 +553,46 @@ static int get_thread_buffer_filled(void) + + int alsa_get_output_time(void) + { ++ int ret; + snd_pcm_sframes_t delay; + guint64 bytes = alsa_hw_written; + +- if (!going || alsa_pcm == NULL) +- return 0; ++ g_static_mutex_lock(&alsa_mutex); + +- if (!snd_pcm_delay(alsa_pcm, &delay)) ++ if (going && alsa_pcm) + { +- unsigned int d = snd_pcm_frames_to_bytes(alsa_pcm, delay); +- if (bytes < d) +- bytes = 0; +- else +- bytes -= d; ++ if (!snd_pcm_delay(alsa_pcm, &delay)) ++ { ++ unsigned int d = snd_pcm_frames_to_bytes(alsa_pcm, delay); ++ if (bytes < d) ++ bytes = 0; ++ else ++ bytes -= d; ++ } ++ ret = output_time_offset + (bytes * 1000) / outputf->bps; + } +- return output_time_offset + (bytes * 1000) / outputf->bps; ++ else ++ ret = 0; ++ ++ g_static_mutex_unlock(&alsa_mutex); ++ ++ return ret; + } + + int alsa_get_written_time(void) + { +- if (!going) +- return 0; +- return (alsa_total_written * 1000) / inputf->bps; ++ int ret; ++ ++ g_static_mutex_lock(&alsa_mutex); ++ ++ if (going) ++ ret = (alsa_total_written * 1000) / inputf->bps; ++ else ++ ret = 0; ++ ++ g_static_mutex_unlock(&alsa_mutex); ++ ++ return ret; + } + + /* transfer data to audio h/w; length is given in bytes +@@ -583,7 +613,9 @@ void alsa_write(gpointer data, int length) + { + int cnt; + char *src = (char *)data; +- ++ ++ g_static_mutex_lock(&alsa_mutex); ++ + remove_prebuffer = FALSE; + + alsa_total_written += length; +@@ -597,6 +629,7 @@ void alsa_write(gpointer data, int length) + length -= cnt; + src += cnt; + } ++ g_static_mutex_unlock(&alsa_mutex); + } + + /* transfer data to audio h/w via normal write */ +@@ -653,12 +686,17 @@ static void alsa_write_out_thread_data(void) + /* FIXME: proper lock? */ + static void *alsa_loop(void *arg) + { +- int npfds = snd_pcm_poll_descriptors_count(alsa_pcm); +- int wr = 0; ++ struct pollfd pfd[16]; ++ int npfds, err; + + g_static_mutex_lock(&alsa_mutex); + +- if (npfds <= 0) ++ npfds = snd_pcm_poll_descriptors_count(alsa_pcm); ++ if (npfds <= 0 || npfds > 16) ++ goto _error; ++ ++ err = snd_pcm_poll_descriptors(alsa_pcm, pfd, npfds); ++ if (err != npfds) + goto _error; + + while (going && alsa_pcm) +@@ -667,18 +705,21 @@ static void *alsa_loop(void *arg) + prebuffer = FALSE; + if (!paused && !prebuffer && get_thread_buffer_filled()) + { +- wr = snd_pcm_wait(alsa_pcm, 10); +- if (wr > 0) +- { +- alsa_write_out_thread_data(); +- } +- else if (wr < 0) +- { +- alsa_recovery(wr); +- } ++ g_static_mutex_unlock(&alsa_mutex); ++ err = poll(pfd, npfds, 10); ++ g_static_mutex_lock(&alsa_mutex); ++ ++ if (err < 0 && errno != EINTR) ++ goto _error; ++ ++ alsa_write_out_thread_data(); + } +- else /* XXX: why is this here? --nenolod */ ++ else ++ { ++ g_static_mutex_unlock(&alsa_mutex); + g_usleep(10000); ++ g_static_mutex_lock(&alsa_mutex); ++ } + + if (pause_request != paused) + alsa_do_pause(pause_request); +@@ -715,8 +756,6 @@ int alsa_open(AFormat fmt, int rate, int nch) + return 0; + } + +- g_static_mutex_lock(&alsa_mutex); +- + if (!mixer) + alsa_setup_mixer(); + +@@ -742,8 +781,6 @@ int alsa_open(AFormat fmt, int rate, int nch) + pause_request = FALSE; + flush_request = -1; + +- g_static_mutex_unlock(&alsa_mutex); +- + audio_thread = g_thread_create((GThreadFunc)alsa_loop, NULL, TRUE, NULL); + return 1; + } +-- +1.6.2.2 + diff --git a/audacious-plugins-1.5.1-0008-alsa-output-plugin-allow-usage-of-last-byte-of-thre.patch b/audacious-plugins-1.5.1-0008-alsa-output-plugin-allow-usage-of-last-byte-of-thre.patch new file mode 100644 index 0000000..22fdeaa --- /dev/null +++ b/audacious-plugins-1.5.1-0008-alsa-output-plugin-allow-usage-of-last-byte-of-thre.patch @@ -0,0 +1,86 @@ +From a113a1fad60cbb0e7e1d30f434e759ecca0fa582 Mon Sep 17 00:00:00 2001 +From: Hans de Goede +Date: Mon, 11 May 2009 16:38:58 +0200 +Subject: [PATCH 8/9] alsa output plugin: allow usage of last byte of thread buffer + +The code before this patch only allowed using 1 less byte then the +actual thread buffer size, as the fifo code had no way to distinguish +if rd_index == wr_index meant the fifo was full or empty. The old never +use the last byte solution was sub optimal, as the thread buffer size +normally is 2x the hardware buffer size, which is a power of 2, and reads are +being done from it a fragment at a time, which usually also are powers of 2. +--- + src/alsa/audio.c | 14 ++++++++++++-- + 1 files changed, 12 insertions(+), 2 deletions(-) + +diff --git a/src/alsa/audio.c b/src/alsa/audio.c +index c50548b..ca9c70d 100644 +--- a/src/alsa/audio.c ++++ b/src/alsa/audio.c +@@ -62,6 +62,7 @@ static gboolean alsa_can_pause; + static GThread *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 buffer_empty; /* is the buffer empty? */ + static int rd_index, wr_index; /* current read/write position in int-buffer */ + static gboolean pause_request; /* pause status currently requested */ + static int flush_request; /* flush status (time) currently requested */ +@@ -235,7 +236,7 @@ int alsa_free(void) + if (prebuffer) + remove_prebuffer = TRUE; + +- ret = thread_buffer_size - get_thread_buffer_filled() - 1; ++ ret = thread_buffer_size - get_thread_buffer_filled(); + + g_static_mutex_unlock(&alsa_mutex); + +@@ -332,6 +333,7 @@ static void alsa_do_flush(int time) + output_time_offset = time; + alsa_total_written = (guint64) time * inputf->bps / 1000; + rd_index = wr_index = alsa_hw_written = 0; ++ buffer_empty = 1; + } + + void alsa_flush(int time) +@@ -546,8 +548,12 @@ void alsa_set_volume(int l, int r) + /* return the size of audio data filled in the audio thread buffer */ + static int get_thread_buffer_filled(void) + { +- if (wr_index >= rd_index) ++ if (buffer_empty) ++ return 0; ++ ++ if (wr_index > rd_index) + return wr_index - rd_index; ++ + return thread_buffer_size - (rd_index - wr_index); + } + +@@ -626,6 +632,7 @@ void alsa_write(gpointer data, int length) + memcpy(thread_buffer + wr_index, src, cnt); + wr = (wr_index + cnt) % thread_buffer_size; + wr_index = wr; ++ buffer_empty = 0; + length -= cnt; + src += cnt; + } +@@ -678,6 +685,8 @@ static void alsa_write_out_thread_data(void) + alsa_do_write(thread_buffer + rd_index, cnt); + rd = (rd_index + cnt) % thread_buffer_size; + rd_index = rd; ++ if (rd_index == wr_index) ++ buffer_empty = 1; + length -= cnt; + } + } +@@ -778,6 +787,7 @@ int alsa_open(AFormat fmt, int rate, int nch) + thread_buffer_size -= thread_buffer_size % hw_period_size; + thread_buffer = g_malloc0(thread_buffer_size); + wr_index = rd_index = 0; ++ buffer_empty = 1; + pause_request = FALSE; + flush_request = -1; + +-- +1.6.2.2 + diff --git a/audacious-plugins-1.5.1-0009-alsa-output-plugin-use-snd_pcm_recover.patch b/audacious-plugins-1.5.1-0009-alsa-output-plugin-use-snd_pcm_recover.patch new file mode 100644 index 0000000..982ad8a --- /dev/null +++ b/audacious-plugins-1.5.1-0009-alsa-output-plugin-use-snd_pcm_recover.patch @@ -0,0 +1,96 @@ +From 7b027ee36f0e7850820b1e9cc0214c69688c6917 Mon Sep 17 00:00:00 2001 +From: Hans de Goede +Date: Mon, 11 May 2009 16:53:23 +0200 +Subject: [PATCH 9/9] alsa output plugin: use snd_pcm_recover() + +The alsa_recovery() function this patch removes does exactly the same as +the alsa-lib snd_pcm_recover() function, so use that instead. +--- + src/alsa/audio.c | 57 +---------------------------------------------------- + 1 files changed, 2 insertions(+), 55 deletions(-) + +diff --git a/src/alsa/audio.c b/src/alsa/audio.c +index ca9c70d..ed3af92 100644 +--- a/src/alsa/audio.c ++++ b/src/alsa/audio.c +@@ -147,59 +147,6 @@ int alsa_playing(void) + return ret; + } + +-static int +-alsa_recovery(int err) +-{ +- int err2; +- +- /* if debug mode is enabled, dump ALSA state to console */ +- if (alsa_cfg.debug) +- { +- snd_pcm_status_t *alsa_status = NULL; +- 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); +- } +- } +- +- /* +- * specifically handle -EPIPE and -ESTRPIPE to recover +- * PCM fragment periods without losing data. +- */ +- switch (err) +- { +- case -ESTRPIPE: +- case ESTRPIPE: /* "suspend": wait until ALSA is "running" again. */ +- while ((err2 = snd_pcm_resume(alsa_pcm)) == -EAGAIN) +- g_usleep(100000); +- +- if (err2 < 0) +- return snd_pcm_prepare(alsa_pcm); +- +- break; +- +- case -EPIPE: +- case EPIPE: /* under-run and the I/O pipe closed on us */ +- return snd_pcm_prepare(alsa_pcm); +- break; +- +- case EINTR: +- case -EINTR: +- break; +- +- default: +- g_warning("Unhandled ALSA exception code %d (%s), trying hard restart.", err, snd_strerror(err)); +- return snd_pcm_prepare(alsa_pcm); +- break; +- } +- +- return 0; +-} +- + /* update and get the available space on h/w buffer (in frames) */ + static snd_pcm_sframes_t alsa_get_avail(void) + { +@@ -210,7 +157,7 @@ static snd_pcm_sframes_t alsa_get_avail(void) + + while ((ret = snd_pcm_avail_update(alsa_pcm)) < 0) + { +- ret = alsa_recovery(ret); ++ ret = snd_pcm_recover(alsa_pcm, ret, !alsa_cfg.debug); + if (ret < 0) + { + g_warning("alsa_get_avail(): snd_pcm_avail_update() failed: %s", +@@ -659,7 +606,7 @@ static void alsa_write_audio(char *data, int length) + } + else + { +- int err = alsa_recovery((int)written_frames); ++ int err = snd_pcm_recover(alsa_pcm, written_frames, !alsa_cfg.debug); + if (err < 0) + { + g_warning("alsa_write_audio(): write error: %s", +-- +1.6.2.2 + diff --git a/audacious-plugins-1.5.1-neon-reader-error-crash.patch b/audacious-plugins-1.5.1-neon-reader-error-crash.patch new file mode 100644 index 0000000..dcf36a1 --- /dev/null +++ b/audacious-plugins-1.5.1-neon-reader-error-crash.patch @@ -0,0 +1,12 @@ +diff -r e6034a500e27 -r 617cd51dfee5 src/neon/neon.c +--- a/src/neon/neon.c Wed May 06 12:11:06 2009 -0400 ++++ b/src/neon/neon.c Wed May 06 12:10:28 2009 -0500 +@@ -990,7 +990,7 @@ + } + + if (NULL == h->reader) { +- if (NEON_READER_EOF != h->reader_status.status) { ++ if (NEON_READER_EOF != h->reader_status.status && NEON_READER_ERROR != h->reader_status.status) { + /* + * There is no reader thread yet. Read the first bytes from + * the network ourselves, and then fire up the reader thread diff --git a/audacious-plugins-1.5.1-sndfile-cleanup.patch b/audacious-plugins-1.5.1-sndfile-cleanup.patch new file mode 100644 index 0000000..48d731e --- /dev/null +++ b/audacious-plugins-1.5.1-sndfile-cleanup.patch @@ -0,0 +1,73 @@ +diff -Nur audacious-plugins-fedora-1.5.1-orig/src/sndfile/plugin.c audacious-plugins-fedora-1.5.1/src/sndfile/plugin.c +--- audacious-plugins-fedora-1.5.1-orig/src/sndfile/plugin.c 2008-06-08 10:37:44.000000000 +0200 ++++ audacious-plugins-fedora-1.5.1/src/sndfile/plugin.c 2009-06-05 00:35:29.000000000 +0200 +@@ -47,6 +47,7 @@ + static gint song_length; + static gint bit_rate = 0; + static glong seek_time = -1; ++static volatile char pause_flag; + + static GThread *decode_thread; + static GMutex *decode_mutex; +@@ -121,6 +122,7 @@ + plugin_init (void) + { + seek_time = -1; ++ pause_flag = 0; + + decode_mutex = g_mutex_new(); + decode_cond = g_cond_new(); +@@ -362,6 +364,22 @@ + return TRUE; + } + ++static void do_seek (InputPlayback * playback) { ++ playback->output->flush (seek_time); ++ sf_seek (sndfile, (long long) seek_time * sfinfo.samplerate / 1000, SEEK_SET); ++ seek_time = -1; ++} ++ ++static void do_pause (InputPlayback * playback) { ++ playback->output->pause (1); ++ while (pause_flag) { ++ if (seek_time != -1) ++ do_seek (playback); ++ g_usleep(50000); ++ } ++ playback->output->pause (0); ++} ++ + static gpointer + play_loop (gpointer arg) + { +@@ -407,17 +425,13 @@ + playback->eof = TRUE; + playback->playing = FALSE; + +- g_mutex_unlock(decode_mutex); + break; + } + +- /* Do seek if seek_time is valid. */ +- if (seek_time >= 0) { +- sf_seek (sndfile, (sf_count_t)((gint64)seek_time * (gint64)sfinfo.samplerate / 1000L), +- SEEK_SET); +- playback->output->flush (seek_time); +- seek_time = -1; +- } ++ if (seek_time != -1) ++ do_seek (playback); ++ if (pause_flag) ++ do_pause (playback); + + if (playback->playing == FALSE) + break; +@@ -477,7 +491,7 @@ + static void + play_pause (InputPlayback *playback, gshort p) + { +- playback->output->pause(p); ++ pause_flag = p; + } + + static void diff --git a/audacious-plugins.spec b/audacious-plugins.spec index 0e28824..ec45d85 100644 --- a/audacious-plugins.spec +++ b/audacious-plugins.spec @@ -1,8 +1,10 @@ -%define aud_ver 1.5.0 +# Minimum audacious/audacious-plugins version in inter-package +# dependencies. We have 1.5.1 for both, so we enforce 1.5.1. +%define aud_ver 1.5.1 Name: audacious-plugins Version: 1.5.1 -Release: 4%{?dist} +Release: 6%{?dist} Summary: Plugins for the Audacious media player Group: Applications/Multimedia @@ -21,6 +23,16 @@ Patch3: audacious-plugins-1.5.1-libmtp.patch Patch4: audacious-plugins-1.5.1-vorbis-oga.patch Patch5: audacious-plugins-1.5.1-timidity-cfg.patch Patch6: audacious-plugins-1.5.1-amidi-symbol.patch +Patch7: audacious-plugins-1.5.1-neon-reader-error-crash.patch +Patch8: audacious-plugins-1.5.1-sndfile-cleanup.patch + +# ALSA driver bug-fixes originally for Audacious 2.0 series +# backported to legacy 1.5.1 (#499942) +Patch100: audacious-plugins-1.5.1-0006-alsa-plugin-Fix-last-second-s-of-songs-getting-los.patch +Patch101: audacious-plugins-1.5.1-0007-Fix-alsa-plugin-locking.patch +Patch102: audacious-plugins-1.5.1-0008-alsa-output-plugin-allow-usage-of-last-byte-of-thre.patch +Patch103: audacious-plugins-1.5.1-0009-alsa-output-plugin-use-snd_pcm_recover.patch + BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) BuildRequires: audacious-devel >= %{aud_ver}, esound-devel >= 0.2, libvorbis-devel >= 1.0 @@ -38,27 +50,24 @@ BuildRequires: libXcomposite-devel BuildRequires: file-devel BuildRequires: libmtp-devel BuildRequires: neon-devel >= 0.25 -BuildRequires: libmowgli >= 0.5.0 +BuildRequires: libmowgli-devel >= 0.5.0 BuildRequires: mcs-devel >= 0.6.0 BuildRequires: libcdio-devel >= 0.70 BuildRequires: libcddb-devel >= 1.2.1 - +BuildRequires: libsndfile-devel Requires: audacious >= %{aud_ver} -Requires(post): desktop-file-utils >= 0.9, /sbin/ldconfig -Requires(postun): desktop-file-utils >= 0.9, /sbin/ldconfig - Obsoletes: audacious-plugins-pulseaudio <= 1.3.5 Provides: audacious-plugins-pulseaudio = %{version} %description -Audacious is a media player that currently uses a skinned -user interface based on Winamp 2.x skins. It is based on ("forked off") -BMP. -This package provides essential plugins for audio input, audio output -and visualization. +Audacious is a media player that currently uses a skinned user interface +based on Winamp 2.x skins. It is based on ("forked off") BMP. + +This package provides essential plugins for audio input, audio output and +visualization. %package jack @@ -169,19 +178,29 @@ vortex compressed files. # fix missing symbols in amidi %patch6 -p1 -b amidi-symbols -perl -pi -e 's/^\.SILENT:.*$//' buildsys.mk.in +# Patch possible neon crash on buffer underrun +%patch7 -p1 -b neon-reader-error-crash + +# pause and seek for libsndfile input plugin +%patch8 -p1 -b .sndfile-cleanup + +%patch100 -p1 -b .alsa-499942-0006 +%patch101 -p1 -b .alsa-499942-0007 +%patch102 -p1 -b .alsa-499942-0008 +%patch103 -p1 -b .alsa-499942-0009 + +sed -i '\,^.SILENT:,d' buildsys.mk.in %build %configure \ --disable-rpath \ - --enable-gconf \ - --disable-gnome-vfs \ --enable-chardet \ --disable-dependency-tracking \ --enable-amidiplug \ --disable-amidiplug-dummy \ - --disable-sndfile \ --disable-sse2 \ + --disable-rootvis \ + --disable-projectm \ --enable-neon make %{?_smp_mflags} @@ -189,7 +208,7 @@ make %{?_smp_mflags} %install rm -rf $RPM_BUILD_ROOT -make install DESTDIR=$RPM_BUILD_ROOT +make install DESTDIR=$RPM_BUILD_ROOT INSTALL="install -p" %find_lang %{name} desktop-file-install --vendor fedora \ @@ -201,25 +220,23 @@ rm -rf $RPM_BUILD_ROOT %post -/sbin/ldconfig -update-desktop-database %{_datadir}/applications +update-desktop-database &> /dev/null || : %postun -/sbin/ldconfig -update-desktop-database %{_datadir}/applications +update-desktop-database &> /dev/null || : %files -f %{name}.lang %defattr(-,root,root,-) %doc AUTHORS COPYING NEWS -%{_libdir}/audacious/Input -%{_libdir}/audacious/Output -%{_libdir}/audacious/Container -%{_libdir}/audacious/Effect -%{_libdir}/audacious/General -%{_libdir}/audacious/Visualization -%{_libdir}/audacious/Transport +%{_libdir}/audacious/Input/ +%{_libdir}/audacious/Output/ +%{_libdir}/audacious/Container/ +%{_libdir}/audacious/Effect/ +%{_libdir}/audacious/General/ +%{_libdir}/audacious/Visualization/ +%{_libdir}/audacious/Transport/ %exclude %{_libdir}/audacious/Input/amidi-plug.so %exclude %{_libdir}/audacious/Input/wavpack.so %exclude %{_libdir}/audacious/Input/metronom.so @@ -231,7 +248,7 @@ update-desktop-database %{_datadir}/applications %{_datadir}/audacious/images/audioscrobbler.png %{_datadir}/audacious/images/audioscrobbler_badge.png # %{_datadir}/audacious-plugins -%{_datadir}/audacious/paranormal +%{_datadir}/audacious/paranormal/ %files jack %defattr(-,root,root,-) @@ -265,6 +282,16 @@ update-desktop-database %{_datadir}/applications %changelog +* Thu Jun 4 2009 Michael Schwendt - 1.5.1-6 +- Apply ALSA driver patches by Hans de Goede (#499942). +- Minor spec updates. +- Update scriptlets in accordance with guidelines. +- Build with libsndfile plugin for advanced formats in WAV and + patch it for pause and seek (also fixes #501007). + +* Wed May 06 2009 Ralf Ertzinger 1.5.1-5 +- Fix possible crash on neon buffer underrun (BZ#496413) + * Fri May 01 2009 Ralf Ertzinger 1.5.1-4 - Accept .oga files (BZ#479120) - Look for timitidy.cfg in /etc (BZ#450933)