aboutsummaryrefslogtreecommitdiffstats
path: root/src/decoder/mad_decoder_plugin.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/decoder/mad_decoder_plugin.c')
-rw-r--r--src/decoder/mad_decoder_plugin.c1204
1 files changed, 1204 insertions, 0 deletions
diff --git a/src/decoder/mad_decoder_plugin.c b/src/decoder/mad_decoder_plugin.c
new file mode 100644
index 000000000..a11d1b020
--- /dev/null
+++ b/src/decoder/mad_decoder_plugin.c
@@ -0,0 +1,1204 @@
+/*
+ * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include "decoder_api.h"
+#include "conf.h"
+#include "tag_id3.h"
+#include "tag_rva2.h"
+#include "audio_check.h"
+
+#include <assert.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <glib.h>
+#include <mad.h>
+
+#ifdef HAVE_ID3TAG
+#include <id3tag.h>
+#endif
+
+#undef G_LOG_DOMAIN
+#define G_LOG_DOMAIN "mad"
+
+#define FRAMES_CUSHION 2000
+
+#define READ_BUFFER_SIZE 40960
+
+enum mp3_action {
+ DECODE_SKIP = -3,
+ DECODE_BREAK = -2,
+ DECODE_CONT = -1,
+ DECODE_OK = 0
+};
+
+enum muteframe {
+ MUTEFRAME_NONE,
+ MUTEFRAME_SKIP,
+ MUTEFRAME_SEEK
+};
+
+/* the number of samples of silence the decoder inserts at start */
+#define DECODERDELAY 529
+
+#define DEFAULT_GAPLESS_MP3_PLAYBACK true
+
+static bool gapless_playback;
+
+static inline int32_t
+mad_fixed_to_24_sample(mad_fixed_t sample)
+{
+ enum {
+ bits = 24,
+ MIN = -MAD_F_ONE,
+ MAX = MAD_F_ONE - 1
+ };
+
+ /* round */
+ sample = sample + (1L << (MAD_F_FRACBITS - bits));
+
+ /* clip */
+ if (sample > MAX)
+ sample = MAX;
+ else if (sample < MIN)
+ sample = MIN;
+
+ /* quantize */
+ return sample >> (MAD_F_FRACBITS + 1 - bits);
+}
+
+static void
+mad_fixed_to_24_buffer(int32_t *dest, const struct mad_synth *synth,
+ unsigned int start, unsigned int end,
+ unsigned int num_channels)
+{
+ unsigned int i, c;
+
+ for (i = start; i < end; ++i) {
+ for (c = 0; c < num_channels; ++c)
+ *dest++ = mad_fixed_to_24_sample(synth->pcm.samples[c][i]);
+ }
+}
+
+static bool
+mp3_plugin_init(G_GNUC_UNUSED const struct config_param *param)
+{
+ gapless_playback = config_get_bool(CONF_GAPLESS_MP3_PLAYBACK,
+ DEFAULT_GAPLESS_MP3_PLAYBACK);
+ return true;
+}
+
+#define MP3_DATA_OUTPUT_BUFFER_SIZE 2048
+
+struct mp3_data {
+ struct mad_stream stream;
+ struct mad_frame frame;
+ struct mad_synth synth;
+ mad_timer_t timer;
+ unsigned char input_buffer[READ_BUFFER_SIZE];
+ int32_t output_buffer[MP3_DATA_OUTPUT_BUFFER_SIZE];
+ float total_time;
+ float elapsed_time;
+ float seek_where;
+ enum muteframe mute_frame;
+ long *frame_offsets;
+ mad_timer_t *times;
+ unsigned long highest_frame;
+ unsigned long max_frames;
+ unsigned long current_frame;
+ unsigned int drop_start_frames;
+ unsigned int drop_end_frames;
+ unsigned int drop_start_samples;
+ unsigned int drop_end_samples;
+ bool found_replay_gain;
+ bool found_xing;
+ bool found_first_frame;
+ bool decoded_first_frame;
+ unsigned long bit_rate;
+ struct decoder *decoder;
+ struct input_stream *input_stream;
+ enum mad_layer layer;
+};
+
+static void
+mp3_data_init(struct mp3_data *data, struct decoder *decoder,
+ struct input_stream *input_stream)
+{
+ data->mute_frame = MUTEFRAME_NONE;
+ data->highest_frame = 0;
+ data->max_frames = 0;
+ data->frame_offsets = NULL;
+ data->times = NULL;
+ data->current_frame = 0;
+ data->drop_start_frames = 0;
+ data->drop_end_frames = 0;
+ data->drop_start_samples = 0;
+ data->drop_end_samples = 0;
+ data->found_replay_gain = false;
+ data->found_xing = false;
+ data->found_first_frame = false;
+ data->decoded_first_frame = false;
+ data->decoder = decoder;
+ data->input_stream = input_stream;
+ data->layer = 0;
+
+ mad_stream_init(&data->stream);
+ mad_stream_options(&data->stream, MAD_OPTION_IGNORECRC);
+ mad_frame_init(&data->frame);
+ mad_synth_init(&data->synth);
+ mad_timer_reset(&data->timer);
+}
+
+static bool mp3_seek(struct mp3_data *data, long offset)
+{
+ if (!input_stream_seek(data->input_stream, offset, SEEK_SET, NULL))
+ return false;
+
+ mad_stream_buffer(&data->stream, data->input_buffer, 0);
+ (data->stream).error = 0;
+
+ return true;
+}
+
+static bool
+mp3_fill_buffer(struct mp3_data *data)
+{
+ size_t remaining, length;
+ unsigned char *dest;
+
+ if (data->stream.next_frame != NULL) {
+ remaining = data->stream.bufend - data->stream.next_frame;
+ memmove(data->input_buffer, data->stream.next_frame,
+ remaining);
+ dest = (data->input_buffer) + remaining;
+ length = READ_BUFFER_SIZE - remaining;
+ } else {
+ remaining = 0;
+ length = READ_BUFFER_SIZE;
+ dest = data->input_buffer;
+ }
+
+ /* we've exhausted the read buffer, so give up!, these potential
+ * mp3 frames are way too big, and thus unlikely to be mp3 frames */
+ if (length == 0)
+ return false;
+
+ length = decoder_read(data->decoder, data->input_stream, dest, length);
+ if (length == 0)
+ return false;
+
+ mad_stream_buffer(&data->stream, data->input_buffer,
+ length + remaining);
+ (data->stream).error = 0;
+
+ return true;
+}
+
+#ifdef HAVE_ID3TAG
+static bool
+parse_id3_replay_gain_info(struct replay_gain_info *replay_gain_info,
+ struct id3_tag *tag)
+{
+ int i;
+ char *key;
+ char *value;
+ struct id3_frame *frame;
+ bool found = false;
+
+ replay_gain_info_init(replay_gain_info);
+
+ for (i = 0; (frame = id3_tag_findframe(tag, "TXXX", i)); i++) {
+ if (frame->nfields < 3)
+ continue;
+
+ key = (char *)
+ id3_ucs4_latin1duplicate(id3_field_getstring
+ (&frame->fields[1]));
+ value = (char *)
+ id3_ucs4_latin1duplicate(id3_field_getstring
+ (&frame->fields[2]));
+
+ if (g_ascii_strcasecmp(key, "replaygain_track_gain") == 0) {
+ replay_gain_info->tuples[REPLAY_GAIN_TRACK].gain = atof(value);
+ found = true;
+ } else if (g_ascii_strcasecmp(key, "replaygain_album_gain") == 0) {
+ replay_gain_info->tuples[REPLAY_GAIN_ALBUM].gain = atof(value);
+ found = true;
+ } else if (g_ascii_strcasecmp(key, "replaygain_track_peak") == 0) {
+ replay_gain_info->tuples[REPLAY_GAIN_TRACK].peak = atof(value);
+ found = true;
+ } else if (g_ascii_strcasecmp(key, "replaygain_album_peak") == 0) {
+ replay_gain_info->tuples[REPLAY_GAIN_ALBUM].peak = atof(value);
+ found = true;
+ }
+
+ free(key);
+ free(value);
+ }
+
+ return found ||
+ /* fall back on RVA2 if no replaygain tags found */
+ tag_rva2_parse(tag, replay_gain_info);
+}
+#endif
+
+#ifdef HAVE_ID3TAG
+static bool
+parse_id3_mixramp(char **mixramp_start, char **mixramp_end,
+ struct id3_tag *tag)
+{
+ int i;
+ char *key;
+ char *value;
+ struct id3_frame *frame;
+ bool found = false;
+
+ *mixramp_start = NULL;
+ *mixramp_end = NULL;
+
+ for (i = 0; (frame = id3_tag_findframe(tag, "TXXX", i)); i++) {
+ if (frame->nfields < 3)
+ continue;
+
+ key = (char *)
+ id3_ucs4_latin1duplicate(id3_field_getstring
+ (&frame->fields[1]));
+ value = (char *)
+ id3_ucs4_latin1duplicate(id3_field_getstring
+ (&frame->fields[2]));
+
+ if (g_ascii_strcasecmp(key, "mixramp_start") == 0) {
+ *mixramp_start = g_strdup(value);
+ found = true;
+ } else if (g_ascii_strcasecmp(key, "mixramp_end") == 0) {
+ *mixramp_end = g_strdup(value);
+ found = true;
+ }
+
+ free(key);
+ free(value);
+ }
+
+ return found;
+}
+#endif
+
+static void mp3_parse_id3(struct mp3_data *data, size_t tagsize,
+ struct tag **mpd_tag)
+{
+#ifdef HAVE_ID3TAG
+ struct id3_tag *id3_tag = NULL;
+ id3_length_t count;
+ id3_byte_t const *id3_data;
+ id3_byte_t *allocated = NULL;
+
+ count = data->stream.bufend - data->stream.this_frame;
+
+ if (tagsize <= count) {
+ id3_data = data->stream.this_frame;
+ mad_stream_skip(&(data->stream), tagsize);
+ } else {
+ allocated = g_malloc(tagsize);
+ memcpy(allocated, data->stream.this_frame, count);
+ mad_stream_skip(&(data->stream), count);
+
+ while (count < tagsize) {
+ size_t len;
+
+ len = decoder_read(data->decoder, data->input_stream,
+ allocated + count, tagsize - count);
+ if (len == 0)
+ break;
+ else
+ count += len;
+ }
+
+ if (count != tagsize) {
+ g_debug("error parsing ID3 tag");
+ g_free(allocated);
+ return;
+ }
+
+ id3_data = allocated;
+ }
+
+ id3_tag = id3_tag_parse(id3_data, tagsize);
+ if (id3_tag == NULL) {
+ g_free(allocated);
+ return;
+ }
+
+ if (mpd_tag) {
+ struct tag *tmp_tag = tag_id3_import(id3_tag);
+ if (tmp_tag != NULL) {
+ if (*mpd_tag != NULL)
+ tag_free(*mpd_tag);
+ *mpd_tag = tmp_tag;
+ }
+ }
+
+ if (data->decoder != NULL) {
+ struct replay_gain_info rgi;
+ char *mixramp_start;
+ char *mixramp_end;
+ float replay_gain_db = 0;
+
+ if (parse_id3_replay_gain_info(&rgi, id3_tag)) {
+ replay_gain_db = decoder_replay_gain(data->decoder, &rgi);
+ data->found_replay_gain = true;
+ }
+ if (parse_id3_mixramp(&mixramp_start, &mixramp_end, id3_tag)) {
+ g_debug("setting mixramp_tags");
+ decoder_mixramp(data->decoder, replay_gain_db,
+ mixramp_start, mixramp_end);
+ }
+ }
+
+ id3_tag_delete(id3_tag);
+
+ g_free(allocated);
+#else /* !HAVE_ID3TAG */
+ (void)mpd_tag;
+
+ /* This code is enabled when libid3tag is disabled. Instead
+ of parsing the ID3 frame, it just skips it. */
+
+ size_t count = data->stream.bufend - data->stream.this_frame;
+
+ if (tagsize <= count) {
+ mad_stream_skip(&data->stream, tagsize);
+ } else {
+ mad_stream_skip(&data->stream, count);
+
+ while (count < tagsize) {
+ size_t len = tagsize - count;
+ char ignored[1024];
+ if (len > sizeof(ignored))
+ len = sizeof(ignored);
+
+ len = decoder_read(data->decoder, data->input_stream,
+ ignored, len);
+ if (len == 0)
+ break;
+ else
+ count += len;
+ }
+ }
+#endif
+}
+
+#ifndef HAVE_ID3TAG
+/**
+ * This function emulates libid3tag when it is disabled. Instead of
+ * doing a real analyzation of the frame, it just checks whether the
+ * frame begins with the string "ID3". If so, it returns the length
+ * of the ID3 frame.
+ */
+static signed long
+id3_tag_query(const void *p0, size_t length)
+{
+ const char *p = p0;
+
+ return length >= 10 && memcmp(p, "ID3", 3) == 0
+ ? (p[8] << 7) + p[9] + 10
+ : 0;
+}
+#endif /* !HAVE_ID3TAG */
+
+static enum mp3_action
+decode_next_frame_header(struct mp3_data *data, G_GNUC_UNUSED struct tag **tag)
+{
+ enum mad_layer layer;
+
+ if ((data->stream).buffer == NULL
+ || (data->stream).error == MAD_ERROR_BUFLEN) {
+ if (!mp3_fill_buffer(data))
+ return DECODE_BREAK;
+ }
+ if (mad_header_decode(&data->frame.header, &data->stream)) {
+ if ((data->stream).error == MAD_ERROR_LOSTSYNC &&
+ (data->stream).this_frame) {
+ signed long tagsize = id3_tag_query((data->stream).
+ this_frame,
+ (data->stream).
+ bufend -
+ (data->stream).
+ this_frame);
+
+ if (tagsize > 0) {
+ if (tag && !(*tag)) {
+ mp3_parse_id3(data, (size_t)tagsize,
+ tag);
+ } else {
+ mad_stream_skip(&(data->stream),
+ tagsize);
+ }
+ return DECODE_CONT;
+ }
+ }
+ if (MAD_RECOVERABLE((data->stream).error)) {
+ return DECODE_SKIP;
+ } else {
+ if ((data->stream).error == MAD_ERROR_BUFLEN)
+ return DECODE_CONT;
+ else {
+ g_warning("unrecoverable frame level error "
+ "(%s).\n",
+ mad_stream_errorstr(&data->stream));
+ return DECODE_BREAK;
+ }
+ }
+ }
+
+ layer = data->frame.header.layer;
+ if (!data->layer) {
+ if (layer != MAD_LAYER_II && layer != MAD_LAYER_III) {
+ /* Only layer 2 and 3 have been tested to work */
+ return DECODE_SKIP;
+ }
+ data->layer = layer;
+ } else if (layer != data->layer) {
+ /* Don't decode frames with a different layer than the first */
+ return DECODE_SKIP;
+ }
+
+ return DECODE_OK;
+}
+
+static enum mp3_action
+decodeNextFrame(struct mp3_data *data)
+{
+ if ((data->stream).buffer == NULL
+ || (data->stream).error == MAD_ERROR_BUFLEN) {
+ if (!mp3_fill_buffer(data))
+ return DECODE_BREAK;
+ }
+ if (mad_frame_decode(&data->frame, &data->stream)) {
+ if ((data->stream).error == MAD_ERROR_LOSTSYNC) {
+ signed long tagsize = id3_tag_query((data->stream).
+ this_frame,
+ (data->stream).
+ bufend -
+ (data->stream).
+ this_frame);
+ if (tagsize > 0) {
+ mad_stream_skip(&(data->stream), tagsize);
+ return DECODE_CONT;
+ }
+ }
+ if (MAD_RECOVERABLE((data->stream).error)) {
+ return DECODE_SKIP;
+ } else {
+ if ((data->stream).error == MAD_ERROR_BUFLEN)
+ return DECODE_CONT;
+ else {
+ g_warning("unrecoverable frame level error "
+ "(%s).\n",
+ mad_stream_errorstr(&data->stream));
+ return DECODE_BREAK;
+ }
+ }
+ }
+
+ return DECODE_OK;
+}
+
+/* xing stuff stolen from alsaplayer, and heavily modified by jat */
+#define XI_MAGIC (('X' << 8) | 'i')
+#define NG_MAGIC (('n' << 8) | 'g')
+#define IN_MAGIC (('I' << 8) | 'n')
+#define FO_MAGIC (('f' << 8) | 'o')
+
+enum xing_magic {
+ XING_MAGIC_XING, /* VBR */
+ XING_MAGIC_INFO /* CBR */
+};
+
+struct xing {
+ long flags; /* valid fields (see below) */
+ unsigned long frames; /* total number of frames */
+ unsigned long bytes; /* total number of bytes */
+ unsigned char toc[100]; /* 100-point seek table */
+ long scale; /* VBR quality */
+ enum xing_magic magic; /* header magic */
+};
+
+enum {
+ XING_FRAMES = 0x00000001L,
+ XING_BYTES = 0x00000002L,
+ XING_TOC = 0x00000004L,
+ XING_SCALE = 0x00000008L
+};
+
+struct version {
+ unsigned major;
+ unsigned minor;
+};
+
+struct lame {
+ char encoder[10]; /* 9 byte encoder name/version ("LAME3.97b") */
+ struct version version; /* struct containing just the version */
+ float peak; /* replaygain peak */
+ float track_gain; /* replaygain track gain */
+ float album_gain; /* replaygain album gain */
+ int encoder_delay; /* # of added samples at start of mp3 */
+ int encoder_padding; /* # of added samples at end of mp3 */
+ int crc; /* CRC of the first 190 bytes of this frame */
+};
+
+static bool
+parse_xing(struct xing *xing, struct mad_bitptr *ptr, int *oldbitlen)
+{
+ unsigned long bits;
+ int bitlen;
+ int bitsleft;
+ int i;
+
+ bitlen = *oldbitlen;
+
+ if (bitlen < 16)
+ return false;
+
+ bits = mad_bit_read(ptr, 16);
+ bitlen -= 16;
+
+ if (bits == XI_MAGIC) {
+ if (bitlen < 16)
+ return false;
+
+ if (mad_bit_read(ptr, 16) != NG_MAGIC)
+ return false;
+
+ bitlen -= 16;
+ xing->magic = XING_MAGIC_XING;
+ } else if (bits == IN_MAGIC) {
+ if (bitlen < 16)
+ return false;
+
+ if (mad_bit_read(ptr, 16) != FO_MAGIC)
+ return false;
+
+ bitlen -= 16;
+ xing->magic = XING_MAGIC_INFO;
+ }
+ else if (bits == NG_MAGIC) xing->magic = XING_MAGIC_XING;
+ else if (bits == FO_MAGIC) xing->magic = XING_MAGIC_INFO;
+ else
+ return false;
+
+ if (bitlen < 32)
+ return false;
+ xing->flags = mad_bit_read(ptr, 32);
+ bitlen -= 32;
+
+ if (xing->flags & XING_FRAMES) {
+ if (bitlen < 32)
+ return false;
+ xing->frames = mad_bit_read(ptr, 32);
+ bitlen -= 32;
+ }
+
+ if (xing->flags & XING_BYTES) {
+ if (bitlen < 32)
+ return false;
+ xing->bytes = mad_bit_read(ptr, 32);
+ bitlen -= 32;
+ }
+
+ if (xing->flags & XING_TOC) {
+ if (bitlen < 800)
+ return false;
+ for (i = 0; i < 100; ++i) xing->toc[i] = mad_bit_read(ptr, 8);
+ bitlen -= 800;
+ }
+
+ if (xing->flags & XING_SCALE) {
+ if (bitlen < 32)
+ return false;
+ xing->scale = mad_bit_read(ptr, 32);
+ bitlen -= 32;
+ }
+
+ /* Make sure we consume no less than 120 bytes (960 bits) in hopes that
+ * the LAME tag is found there, and not right after the Xing header */
+ bitsleft = 960 - ((*oldbitlen) - bitlen);
+ if (bitsleft < 0)
+ return false;
+ else if (bitsleft > 0) {
+ mad_bit_read(ptr, bitsleft);
+ bitlen -= bitsleft;
+ }
+
+ *oldbitlen = bitlen;
+
+ return true;
+}
+
+static bool
+parse_lame(struct lame *lame, struct mad_bitptr *ptr, int *bitlen)
+{
+ int adj = 0;
+ int name;
+ int orig;
+ int sign;
+ int gain;
+ int i;
+
+ /* Unlike the xing header, the lame tag has a fixed length. Fail if
+ * not all 36 bytes (288 bits) are there. */
+ if (*bitlen < 288)
+ return false;
+
+ for (i = 0; i < 9; i++)
+ lame->encoder[i] = (char)mad_bit_read(ptr, 8);
+ lame->encoder[9] = '\0';
+
+ *bitlen -= 72;
+
+ /* This is technically incorrect, since the encoder might not be lame.
+ * But there's no other way to determine if this is a lame tag, and we
+ * wouldn't want to go reading a tag that's not there. */
+ if (!g_str_has_prefix(lame->encoder, "LAME"))
+ return false;
+
+ if (sscanf(lame->encoder+4, "%u.%u",
+ &lame->version.major, &lame->version.minor) != 2)
+ return false;
+
+ g_debug("detected LAME version %i.%i (\"%s\")\n",
+ lame->version.major, lame->version.minor, lame->encoder);
+
+ /* The reference volume was changed from the 83dB used in the
+ * ReplayGain spec to 89dB in lame 3.95.1. Bump the gain for older
+ * versions, since everyone else uses 89dB instead of 83dB.
+ * Unfortunately, lame didn't differentiate between 3.95 and 3.95.1, so
+ * it's impossible to make the proper adjustment for 3.95.
+ * Fortunately, 3.95 was only out for about a day before 3.95.1 was
+ * released. -- tmz */
+ if (lame->version.major < 3 ||
+ (lame->version.major == 3 && lame->version.minor < 95))
+ adj = 6;
+
+ mad_bit_read(ptr, 16);
+
+ lame->peak = mad_f_todouble(mad_bit_read(ptr, 32) << 5); /* peak */
+ g_debug("LAME peak found: %f\n", lame->peak);
+
+ lame->track_gain = 0;
+ name = mad_bit_read(ptr, 3); /* gain name */
+ orig = mad_bit_read(ptr, 3); /* gain originator */
+ sign = mad_bit_read(ptr, 1); /* sign bit */
+ gain = mad_bit_read(ptr, 9); /* gain*10 */
+ if (gain && name == 1 && orig != 0) {
+ lame->track_gain = ((sign ? -gain : gain) / 10.0) + adj;
+ g_debug("LAME track gain found: %f\n", lame->track_gain);
+ }
+
+ /* tmz reports that this isn't currently written by any version of lame
+ * (as of 3.97). Since we have no way of testing it, don't use it.
+ * Wouldn't want to go blowing someone's ears just because we read it
+ * wrong. :P -- jat */
+ lame->album_gain = 0;
+#if 0
+ name = mad_bit_read(ptr, 3); /* gain name */
+ orig = mad_bit_read(ptr, 3); /* gain originator */
+ sign = mad_bit_read(ptr, 1); /* sign bit */
+ gain = mad_bit_read(ptr, 9); /* gain*10 */
+ if (gain && name == 2 && orig != 0) {
+ lame->album_gain = ((sign ? -gain : gain) / 10.0) + adj;
+ g_debug("LAME album gain found: %f\n", lame->track_gain);
+ }
+#else
+ mad_bit_read(ptr, 16);
+#endif
+
+ mad_bit_read(ptr, 16);
+
+ lame->encoder_delay = mad_bit_read(ptr, 12);
+ lame->encoder_padding = mad_bit_read(ptr, 12);
+
+ g_debug("encoder delay is %i, encoder padding is %i\n",
+ lame->encoder_delay, lame->encoder_padding);
+
+ mad_bit_read(ptr, 80);
+
+ lame->crc = mad_bit_read(ptr, 16);
+
+ *bitlen -= 216;
+
+ return true;
+}
+
+static inline float
+mp3_frame_duration(const struct mad_frame *frame)
+{
+ return mad_timer_count(frame->header.duration,
+ MAD_UNITS_MILLISECONDS) / 1000.0;
+}
+
+static goffset
+mp3_this_frame_offset(const struct mp3_data *data)
+{
+ goffset offset = data->input_stream->offset;
+
+ if (data->stream.this_frame != NULL)
+ offset -= data->stream.bufend - data->stream.this_frame;
+ else
+ offset -= data->stream.bufend - data->stream.buffer;
+
+ return offset;
+}
+
+static goffset
+mp3_rest_including_this_frame(const struct mp3_data *data)
+{
+ return data->input_stream->size - mp3_this_frame_offset(data);
+}
+
+/**
+ * Attempt to calulcate the length of the song from filesize
+ */
+static void
+mp3_filesize_to_song_length(struct mp3_data *data)
+{
+ goffset rest = mp3_rest_including_this_frame(data);
+
+ if (rest > 0) {
+ float frame_duration = mp3_frame_duration(&data->frame);
+
+ data->total_time = (rest * 8.0) / (data->frame).header.bitrate;
+ data->max_frames = data->total_time / frame_duration +
+ FRAMES_CUSHION;
+ } else {
+ data->max_frames = FRAMES_CUSHION;
+ data->total_time = 0;
+ }
+}
+
+static bool
+mp3_decode_first_frame(struct mp3_data *data, struct tag **tag)
+{
+ struct xing xing;
+ struct lame lame;
+ struct mad_bitptr ptr;
+ int bitlen;
+ enum mp3_action ret;
+
+ /* stfu gcc */
+ memset(&xing, 0, sizeof(struct xing));
+ xing.flags = 0;
+
+ while (true) {
+ do {
+ ret = decode_next_frame_header(data, tag);
+ } while (ret == DECODE_CONT);
+ if (ret == DECODE_BREAK)
+ return false;
+ if (ret == DECODE_SKIP) continue;
+
+ do {
+ ret = decodeNextFrame(data);
+ } while (ret == DECODE_CONT);
+ if (ret == DECODE_BREAK)
+ return false;
+ if (ret == DECODE_OK) break;
+ }
+
+ ptr = data->stream.anc_ptr;
+ bitlen = data->stream.anc_bitlen;
+
+ mp3_filesize_to_song_length(data);
+
+ /*
+ * if an xing tag exists, use that!
+ */
+ if (parse_xing(&xing, &ptr, &bitlen)) {
+ data->found_xing = true;
+ data->mute_frame = MUTEFRAME_SKIP;
+
+ if ((xing.flags & XING_FRAMES) && xing.frames) {
+ mad_timer_t duration = data->frame.header.duration;
+ mad_timer_multiply(&duration, xing.frames);
+ data->total_time = ((float)mad_timer_count(duration, MAD_UNITS_MILLISECONDS)) / 1000;
+ data->max_frames = xing.frames;
+ }
+
+ if (parse_lame(&lame, &ptr, &bitlen)) {
+ if (gapless_playback &&
+ data->input_stream->seekable) {
+ data->drop_start_samples = lame.encoder_delay +
+ DECODERDELAY;
+ data->drop_end_samples = lame.encoder_padding;
+ }
+
+ /* Album gain isn't currently used. See comment in
+ * parse_lame() for details. -- jat */
+ if (data->decoder != NULL &&
+ !data->found_replay_gain &&
+ lame.track_gain) {
+ struct replay_gain_info rgi;
+ replay_gain_info_init(&rgi);
+ rgi.tuples[REPLAY_GAIN_TRACK].gain = lame.track_gain;
+ rgi.tuples[REPLAY_GAIN_TRACK].peak = lame.peak;
+ decoder_replay_gain(data->decoder, &rgi);
+ }
+ }
+ }
+
+ if (!data->max_frames)
+ return false;
+
+ if (data->max_frames > 8 * 1024 * 1024) {
+ g_warning("mp3 file header indicates too many frames: %lu\n",
+ data->max_frames);
+ return false;
+ }
+
+ data->frame_offsets = g_malloc(sizeof(long) * data->max_frames);
+ data->times = g_malloc(sizeof(mad_timer_t) * data->max_frames);
+
+ return true;
+}
+
+static void mp3_data_finish(struct mp3_data *data)
+{
+ mad_synth_finish(&data->synth);
+ mad_frame_finish(&data->frame);
+ mad_stream_finish(&data->stream);
+
+ g_free(data->frame_offsets);
+ g_free(data->times);
+}
+
+/* this is primarily used for getting total time for tags */
+static int
+mad_decoder_total_file_time(struct input_stream *is)
+{
+ struct mp3_data data;
+ int ret;
+
+ mp3_data_init(&data, NULL, is);
+ if (!mp3_decode_first_frame(&data, NULL))
+ ret = -1;
+ else
+ ret = data.total_time + 0.5;
+ mp3_data_finish(&data);
+
+ return ret;
+}
+
+static bool
+mp3_open(struct input_stream *is, struct mp3_data *data,
+ struct decoder *decoder, struct tag **tag)
+{
+ mp3_data_init(data, decoder, is);
+ *tag = NULL;
+ if (!mp3_decode_first_frame(data, tag)) {
+ mp3_data_finish(data);
+ if (tag && *tag)
+ tag_free(*tag);
+ return false;
+ }
+
+ return true;
+}
+
+static long
+mp3_time_to_frame(const struct mp3_data *data, double t)
+{
+ unsigned long i;
+
+ for (i = 0; i < data->highest_frame; ++i) {
+ double frame_time =
+ mad_timer_count(data->times[i],
+ MAD_UNITS_MILLISECONDS) / 1000.;
+ if (frame_time >= t)
+ break;
+ }
+
+ return i;
+}
+
+static void
+mp3_update_timer_next_frame(struct mp3_data *data)
+{
+ if (data->current_frame >= data->highest_frame) {
+ /* record this frame's properties in
+ data->frame_offsets (for seeking) and
+ data->times */
+ data->bit_rate = (data->frame).header.bitrate;
+
+ if (data->current_frame >= data->max_frames)
+ /* cap data->current_frame */
+ data->current_frame = data->max_frames - 1;
+ else
+ data->highest_frame++;
+
+ data->frame_offsets[data->current_frame] =
+ mp3_this_frame_offset(data);
+
+ mad_timer_add(&data->timer, (data->frame).header.duration);
+ data->times[data->current_frame] = data->timer;
+ } else
+ /* get the new timer value from data->times */
+ data->timer = data->times[data->current_frame];
+
+ data->current_frame++;
+ data->elapsed_time =
+ mad_timer_count(data->timer, MAD_UNITS_MILLISECONDS) / 1000.0;
+}
+
+/**
+ * Sends the synthesized current frame via decoder_data().
+ */
+static enum decoder_command
+mp3_send_pcm(struct mp3_data *data, unsigned i, unsigned pcm_length)
+{
+ unsigned max_samples;
+
+ max_samples = sizeof(data->output_buffer) /
+ sizeof(data->output_buffer[0]) /
+ MAD_NCHANNELS(&(data->frame).header);
+
+ while (i < pcm_length) {
+ enum decoder_command cmd;
+ unsigned int num_samples = pcm_length - i;
+ if (num_samples > max_samples)
+ num_samples = max_samples;
+
+ i += num_samples;
+
+ mad_fixed_to_24_buffer(data->output_buffer,
+ &data->synth,
+ i - num_samples, i,
+ MAD_NCHANNELS(&(data->frame).header));
+ num_samples *= MAD_NCHANNELS(&(data->frame).header);
+
+ cmd = decoder_data(data->decoder, data->input_stream,
+ data->output_buffer,
+ sizeof(data->output_buffer[0]) * num_samples,
+ data->bit_rate / 1000);
+ if (cmd != DECODE_COMMAND_NONE)
+ return cmd;
+ }
+
+ return DECODE_COMMAND_NONE;
+}
+
+/**
+ * Synthesize the current frame and send it via decoder_data().
+ */
+static enum decoder_command
+mp3_synth_and_send(struct mp3_data *data)
+{
+ unsigned i, pcm_length;
+ enum decoder_command cmd;
+
+ mad_synth_frame(&data->synth, &data->frame);
+
+ if (!data->found_first_frame) {
+ unsigned int samples_per_frame = data->synth.pcm.length;
+ data->drop_start_frames = data->drop_start_samples / samples_per_frame;
+ data->drop_end_frames = data->drop_end_samples / samples_per_frame;
+ data->drop_start_samples = data->drop_start_samples % samples_per_frame;
+ data->drop_end_samples = data->drop_end_samples % samples_per_frame;
+ data->found_first_frame = true;
+ }
+
+ if (data->drop_start_frames > 0) {
+ data->drop_start_frames--;
+ return DECODE_COMMAND_NONE;
+ } else if ((data->drop_end_frames > 0) &&
+ (data->current_frame == (data->max_frames + 1 - data->drop_end_frames))) {
+ /* stop decoding, effectively dropping all remaining
+ frames */
+ return DECODE_COMMAND_STOP;
+ }
+
+ if (!data->decoded_first_frame) {
+ i = data->drop_start_samples;
+ data->decoded_first_frame = true;
+ } else
+ i = 0;
+
+ pcm_length = data->synth.pcm.length;
+ if (data->drop_end_samples &&
+ (data->current_frame == data->max_frames - data->drop_end_frames)) {
+ if (data->drop_end_samples >= pcm_length)
+ pcm_length = 0;
+ else
+ pcm_length -= data->drop_end_samples;
+ }
+
+ cmd = mp3_send_pcm(data, i, pcm_length);
+ if (cmd != DECODE_COMMAND_NONE)
+ return cmd;
+
+ if (data->drop_end_samples &&
+ (data->current_frame == data->max_frames - data->drop_end_frames))
+ /* stop decoding, effectively dropping
+ * all remaining samples */
+ return DECODE_COMMAND_STOP;
+
+ return DECODE_COMMAND_NONE;
+}
+
+static bool
+mp3_read(struct mp3_data *data)
+{
+ struct decoder *decoder = data->decoder;
+ enum mp3_action ret;
+ enum decoder_command cmd;
+
+ mp3_update_timer_next_frame(data);
+
+ switch (data->mute_frame) {
+ case MUTEFRAME_SKIP:
+ data->mute_frame = MUTEFRAME_NONE;
+ break;
+ case MUTEFRAME_SEEK:
+ if (data->elapsed_time >= data->seek_where)
+ data->mute_frame = MUTEFRAME_NONE;
+ break;
+ case MUTEFRAME_NONE:
+ cmd = mp3_synth_and_send(data);
+ if (cmd == DECODE_COMMAND_SEEK) {
+ unsigned long j;
+
+ assert(data->input_stream->seekable);
+
+ j = mp3_time_to_frame(data,
+ decoder_seek_where(decoder));
+ if (j < data->highest_frame) {
+ if (mp3_seek(data, data->frame_offsets[j])) {
+ data->current_frame = j;
+ decoder_command_finished(decoder);
+ } else
+ decoder_seek_error(decoder);
+ } else {
+ data->seek_where = decoder_seek_where(decoder);
+ data->mute_frame = MUTEFRAME_SEEK;
+ decoder_command_finished(decoder);
+ }
+ } else if (cmd != DECODE_COMMAND_NONE)
+ return false;
+ }
+
+ while (true) {
+ bool skip = false;
+
+ do {
+ struct tag *tag = NULL;
+
+ ret = decode_next_frame_header(data, &tag);
+
+ if (tag != NULL) {
+ decoder_tag(decoder, data->input_stream, tag);
+ tag_free(tag);
+ }
+ } while (ret == DECODE_CONT);
+ if (ret == DECODE_BREAK)
+ return false;
+ else if (ret == DECODE_SKIP)
+ skip = true;
+
+ if (data->mute_frame == MUTEFRAME_NONE) {
+ do {
+ ret = decodeNextFrame(data);
+ } while (ret == DECODE_CONT);
+ if (ret == DECODE_BREAK)
+ return false;
+ }
+
+ if (!skip && ret == DECODE_OK)
+ break;
+ }
+
+ return ret != DECODE_BREAK;
+}
+
+static void
+mp3_decode(struct decoder *decoder, struct input_stream *input_stream)
+{
+ struct mp3_data data;
+ GError *error = NULL;
+ struct tag *tag = NULL;
+ struct audio_format audio_format;
+
+ if (!mp3_open(input_stream, &data, decoder, &tag)) {
+ if (decoder_get_command(decoder) == DECODE_COMMAND_NONE)
+ g_warning
+ ("Input does not appear to be a mp3 bit stream.\n");
+ return;
+ }
+
+ if (!audio_format_init_checked(&audio_format,
+ data.frame.header.samplerate,
+ SAMPLE_FORMAT_S24_P32,
+ MAD_NCHANNELS(&data.frame.header),
+ &error)) {
+ g_warning("%s", error->message);
+ g_error_free(error);
+
+ if (tag != NULL)
+ tag_free(tag);
+ mp3_data_finish(&data);
+ return;
+ }
+
+ decoder_initialized(decoder, &audio_format,
+ data.input_stream->seekable, data.total_time);
+
+ if (tag != NULL) {
+ decoder_tag(decoder, input_stream, tag);
+ tag_free(tag);
+ }
+
+ while (mp3_read(&data)) ;
+
+ mp3_data_finish(&data);
+}
+
+static struct tag *
+mad_decoder_stream_tag(struct input_stream *is)
+{
+ struct tag *tag;
+ int total_time;
+
+ total_time = mad_decoder_total_file_time(is);
+ if (total_time < 0)
+ return NULL;
+
+ tag = tag_new();
+ tag->time = total_time;
+ return tag;
+}
+
+static const char *const mp3_suffixes[] = { "mp3", "mp2", NULL };
+static const char *const mp3_mime_types[] = { "audio/mpeg", NULL };
+
+const struct decoder_plugin mad_decoder_plugin = {
+ .name = "mad",
+ .init = mp3_plugin_init,
+ .stream_decode = mp3_decode,
+ .stream_tag = mad_decoder_stream_tag,
+ .suffixes = mp3_suffixes,
+ .mime_types = mp3_mime_types
+};