1 /* MP3 decoding plugin for GStreamer using the mpg123 library
2 * Copyright (C) 2012 Carlos Rafael Giani
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23 #include "gstmpg123audiodec.h"
28 GST_DEBUG_CATEGORY_STATIC (mpg123_debug);
29 #define GST_CAT_DEFAULT mpg123_debug
31 /* Omitted sample formats that mpg123 supports (or at least can support):
32 * - 8bit integer signed
33 * - 8bit integer unsigned
38 * The first four formats are not supported by the GstAudioDecoder base class.
39 * (The internal gst_audio_format_from_caps_structure() call fails.)
41 * The 64bit float issue is tricky. mpg123 actually decodes to "real",
42 * not necessarily to "float".
44 * "real" can be fixed point, 32bit float, 64bit float. There seems to be
45 * no way how to find out which one of them is actually used.
47 * However, in all known installations, "real" equals 32bit float, so that's
50 static GstStaticPadTemplate static_sink_template =
51 GST_STATIC_PAD_TEMPLATE ("sink",
54 GST_STATIC_CAPS ("audio/mpeg, "
55 "mpegversion = (int) { 1 }, "
56 "layer = (int) [ 1, 3 ], "
57 "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, "
58 "channels = (int) [ 1, 2 ], " "parsed = (boolean) true ")
61 static void gst_mpg123_audio_dec_finalize (GObject * object);
62 static gboolean gst_mpg123_audio_dec_start (GstAudioDecoder * dec);
63 static gboolean gst_mpg123_audio_dec_stop (GstAudioDecoder * dec);
64 static GstFlowReturn gst_mpg123_audio_dec_push_decoded_bytes (GstMpg123AudioDec
65 * mpg123_decoder, unsigned char const *decoded_bytes,
66 size_t const num_decoded_bytes);
67 static GstFlowReturn gst_mpg123_audio_dec_handle_frame (GstAudioDecoder * dec,
68 GstBuffer * input_buffer);
69 static gboolean gst_mpg123_audio_dec_set_format (GstAudioDecoder * dec,
70 GstCaps * input_caps);
71 static void gst_mpg123_audio_dec_flush (GstAudioDecoder * dec, gboolean hard);
73 G_DEFINE_TYPE (GstMpg123AudioDec, gst_mpg123_audio_dec, GST_TYPE_AUDIO_DECODER);
76 gst_mpg123_audio_dec_class_init (GstMpg123AudioDecClass * klass)
78 GObjectClass *object_class;
79 GstAudioDecoderClass *base_class;
80 GstElementClass *element_class;
81 GstPadTemplate *src_template, *sink_template;
84 GST_DEBUG_CATEGORY_INIT (mpg123_debug, "mpg123", 0, "mpg123 mp3 decoder");
86 object_class = G_OBJECT_CLASS (klass);
87 base_class = GST_AUDIO_DECODER_CLASS (klass);
88 element_class = GST_ELEMENT_CLASS (klass);
90 object_class->finalize = gst_mpg123_audio_dec_finalize;
92 gst_element_class_set_static_metadata (element_class,
94 "Codec/Decoder/Audio",
95 "Decodes mp3 streams using the mpg123 library",
96 "Carlos Rafael Giani <dv@pseudoterminal.org>");
98 /* Not using static pad template for srccaps, since the comma-separated list
99 * of formats needs to be created depending on whatever mpg123 supports */
101 const int *format_list;
102 const long *rates_list;
105 GstCaps *src_template_caps;
107 s = g_string_new ("audio/x-raw, ");
109 mpg123_encodings (&format_list, &num);
110 g_string_append (s, "format = { ");
111 for (i = 0; i < num; ++i) {
112 switch (format_list[i]) {
113 case MPG123_ENC_SIGNED_16:
114 g_string_append (s, (i > 0) ? ", " : "");
115 g_string_append (s, GST_AUDIO_NE (S16));
117 case MPG123_ENC_UNSIGNED_16:
118 g_string_append (s, (i > 0) ? ", " : "");
119 g_string_append (s, GST_AUDIO_NE (U16));
121 case MPG123_ENC_SIGNED_24:
122 g_string_append (s, (i > 0) ? ", " : "");
123 g_string_append (s, GST_AUDIO_NE (S24));
125 case MPG123_ENC_UNSIGNED_24:
126 g_string_append (s, (i > 0) ? ", " : "");
127 g_string_append (s, GST_AUDIO_NE (U24));
129 case MPG123_ENC_SIGNED_32:
130 g_string_append (s, (i > 0) ? ", " : "");
131 g_string_append (s, GST_AUDIO_NE (S32));
133 case MPG123_ENC_UNSIGNED_32:
134 g_string_append (s, (i > 0) ? ", " : "");
135 g_string_append (s, GST_AUDIO_NE (U32));
137 case MPG123_ENC_FLOAT_32:
138 g_string_append (s, (i > 0) ? ", " : "");
139 g_string_append (s, GST_AUDIO_NE (F32));
142 GST_DEBUG ("Ignoring mpg123 format %d", format_list[i]);
146 g_string_append (s, " }, ");
148 mpg123_rates (&rates_list, &num);
149 g_string_append (s, "rate = (int) { ");
150 for (i = 0; i < num; ++i) {
151 g_string_append_printf (s, "%s%lu", (i > 0) ? ", " : "", rates_list[i]);
153 g_string_append (s, "}, ");
155 g_string_append (s, "channels = (int) [ 1, 2 ], ");
156 g_string_append (s, "layout = (string) interleaved");
158 src_template_caps = gst_caps_from_string (s->str);
159 src_template = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
162 g_string_free (s, TRUE);
165 sink_template = gst_static_pad_template_get (&static_sink_template);
167 gst_element_class_add_pad_template (element_class, sink_template);
168 gst_element_class_add_pad_template (element_class, src_template);
170 base_class->start = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_start);
171 base_class->stop = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_stop);
172 base_class->handle_frame =
173 GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_handle_frame);
174 base_class->set_format = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_set_format);
175 base_class->flush = GST_DEBUG_FUNCPTR (gst_mpg123_audio_dec_flush);
177 error = mpg123_init ();
178 if (G_UNLIKELY (error != MPG123_OK))
179 GST_ERROR ("Could not initialize mpg123 library: %s",
180 mpg123_plain_strerror (error));
182 GST_INFO ("mpg123 library initialized");
187 gst_mpg123_audio_dec_init (GstMpg123AudioDec * mpg123_decoder)
189 mpg123_decoder->handle = NULL;
194 gst_mpg123_audio_dec_finalize (GObject * object)
196 GstMpg123AudioDec *mpg123_decoder = GST_MPG123_AUDIO_DEC (object);
197 if (G_LIKELY (mpg123_decoder->handle != NULL)) {
198 mpg123_delete (mpg123_decoder->handle);
199 mpg123_decoder->handle = NULL;
205 gst_mpg123_audio_dec_start (GstAudioDecoder * dec)
207 GstMpg123AudioDec *mpg123_decoder;
210 mpg123_decoder = GST_MPG123_AUDIO_DEC (dec);
213 mpg123_decoder->handle = mpg123_new (NULL, &error);
214 mpg123_decoder->has_next_audioinfo = FALSE;
215 mpg123_decoder->frame_offset = 0;
217 /* Initially, the mpg123 handle comes with a set of default formats
218 * supported. This clears this set. This is necessary, since only one
219 * format shall be supported (see set_format for more). */
220 mpg123_format_none (mpg123_decoder->handle);
222 /* Built-in mpg123 support for gapless decoding is disabled for now,
223 * since it does not work well with seeking */
224 mpg123_param (mpg123_decoder->handle, MPG123_REMOVE_FLAGS, MPG123_GAPLESS, 0);
225 /* Tells mpg123 to use a small read-ahead buffer for better MPEG sync;
226 * essential for MP3 radio streams */
227 mpg123_param (mpg123_decoder->handle, MPG123_ADD_FLAGS, MPG123_SEEKBUFFER, 0);
228 /* Sets the resync limit to the end of the stream (otherwise mpg123 may give
229 * up on decoding prematurely, especially with mp3 web radios) */
230 mpg123_param (mpg123_decoder->handle, MPG123_RESYNC_LIMIT, -1, 0);
231 /* Don't let mpg123 resample output */
232 mpg123_param (mpg123_decoder->handle, MPG123_REMOVE_FLAGS,
233 MPG123_AUTO_RESAMPLE, 0);
234 /* Don't let mpg123 print messages to stdout/stderr */
235 mpg123_param (mpg123_decoder->handle, MPG123_ADD_FLAGS, MPG123_QUIET, 0);
237 /* Open in feed mode (= encoded data is fed manually into the handle). */
238 error = mpg123_open_feed (mpg123_decoder->handle);
240 if (G_UNLIKELY (error != MPG123_OK)) {
241 GST_ELEMENT_ERROR (dec, LIBRARY, INIT, (NULL),
242 ("%s", mpg123_strerror (mpg123_decoder->handle)));
243 mpg123_close (mpg123_decoder->handle);
244 mpg123_delete (mpg123_decoder->handle);
245 mpg123_decoder->handle = NULL;
249 GST_INFO_OBJECT (dec, "mpg123 decoder started");
256 gst_mpg123_audio_dec_stop (GstAudioDecoder * dec)
258 GstMpg123AudioDec *mpg123_decoder = GST_MPG123_AUDIO_DEC (dec);
260 if (G_LIKELY (mpg123_decoder->handle != NULL)) {
261 mpg123_close (mpg123_decoder->handle);
262 mpg123_delete (mpg123_decoder->handle);
263 mpg123_decoder->handle = NULL;
266 GST_INFO_OBJECT (dec, "mpg123 decoder stopped");
273 gst_mpg123_audio_dec_push_decoded_bytes (GstMpg123AudioDec * mpg123_decoder,
274 unsigned char const *decoded_bytes, size_t const num_decoded_bytes)
276 GstBuffer *output_buffer;
277 GstAudioDecoder *dec;
279 output_buffer = NULL;
280 dec = GST_AUDIO_DECODER (mpg123_decoder);
282 if ((num_decoded_bytes == 0) || (decoded_bytes == NULL)) {
283 /* This occurs in the first few frames, which do not carry data; once
284 * MPG123_AUDIO_DEC_NEW_FORMAT is received, the empty frames stop occurring */
285 GST_DEBUG_OBJECT (mpg123_decoder,
286 "cannot decode yet, need more data -> no output buffer to push");
290 output_buffer = gst_buffer_new_allocate (NULL, num_decoded_bytes, NULL);
292 if (output_buffer == NULL) {
293 /* This is necessary to advance playback in time,
294 * even when nothing was decoded. */
295 return gst_audio_decoder_finish_frame (dec, NULL, 1);
299 if (gst_buffer_map (output_buffer, &info, GST_MAP_WRITE)) {
300 memcpy (info.data, decoded_bytes, num_decoded_bytes);
301 gst_buffer_unmap (output_buffer, &info);
303 GST_ERROR_OBJECT (mpg123_decoder, "gst_buffer_map() returned NULL");
304 gst_buffer_unref (output_buffer);
305 output_buffer = NULL;
308 return gst_audio_decoder_finish_frame (dec, output_buffer, 1);
314 gst_mpg123_audio_dec_handle_frame (GstAudioDecoder * dec,
315 GstBuffer * input_buffer)
317 GstMpg123AudioDec *mpg123_decoder;
319 unsigned char *decoded_bytes;
320 size_t num_decoded_bytes;
321 GstFlowReturn retval;
323 mpg123_decoder = GST_MPG123_AUDIO_DEC (dec);
325 g_assert (mpg123_decoder->handle != NULL);
327 /* The actual decoding */
329 /* feed input data (if there is any) */
330 if (G_LIKELY (input_buffer != NULL)) {
333 if (gst_buffer_map (input_buffer, &info, GST_MAP_READ)) {
334 mpg123_feed (mpg123_decoder->handle, info.data, info.size);
335 gst_buffer_unmap (input_buffer, &info);
337 GST_ERROR_OBJECT (mpg123_decoder, "gst_memory_map() failed");
338 return GST_FLOW_ERROR;
342 /* Try to decode a frame */
343 decoded_bytes = NULL;
344 num_decoded_bytes = 0;
345 decode_error = mpg123_decode_frame (mpg123_decoder->handle,
346 &mpg123_decoder->frame_offset, &decoded_bytes, &num_decoded_bytes);
349 retval = GST_FLOW_OK;
351 switch (decode_error) {
352 case MPG123_NEW_FORMAT:
353 /* As mentioned in gst_mpg123_audio_dec_set_format(), the next audioinfo
354 * is not set immediately; instead, the code waits for mpg123 to take
355 * note of the new format, and then sets the audioinfo. This fixes glitches
356 * with mp3s containing several format headers (for example, first half
357 * using 44.1kHz, second half 32 kHz) */
360 "mpg123 reported a new format -> setting next srccaps");
362 gst_mpg123_audio_dec_push_decoded_bytes (mpg123_decoder, decoded_bytes,
365 /* If there is a next audioinfo, use it, then set has_next_audioinfo to
366 * FALSE, to make sure gst_audio_decoder_set_output_format() isn't called
367 * again until set_format is called by the base class */
368 if (mpg123_decoder->has_next_audioinfo) {
369 if (!gst_audio_decoder_set_output_format (dec,
370 &(mpg123_decoder->next_audioinfo))) {
371 GST_WARNING_OBJECT (dec, "Unable to set output format");
372 retval = GST_FLOW_NOT_NEGOTIATED;
374 mpg123_decoder->has_next_audioinfo = FALSE;
379 case MPG123_NEED_MORE:
381 retval = gst_mpg123_audio_dec_push_decoded_bytes (mpg123_decoder,
382 decoded_bytes, num_decoded_bytes);
386 /* If this happens, then the upstream parser somehow missed the ending
387 * of the bitstream */
388 GST_LOG_OBJECT (dec, "mpg123 is done decoding");
389 gst_mpg123_audio_dec_push_decoded_bytes (mpg123_decoder, decoded_bytes,
391 retval = GST_FLOW_EOS;
396 /* Anything else is considered an error */
398 switch (decode_error) {
400 errcode = mpg123_errcode (mpg123_decoder->handle);
403 errcode = decode_error;
406 case MPG123_BAD_OUTFORMAT:{
407 GstCaps *input_caps =
408 gst_pad_get_current_caps (GST_AUDIO_DECODER_SINK_PAD (dec));
409 GST_ELEMENT_ERROR (dec, STREAM, FORMAT, (NULL),
410 ("Output sample format could not be used when trying to decode frame. "
411 "This is typically caused when the input caps (often the sample "
412 "rate) do not match the actual format of the audio data. "
413 "Input caps: %" GST_PTR_FORMAT, input_caps)
415 gst_caps_unref (input_caps);
419 char const *errmsg = mpg123_plain_strerror (errcode);
420 GST_ERROR_OBJECT (dec, "Reported error: %s", errmsg);
424 retval = GST_FLOW_ERROR;
433 gst_mpg123_audio_dec_set_format (GstAudioDecoder * dec, GstCaps * input_caps)
435 /* Using the parsed information upstream, and the list of allowed caps
436 * downstream, this code tries to find a suitable audio info. It is important
437 * to keep in mind that the rate and number of channels should never deviate
438 * from the one the bitstream has, otherwise mpg123 has to mix channels and/or
439 * resample (and as its docs say, its internal resampler is very crude). The
440 * sample format, however, can be chosen freely, because the MPEG specs do not
441 * mandate any special format. Therefore, rate and number of channels are taken
442 * from upstream (which parsed the MPEG frames, so the input_caps contain
443 * exactly the rate and number of channels the bitstream actually has), while
444 * the sample format is chosen by trying out all caps that are allowed by
445 * downstream. This way, the output is adjusted to what the downstream prefers.
447 * Also, the new output audio info is not set immediately. Instead, it is
448 * considered the "next audioinfo". The code waits for mpg123 to notice the new
449 * format (= when mpg123_decode_frame() returns MPG123_AUDIO_DEC_NEW_FORMAT),
450 * and then sets the next audioinfo. Otherwise, the next audioinfo is set too
451 * soon, which may cause problems with mp3s containing several format headers.
452 * One example would be an mp3 with the first 30 seconds using 44.1 kHz, then
453 * the next 30 seconds using 32 kHz. Rare, but possible.
457 * 1. get rate and channels from input_caps
458 * 2. get allowed caps from src pad
459 * 3. for each structure in allowed caps:
461 * 3.2. if the combination of format with rate and channels is unsupported by
462 * mpg123, go to (3), or exit with error if there are no more structures
464 * 3.3. create next audioinfo out of rate,channels,format, and exit
469 GstMpg123AudioDec *mpg123_decoder;
470 GstCaps *allowed_srccaps;
472 gboolean match_found = FALSE;
474 mpg123_decoder = GST_MPG123_AUDIO_DEC (dec);
476 g_assert (mpg123_decoder->handle != NULL);
478 mpg123_decoder->has_next_audioinfo = FALSE;
480 /* Get rate and channels from input_caps */
482 GstStructure *structure;
483 gboolean err = FALSE;
485 /* Only the first structure is used (multiple
486 * input caps structures don't make sense */
487 structure = gst_caps_get_structure (input_caps, 0);
489 if (!gst_structure_get_int (structure, "rate", &rate)) {
491 GST_ERROR_OBJECT (dec, "Input caps do not have a rate value");
493 if (!gst_structure_get_int (structure, "channels", &channels)) {
495 GST_ERROR_OBJECT (dec, "Input caps do not have a channel value");
502 /* Get the caps that are allowed by downstream */
504 GstCaps *allowed_srccaps_unnorm =
505 gst_pad_get_allowed_caps (GST_AUDIO_DECODER_SRC_PAD (dec));
506 allowed_srccaps = gst_caps_normalize (allowed_srccaps_unnorm);
509 /* Go through all allowed caps, pick the first one that matches */
510 for (structure_nr = 0; structure_nr < gst_caps_get_size (allowed_srccaps);
512 GstStructure *structure;
513 gchar const *format_str;
514 GstAudioFormat format;
517 structure = gst_caps_get_structure (allowed_srccaps, structure_nr);
519 format_str = gst_structure_get_string (structure, "format");
520 if (format_str == NULL) {
521 GST_DEBUG_OBJECT (dec, "Could not get format from src caps");
525 format = gst_audio_format_from_string (format_str);
526 if (format == GST_AUDIO_FORMAT_UNKNOWN) {
527 GST_DEBUG_OBJECT (dec, "Unknown format %s", format_str);
532 case GST_AUDIO_FORMAT_S16:
533 encoding = MPG123_ENC_SIGNED_16;
535 case GST_AUDIO_FORMAT_S24:
536 encoding = MPG123_ENC_SIGNED_24;
538 case GST_AUDIO_FORMAT_S32:
539 encoding = MPG123_ENC_SIGNED_32;
541 case GST_AUDIO_FORMAT_U16:
542 encoding = MPG123_ENC_UNSIGNED_16;
544 case GST_AUDIO_FORMAT_U24:
545 encoding = MPG123_ENC_UNSIGNED_24;
547 case GST_AUDIO_FORMAT_U32:
548 encoding = MPG123_ENC_UNSIGNED_32;
550 case GST_AUDIO_FORMAT_F32:
551 encoding = MPG123_ENC_FLOAT_32;
554 GST_DEBUG_OBJECT (dec,
555 "Format %s in srccaps is not supported", format_str);
562 /* Cleanup old formats & set new one */
563 mpg123_format_none (mpg123_decoder->handle);
564 err = mpg123_format (mpg123_decoder->handle, rate, channels, encoding);
565 if (err != MPG123_OK) {
566 GST_DEBUG_OBJECT (dec,
567 "mpg123 cannot use caps %" GST_PTR_FORMAT
568 " because mpg123_format() failed: %s", structure,
569 mpg123_strerror (mpg123_decoder->handle));
574 gst_audio_info_init (&(mpg123_decoder->next_audioinfo));
575 gst_audio_info_set_format (&(mpg123_decoder->next_audioinfo), format, rate,
577 GST_LOG_OBJECT (dec, "The next audio format is: %s, %u Hz, %u channels",
578 format_str, rate, channels);
579 mpg123_decoder->has_next_audioinfo = TRUE;
586 gst_caps_unref (allowed_srccaps);
593 gst_mpg123_audio_dec_flush (GstAudioDecoder * dec, gboolean hard)
596 GstMpg123AudioDec *mpg123_decoder;
600 GST_LOG_OBJECT (dec, "Flushing decoder");
602 mpg123_decoder = GST_MPG123_AUDIO_DEC (dec);
604 g_assert (mpg123_decoder->handle != NULL);
606 /* Flush by reopening the feed */
607 mpg123_close (mpg123_decoder->handle);
608 error = mpg123_open_feed (mpg123_decoder->handle);
610 if (G_UNLIKELY (error != MPG123_OK)) {
611 GST_ELEMENT_ERROR (dec, LIBRARY, INIT, (NULL),
612 ("Error while reopening mpg123 feed: %s",
613 mpg123_plain_strerror (error)));
614 mpg123_close (mpg123_decoder->handle);
615 mpg123_delete (mpg123_decoder->handle);
616 mpg123_decoder->handle = NULL;
619 mpg123_decoder->has_next_audioinfo = FALSE;
621 /* opening/closing feeds do not affect the format defined by the
622 * mpg123_format() call that was made in gst_mpg123_audio_dec_set_format(),
623 * and since the up/downstream caps are not expected to change here, no
624 * mpg123_format() calls are done */
628 plugin_init (GstPlugin * plugin)
630 return gst_element_register (plugin, "mpg123audiodec",
631 GST_RANK_MARGINAL, gst_mpg123_audio_dec_get_type ());
634 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
636 mpg123, "mp3 decoding based on the mpg123 library",
637 plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)