X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=mp3dec_filter.c;h=bd2b4be6869f9a09329b1bdd90936324c406f8b1;hp=50e530e112aa9992197a7ea7739bd7b2e27013ca;hb=5587494468627e20fe622b6055689717262d09ab;hpb=dd0b1f12758ac877de6834b34f8c7f9291d4311d;ds=sidebyside diff --git a/mp3dec_filter.c b/mp3dec_filter.c index 50e530e1..bd2b4be6 100644 --- a/mp3dec_filter.c +++ b/mp3dec_filter.c @@ -1,26 +1,35 @@ /* - * Copyright (C) 2005-2008 Andre Noll + * Copyright (C) 2005-2009 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ /** \file mp3dec_filter.c Paraslash's mp3 decoder. */ +#include +#include + #include "para.h" +#include "mp3dec_filter.cmdline.h" #include "list.h" #include "sched.h" +#include "ggo.h" #include "filter.h" #include "error.h" -#include #include "string.h" -/** The output buffer size. */ -#define MP3_OUTBUF_SIZE (128 * 1024) - /** Convert a sample value from libmad to a signed short. */ #define MAD_TO_SHORT(f) (f) >= MAD_F_ONE? SHRT_MAX :\ (f) <= -MAD_F_ONE? -SHRT_MAX : (signed short) ((f) >> (MAD_F_FRACBITS - 15)) +/** State of the decoding process. */ +enum mp3dec_flags { + /** Bad main_data_begin pointer encounterd. */ + MP3DEC_FLAG_BAD_DATA = 1, + /** Some output has already been produced. */ + MP3DEC_FLAG_DECODE_STARTED = 2, +}; + /** Data specific to the mp3dec filter. */ struct private_mp3dec_data { /** Information on the current mp3 stream. */ @@ -29,15 +38,64 @@ struct private_mp3dec_data { struct mad_frame frame; /** Contains the PCM output. */ struct mad_synth synth; + /** See \ref mp3dec_flags. */ + unsigned flags; + /** Defer decoding until this time. */ + struct timeval stream_start_barrier; + /** Wait until this many input bytes are available. */ + size_t input_len_barrier; }; +static int need_bad_data_delay(struct private_mp3dec_data *pmd, + size_t bytes_available) +{ + if (!(pmd->flags & MP3DEC_FLAG_BAD_DATA)) + return 0; + if (pmd->flags & MP3DEC_FLAG_DECODE_STARTED) + return 0; + if (bytes_available >= pmd->input_len_barrier) + return 0; + if (tv_diff(now, &pmd->stream_start_barrier, NULL) > 0) + return 0; + return 1; +} + +/* + * Returns negative on serious errors, zero if the error should be ignored and + * positive on bad data pointer errors at stream start. + */ +static int handle_decode_error(struct private_mp3dec_data *pmd, size_t len) +{ + if (!MAD_RECOVERABLE(pmd->stream.error) + && pmd->stream.error != MAD_ERROR_BUFLEN) { + PARA_ERROR_LOG("%s\n", mad_stream_errorstr(&pmd->stream)); + return -E_MAD_FRAME_DECODE; + } + PARA_DEBUG_LOG("%s\n", mad_stream_errorstr(&pmd->stream)); + if (pmd->stream.error != MAD_ERROR_BADDATAPTR) + return 0; + if (pmd->flags & MP3DEC_FLAG_DECODE_STARTED) + return 0; + /* + * Bad data pointer at stream start. Defer decoding until the amount of + * data we are about to skip is available again, but wait at most 60ms. + */ + pmd->flags |= MP3DEC_FLAG_BAD_DATA; + pmd->input_len_barrier = len; + tv_add(now, &(struct timeval){0, 60 * 1000}, + &pmd->stream_start_barrier); + return 1; +} + static ssize_t mp3dec(char *inbuffer, size_t len, struct filter_node *fn) { int i, ret; struct private_mp3dec_data *pmd = fn->private_data; - size_t copy = PARA_MIN(len, 4096); + size_t copy = PARA_MIN(len, (size_t)4096); - if (fn->loaded > fn->bufsize * 4 / 5) + if (fn->loaded + 16384 > fn->bufsize) + return 0; + if (need_bad_data_delay(pmd, len)) return 0; mad_stream_buffer(&pmd->stream, (unsigned char *) inbuffer, copy); pmd->stream.error = 0; @@ -53,18 +111,18 @@ next_frame: fn->fc->samplerate = pmd->frame.header.samplerate; fn->fc->channels = MAD_NCHANNELS(&pmd->frame.header); ret = mad_frame_decode(&pmd->frame, &pmd->stream); - if (ret) { - if (MAD_RECOVERABLE(pmd->stream.error) || - pmd->stream.error == MAD_ERROR_BUFLEN) { - PARA_DEBUG_LOG("frame decode: %s\n", - mad_stream_errorstr(&pmd->stream)); + if (ret != 0) { + ret = handle_decode_error(pmd, len); + if (ret < 0) + return ret; + if (ret == 0) goto out; - } - PARA_ERROR_LOG("frame decode: %s\n", - mad_stream_errorstr(&pmd->stream)); - return -E_MAD_FRAME_DECODE; + ret = copy - (pmd->stream.bufend - pmd->stream.next_frame); + PARA_NOTICE_LOG("skipping %d input bytes\n", ret); + return ret; } mad_synth_frame(&pmd->synth, &pmd->frame); + pmd->flags |= MP3DEC_FLAG_DECODE_STARTED; for (i = 0; i < pmd->synth.pcm.length; i++) { int s = MAD_TO_SHORT(pmd->synth.pcm.samples[0][i]); @@ -80,13 +138,13 @@ next_frame: PARA_ERROR_LOG("output buffer full: %zd\n", fn->loaded); return -E_MP3DEC_OVERRUN; } - if (fn->loaded <= fn->bufsize * 4 / 5) + if (fn->loaded + 16384 <= fn->bufsize) goto next_frame; out: if (pmd->stream.next_frame) { /* we still have some data */ size_t off = pmd->stream.bufend - pmd->stream.next_frame; -// PARA_INFO_LOG("off: %zd, rate: %u, returning %zd\n", off, -// fn->fc->samplerate, copy - off); + if (fn->loaded + 16384 <= fn->bufsize && off > 2048) + goto next_frame; return copy - off; } return copy; @@ -109,14 +167,38 @@ static void mp3dec_close(struct filter_node *fn) static void mp3dec_open(struct filter_node *fn) { struct private_mp3dec_data *pmd = para_calloc(sizeof(*pmd)); + struct mp3dec_filter_args_info *mp3_conf = fn->conf; fn->private_data = pmd; mad_stream_init(&pmd->stream); mad_frame_init(&pmd->frame); mad_synth_init(&pmd->synth); fn->loaded = 0; - fn->bufsize = MP3_OUTBUF_SIZE; + fn->bufsize = mp3_conf->bufsize_arg * 1024; fn->buf = para_calloc(fn->bufsize); + if (mp3_conf->ignore_crc_given) + mad_stream_options(&pmd->stream, MAD_OPTION_IGNORECRC); +} + +static int mp3dec_parse_config(int argc, char **argv, void **config) +{ + int ret; + struct mp3dec_filter_args_info *mp3_conf; + + mp3_conf = para_calloc(sizeof(*mp3_conf)); + ret = -E_MP3DEC_SYNTAX; + if (mp3dec_cmdline_parser(argc, argv, mp3_conf)) + goto err; + ret = -ERRNO_TO_PARA_ERROR(EINVAL); + if (mp3_conf->bufsize_arg < 32) + goto err; + if (mp3_conf->bufsize_arg >= INT_MAX / 1024) + goto err; + *config = mp3_conf; + return 1; +err: + free(mp3_conf); + return ret; } /** @@ -128,7 +210,15 @@ static void mp3dec_open(struct filter_node *fn) */ void mp3dec_filter_init(struct filter *f) { + struct mp3dec_filter_args_info dummy; + + mp3dec_cmdline_parser_init(&dummy); f->open = mp3dec_open; f->convert = mp3dec; f->close = mp3dec_close; + f->parse_config = mp3dec_parse_config; + f->help = (struct ggo_help) { + .short_help = mp3dec_filter_args_info_help, + .detailed_help = mp3dec_filter_args_info_detailed_help + }; }