c8cd3e6cacbe1e414c2a819d511e28c31e043e7f
[glsdk/gst-plugins-ugly0-10.git] / ext / lame / gstlamemp3enc.c
1 /* GStreamer
2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
3  * Copyright (C) <2004> Wim Taymans <wim@fluendo.com>
4  * Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
5  * Copyright (C) <2009> Sebastian Dröge <sebastian.droege@collabora.co.uk>
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public
18  * License along with this library; if not, write to the
19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20  * Boston, MA 02111-1307, USA.
21  */
23 /**
24  * SECTION:element-lamemp3enc
25  * @see_also: lame, mad, vorbisenc
26  *
27  * This element encodes raw integer audio into an MPEG-1 layer 3 (MP3) stream.
28  * Note that <ulink url="http://en.wikipedia.org/wiki/MP3">MP3</ulink> is not
29  * a free format, there are licensing and patent issues to take into
30  * consideration. See <ulink url="http://www.vorbis.com/">Ogg/Vorbis</ulink>
31  * for a royalty free (and often higher quality) alternative.
32  *
33  * <refsect2>
34  * <title>Output sample rate</title>
35  * If no fixed output sample rate is negotiated on the element's src pad,
36  * the element will choose an optimal sample rate to resample to internally.
37  * For example, a 16-bit 44.1 KHz mono audio stream encoded at 48 kbit will
38  * get resampled to 32 KHz.  Use filter caps on the src pad to force a
39  * particular sample rate.
40  * </refsect2>
41  * <refsect2>
42  * <title>Example pipelines</title>
43  * |[
44  * gst-launch -v audiotestsrc wave=sine num-buffers=100 ! audioconvert ! lamemp3enc ! filesink location=sine.mp3
45  * ]| Encode a test sine signal to MP3.
46  * |[
47  * gst-launch -v alsasrc ! audioconvert ! lamemp3enc target=bitrate bitrate=192 ! filesink location=alsasrc.mp3
48  * ]| Record from a sound card using ALSA and encode to MP3 with an average bitrate of 192kbps
49  * |[
50  * gst-launch -v filesrc location=music.wav ! decodebin ! audioconvert ! audioresample ! lamemp3enc target=quality quality=0 ! id3v2mux ! filesink location=music.mp3
51  * ]| Transcode from a .wav file to MP3 (the id3v2mux element is optional) with best VBR quality
52  * |[
53  * gst-launch -v cdda://5 ! audioconvert ! lamemp3enc target=bitrate cbr=true bitrate=192 ! filesink location=track5.mp3
54  * ]| Encode Audio CD track 5 to MP3 with a constant bitrate of 192kbps
55  * |[
56  * gst-launch -v audiotestsrc num-buffers=10 ! audio/x-raw-int,rate=44100,channels=1 ! lamemp3enc target=bitrate cbr=true bitrate=48 ! filesink location=test.mp3
57  * ]| Encode to a fixed sample rate
58  * </refsect2>
59  *
60  * Since: 0.10.12
61  */
63 #ifdef HAVE_CONFIG_H
64 #include "config.h"
65 #endif
67 #include <string.h>
68 #include "gstlamemp3enc.h"
69 #include <gst/gst-i18n-plugin.h>
71 /* lame < 3.98 */
72 #ifndef HAVE_LAME_SET_VBR_QUALITY
73 #define lame_set_VBR_quality(flags,q) lame_set_VBR_q((flags),(int)(q))
74 #endif
76 GST_DEBUG_CATEGORY_STATIC (debug);
77 #define GST_CAT_DEFAULT debug
79 /* elementfactory information */
81 /* LAMEMP3ENC can do MPEG-1, MPEG-2, and MPEG-2.5, so it has 9 possible
82  * sample rates it supports */
83 static GstStaticPadTemplate gst_lamemp3enc_sink_template =
84 GST_STATIC_PAD_TEMPLATE ("sink",
85     GST_PAD_SINK,
86     GST_PAD_ALWAYS,
87     GST_STATIC_CAPS ("audio/x-raw-int, "
88         "endianness = (int) " G_STRINGIFY (G_BYTE_ORDER) ", "
89         "signed = (boolean) true, "
90         "width = (int) 16, "
91         "depth = (int) 16, "
92         "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, "
93         "channels = (int) [ 1, 2 ]")
94     );
96 static GstStaticPadTemplate gst_lamemp3enc_src_template =
97 GST_STATIC_PAD_TEMPLATE ("src",
98     GST_PAD_SRC,
99     GST_PAD_ALWAYS,
100     GST_STATIC_CAPS ("audio/mpeg, "
101         "mpegversion = (int) 1, "
102         "layer = (int) 3, "
103         "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, "
104         "channels = (int) [ 1, 2 ]")
105     );
107 /********** Define useful types for non-programmatic interfaces **********/
108 enum
110   LAMEMP3ENC_TARGET_QUALITY = 0,
111   LAMEMP3ENC_TARGET_BITRATE
112 };
114 #define GST_TYPE_LAMEMP3ENC_TARGET (gst_lamemp3enc_target_get_type())
115 static GType
116 gst_lamemp3enc_target_get_type (void)
118   static GType lame_target_type = 0;
119   static GEnumValue lame_targets[] = {
120     {LAMEMP3ENC_TARGET_QUALITY, "Quality", "quality"},
121     {LAMEMP3ENC_TARGET_BITRATE, "Bitrate", "bitrate"},
122     {0, NULL, NULL}
123   };
125   if (!lame_target_type) {
126     lame_target_type =
127         g_enum_register_static ("GstLameMP3EncTarget", lame_targets);
128   }
129   return lame_target_type;
132 enum
134   LAMEMP3ENC_ENCODING_ENGINE_QUALITY_FAST = 0,
135   LAMEMP3ENC_ENCODING_ENGINE_QUALITY_STANDARD,
136   LAMEMP3ENC_ENCODING_ENGINE_QUALITY_HIGH
137 };
139 #define GST_TYPE_LAMEMP3ENC_ENCODING_ENGINE_QUALITY (gst_lamemp3enc_encoding_engine_quality_get_type())
140 static GType
141 gst_lamemp3enc_encoding_engine_quality_get_type (void)
143   static GType lame_encoding_engine_quality_type = 0;
144   static GEnumValue lame_encoding_engine_quality[] = {
145     {0, "Fast", "fast"},
146     {1, "Standard", "standard"},
147     {2, "High", "high"},
148     {0, NULL, NULL}
149   };
151   if (!lame_encoding_engine_quality_type) {
152     lame_encoding_engine_quality_type =
153         g_enum_register_static ("GstLameMP3EncEncodingEngineQuality",
154         lame_encoding_engine_quality);
155   }
156   return lame_encoding_engine_quality_type;
159 /********** Standard stuff for signals and arguments **********/
161 enum
163   ARG_0,
164   ARG_TARGET,
165   ARG_BITRATE,
166   ARG_CBR,
167   ARG_QUALITY,
168   ARG_ENCODING_ENGINE_QUALITY,
169   ARG_MONO
170 };
172 #define DEFAULT_TARGET LAMEMP3ENC_TARGET_QUALITY
173 #define DEFAULT_BITRATE 128
174 #define DEFAULT_CBR FALSE
175 #define DEFAULT_QUALITY 4
176 #define DEFAULT_ENCODING_ENGINE_QUALITY LAMEMP3ENC_ENCODING_ENGINE_QUALITY_STANDARD
177 #define DEFAULT_MONO FALSE
179 static gboolean gst_lamemp3enc_start (GstAudioEncoder * enc);
180 static gboolean gst_lamemp3enc_stop (GstAudioEncoder * enc);
181 static gboolean gst_lamemp3enc_set_format (GstAudioEncoder * enc,
182     GstAudioInfo * info);
183 static GstFlowReturn gst_lamemp3enc_handle_frame (GstAudioEncoder * enc,
184     GstBuffer * in_buf);
185 static void gst_lamemp3enc_flush (GstAudioEncoder * enc);
187 static void gst_lamemp3enc_set_property (GObject * object, guint prop_id,
188     const GValue * value, GParamSpec * pspec);
189 static void gst_lamemp3enc_get_property (GObject * object, guint prop_id,
190     GValue * value, GParamSpec * pspec);
191 static gboolean gst_lamemp3enc_setup (GstLameMP3Enc * lame, GstTagList ** tags);
193 GST_BOILERPLATE (GstLameMP3Enc, gst_lamemp3enc, GstAudioEncoder,
194     GST_TYPE_AUDIO_ENCODER);
196 static void
197 gst_lamemp3enc_release_memory (GstLameMP3Enc * lame)
199   if (lame->lgf) {
200     lame_close (lame->lgf);
201     lame->lgf = NULL;
202   }
205 static void
206 gst_lamemp3enc_finalize (GObject * obj)
208   gst_lamemp3enc_release_memory (GST_LAMEMP3ENC (obj));
210   G_OBJECT_CLASS (parent_class)->finalize (obj);
213 static void
214 gst_lamemp3enc_base_init (gpointer g_class)
216   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
218   gst_element_class_add_static_pad_template (element_class,
219       &gst_lamemp3enc_src_template);
220   gst_element_class_add_static_pad_template (element_class,
221       &gst_lamemp3enc_sink_template);
222   gst_element_class_set_details_simple (element_class, "L.A.M.E. mp3 encoder",
223       "Codec/Encoder/Audio",
224       "High-quality free MP3 encoder",
225       "Sebastian Dröge <sebastian.droege@collabora.co.uk>");
228 static void
229 gst_lamemp3enc_class_init (GstLameMP3EncClass * klass)
231   GObjectClass *gobject_class;
232   GstAudioEncoderClass *base_class;
234   gobject_class = (GObjectClass *) klass;
235   base_class = (GstAudioEncoderClass *) klass;
237   gobject_class->set_property = gst_lamemp3enc_set_property;
238   gobject_class->get_property = gst_lamemp3enc_get_property;
239   gobject_class->finalize = gst_lamemp3enc_finalize;
241   base_class->start = GST_DEBUG_FUNCPTR (gst_lamemp3enc_start);
242   base_class->stop = GST_DEBUG_FUNCPTR (gst_lamemp3enc_stop);
243   base_class->set_format = GST_DEBUG_FUNCPTR (gst_lamemp3enc_set_format);
244   base_class->handle_frame = GST_DEBUG_FUNCPTR (gst_lamemp3enc_handle_frame);
245   base_class->flush = GST_DEBUG_FUNCPTR (gst_lamemp3enc_flush);
247   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TARGET,
248       g_param_spec_enum ("target", "Target",
249           "Optimize for quality or bitrate", GST_TYPE_LAMEMP3ENC_TARGET,
250           DEFAULT_TARGET,
251           G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
252   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BITRATE,
253       g_param_spec_int ("bitrate", "Bitrate (kb/s)",
254           "Bitrate in kbit/sec (Only valid if target is bitrate, for CBR one "
255           "of 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, "
256           "256 or 320)", 8, 320, DEFAULT_BITRATE,
257           G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
258   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_CBR,
259       g_param_spec_boolean ("cbr", "CBR", "Enforce constant bitrate encoding "
260           "(Only valid if target is bitrate)", DEFAULT_CBR,
261           G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
262   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_QUALITY,
263       g_param_spec_float ("quality", "Quality",
264           "VBR Quality from 0 to 10, 0 being the best "
265           "(Only valid if target is quality)", 0.0, 9.999,
266           DEFAULT_QUALITY,
267           G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
268   g_object_class_install_property (G_OBJECT_CLASS (klass),
269       ARG_ENCODING_ENGINE_QUALITY, g_param_spec_enum ("encoding-engine-quality",
270           "Encoding Engine Quality", "Quality/speed of the encoding engine, "
271           "this does not affect the bitrate!",
272           GST_TYPE_LAMEMP3ENC_ENCODING_ENGINE_QUALITY,
273           DEFAULT_ENCODING_ENGINE_QUALITY,
274           G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
275   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MONO,
276       g_param_spec_boolean ("mono", "Mono", "Enforce mono encoding",
277           DEFAULT_MONO,
278           G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
281 static void
282 gst_lamemp3enc_init (GstLameMP3Enc * lame, GstLameMP3EncClass * klass)
286 static gboolean
287 gst_lamemp3enc_start (GstAudioEncoder * enc)
289   GstLameMP3Enc *lame = GST_LAMEMP3ENC (enc);
291   GST_DEBUG_OBJECT (lame, "start");
293   if (!lame->adapter)
294     lame->adapter = gst_adapter_new ();
295   gst_adapter_clear (lame->adapter);
297   return TRUE;
300 static gboolean
301 gst_lamemp3enc_stop (GstAudioEncoder * enc)
303   GstLameMP3Enc *lame = GST_LAMEMP3ENC (enc);
305   GST_DEBUG_OBJECT (lame, "stop");
307   if (lame->adapter) {
308     g_object_unref (lame->adapter);
309     lame->adapter = NULL;
310   }
312   gst_lamemp3enc_release_memory (lame);
313   return TRUE;
316 static gboolean
317 gst_lamemp3enc_set_format (GstAudioEncoder * enc, GstAudioInfo * info)
319   GstLameMP3Enc *lame;
320   gint out_samplerate;
321   gint version;
322   GstCaps *othercaps;
323   GstClockTime latency;
324   GstTagList *tags = NULL;
326   lame = GST_LAMEMP3ENC (enc);
328   /* parameters already parsed for us */
329   lame->samplerate = GST_AUDIO_INFO_RATE (info);
330   lame->num_channels = GST_AUDIO_INFO_CHANNELS (info);
332   /* but we might be asked to reconfigure, so reset */
333   gst_lamemp3enc_release_memory (lame);
335   GST_DEBUG_OBJECT (lame, "setting up lame");
336   if (!gst_lamemp3enc_setup (lame, &tags))
337     goto setup_failed;
339   out_samplerate = lame_get_out_samplerate (lame->lgf);
340   if (out_samplerate == 0)
341     goto zero_output_rate;
342   if (out_samplerate != lame->samplerate) {
343     GST_WARNING_OBJECT (lame,
344         "output samplerate %d is different from incoming samplerate %d",
345         out_samplerate, lame->samplerate);
346   }
347   lame->out_samplerate = out_samplerate;
349   version = lame_get_version (lame->lgf);
350   if (version == 0)
351     version = 2;
352   else if (version == 1)
353     version = 1;
354   else if (version == 2)
355     version = 3;
357   othercaps =
358       gst_caps_new_simple ("audio/mpeg",
359       "mpegversion", G_TYPE_INT, 1,
360       "mpegaudioversion", G_TYPE_INT, version,
361       "layer", G_TYPE_INT, 3,
362       "channels", G_TYPE_INT, lame->mono ? 1 : lame->num_channels,
363       "rate", G_TYPE_INT, out_samplerate, NULL);
365   /* and use these caps */
366   gst_pad_set_caps (GST_AUDIO_ENCODER_SRC_PAD (enc), othercaps);
367   gst_caps_unref (othercaps);
369   /* base class feedback:
370    * - we will handle buffers, just hand us all available
371    * - report latency */
372   latency = gst_util_uint64_scale_int (lame_get_framesize (lame->lgf),
373       GST_SECOND, lame->samplerate);
374   gst_audio_encoder_set_latency (enc, latency, latency);
376   if (tags) {
377     gst_audio_encoder_merge_tags (enc, tags, GST_TAG_MERGE_REPLACE);
378     gst_tag_list_free (tags);
379   }
381   return TRUE;
383 zero_output_rate:
384   {
385     if (tags)
386       gst_tag_list_free (tags);
387     GST_ELEMENT_ERROR (lame, LIBRARY, SETTINGS, (NULL),
388         ("LAMEMP3ENC decided on a zero sample rate"));
389     return FALSE;
390   }
391 setup_failed:
392   {
393     GST_ELEMENT_ERROR (lame, LIBRARY, SETTINGS,
394         (_("Failed to configure LAMEMP3ENC encoder. Check your encoding parameters.")), (NULL));
395     return FALSE;
396   }
399 /* <php-emulation-mode>three underscores for ___rate is really really really
400  * private as opposed to one underscore<php-emulation-mode> */
401 /* call this MACRO outside of the NULL state so that we have a higher chance
402  * of actually having a pipeline and bus to get the message through */
404 #define CHECK_AND_FIXUP_BITRATE(obj,param,rate)                           \
405 G_STMT_START {                                                            \
406   gint ___rate = rate;                                                    \
407   gint maxrate = 320;                                                     \
408   gint multiplier = 64;                                                   \
409   if (rate == 0) {                                                        \
410     ___rate = rate;                                                       \
411   } else if (rate <= 64) {                                                \
412     maxrate = 64; multiplier = 8;                                         \
413     if ((rate % 8) != 0) ___rate = GST_ROUND_UP_8 (rate);                 \
414   } else if (rate <= 128) {                                               \
415     maxrate = 128; multiplier = 16;                                       \
416     if ((rate % 16) != 0) ___rate = GST_ROUND_UP_16 (rate);               \
417   } else if (rate <= 256) {                                               \
418     maxrate = 256; multiplier = 32;                                       \
419     if ((rate % 32) != 0) ___rate = GST_ROUND_UP_32 (rate);               \
420   } else if (rate <= 320) {                                               \
421     maxrate = 320; multiplier = 64;                                       \
422     if ((rate % 64) != 0) ___rate = GST_ROUND_UP_64 (rate);               \
423   }                                                                       \
424   if (___rate != rate) {                                                  \
425     GST_ELEMENT_WARNING (obj, LIBRARY, SETTINGS,                          \
426       (_("The requested bitrate %d kbit/s for property '%s' "             \
427        "is not allowed. "                                                 \
428        "The bitrate was changed to %d kbit/s."), rate,                    \
429          param,  ___rate),                                                \
430        ("A bitrate below %d should be a multiple of %d.",                 \
431           maxrate, multiplier));                                          \
432     rate = ___rate;                                                       \
433   }                                                                       \
434 } G_STMT_END
436 static void
437 gst_lamemp3enc_set_property (GObject * object, guint prop_id,
438     const GValue * value, GParamSpec * pspec)
440   GstLameMP3Enc *lame;
442   lame = GST_LAMEMP3ENC (object);
444   switch (prop_id) {
445     case ARG_TARGET:
446       lame->target = g_value_get_enum (value);
447       break;
448     case ARG_BITRATE:
449       lame->bitrate = g_value_get_int (value);
450       break;
451     case ARG_CBR:
452       lame->cbr = g_value_get_boolean (value);
453       break;
454     case ARG_QUALITY:
455       lame->quality = g_value_get_float (value);
456       break;
457     case ARG_ENCODING_ENGINE_QUALITY:
458       lame->encoding_engine_quality = g_value_get_enum (value);
459       break;
460     case ARG_MONO:
461       lame->mono = g_value_get_boolean (value);
462       break;
463     default:
464       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
465       break;
466   }
469 static void
470 gst_lamemp3enc_get_property (GObject * object, guint prop_id, GValue * value,
471     GParamSpec * pspec)
473   GstLameMP3Enc *lame;
475   lame = GST_LAMEMP3ENC (object);
477   switch (prop_id) {
478     case ARG_TARGET:
479       g_value_set_enum (value, lame->target);
480       break;
481     case ARG_BITRATE:
482       g_value_set_int (value, lame->bitrate);
483       break;
484     case ARG_CBR:
485       g_value_set_boolean (value, lame->cbr);
486       break;
487     case ARG_QUALITY:
488       g_value_set_float (value, lame->quality);
489       break;
490     case ARG_ENCODING_ENGINE_QUALITY:
491       g_value_set_enum (value, lame->encoding_engine_quality);
492       break;
493     case ARG_MONO:
494       g_value_set_boolean (value, lame->mono);
495       break;
496     default:
497       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
498       break;
499   }
502 /* **** credits go to mpegaudioparse **** */
504 static const guint mp3types_bitrates[2][3][16] = {
505   {
506         {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},
507         {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},
508         {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}
509       },
510   {
511         {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},
512         {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},
513         {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}
514       },
515 };
517 static const guint mp3types_freqs[3][3] = { {44100, 48000, 32000},
518 {22050, 24000, 16000},
519 {11025, 12000, 8000}
520 };
522 static inline guint
523 mp3_type_frame_length_from_header (GstLameMP3Enc * lame, guint32 header,
524     guint * put_version, guint * put_layer, guint * put_channels,
525     guint * put_bitrate, guint * put_samplerate, guint * put_mode,
526     guint * put_crc)
528   guint length;
529   gulong mode, samplerate, bitrate, layer, channels, padding, crc;
530   gulong version;
531   gint lsf, mpg25;
533   if (header & (1 << 20)) {
534     lsf = (header & (1 << 19)) ? 0 : 1;
535     mpg25 = 0;
536   } else {
537     lsf = 1;
538     mpg25 = 1;
539   }
541   version = 1 + lsf + mpg25;
543   layer = 4 - ((header >> 17) & 0x3);
545   crc = (header >> 16) & 0x1;
547   bitrate = (header >> 12) & 0xF;
548   bitrate = mp3types_bitrates[lsf][layer - 1][bitrate] * 1000;
549   /* The caller has ensured we have a valid header, so bitrate can't be
550      zero here. */
551   g_assert (bitrate != 0);
553   samplerate = (header >> 10) & 0x3;
554   samplerate = mp3types_freqs[lsf + mpg25][samplerate];
556   padding = (header >> 9) & 0x1;
558   mode = (header >> 6) & 0x3;
559   channels = (mode == 3) ? 1 : 2;
561   switch (layer) {
562     case 1:
563       length = 4 * ((bitrate * 12) / samplerate + padding);
564       break;
565     case 2:
566       length = (bitrate * 144) / samplerate + padding;
567       break;
568     default:
569     case 3:
570       length = (bitrate * 144) / (samplerate << lsf) + padding;
571       break;
572   }
574   GST_DEBUG_OBJECT (lame, "Calculated mp3 frame length of %u bytes", length);
575   GST_DEBUG_OBJECT (lame, "samplerate = %lu, bitrate = %lu, version = %lu, "
576       "layer = %lu, channels = %lu", samplerate, bitrate, version,
577       layer, channels);
579   if (put_version)
580     *put_version = version;
581   if (put_layer)
582     *put_layer = layer;
583   if (put_channels)
584     *put_channels = channels;
585   if (put_bitrate)
586     *put_bitrate = bitrate;
587   if (put_samplerate)
588     *put_samplerate = samplerate;
589   if (put_mode)
590     *put_mode = mode;
591   if (put_crc)
592     *put_crc = crc;
594   return length;
597 static gboolean
598 mp3_sync_check (GstLameMP3Enc * lame, unsigned long head)
600   GST_DEBUG_OBJECT (lame, "checking mp3 header 0x%08lx", head);
601   /* if it's not a valid sync */
602   if ((head & 0xffe00000) != 0xffe00000) {
603     GST_WARNING_OBJECT (lame, "invalid sync");
604     return FALSE;
605   }
606   /* if it's an invalid MPEG version */
607   if (((head >> 19) & 3) == 0x1) {
608     GST_WARNING_OBJECT (lame, "invalid MPEG version: 0x%lx", (head >> 19) & 3);
609     return FALSE;
610   }
611   /* if it's an invalid layer */
612   if (!((head >> 17) & 3)) {
613     GST_WARNING_OBJECT (lame, "invalid layer: 0x%lx", (head >> 17) & 3);
614     return FALSE;
615   }
616   /* if it's an invalid bitrate */
617   if (((head >> 12) & 0xf) == 0x0) {
618     GST_WARNING_OBJECT (lame, "invalid bitrate: 0x%lx."
619         "Free format files are not supported yet", (head >> 12) & 0xf);
620     return FALSE;
621   }
622   if (((head >> 12) & 0xf) == 0xf) {
623     GST_WARNING_OBJECT (lame, "invalid bitrate: 0x%lx", (head >> 12) & 0xf);
624     return FALSE;
625   }
626   /* if it's an invalid samplerate */
627   if (((head >> 10) & 0x3) == 0x3) {
628     GST_WARNING_OBJECT (lame, "invalid samplerate: 0x%lx", (head >> 10) & 0x3);
629     return FALSE;
630   }
632   if ((head & 0x3) == 0x2) {
633     /* Ignore this as there are some files with emphasis 0x2 that can
634      * be played fine. See BGO #537235 */
635     GST_WARNING_OBJECT (lame, "invalid emphasis: 0x%lx", head & 0x3);
636   }
638   return TRUE;
641 /* **** end mpegaudioparse **** */
643 static GstFlowReturn
644 gst_lamemp3enc_finish_frames (GstLameMP3Enc * lame)
646   gint av;
647   guint header;
648   GstFlowReturn result = GST_FLOW_OK;
650   /* limited parsing, we don't expect to lose sync here */
651   while ((result == GST_FLOW_OK) &&
652       ((av = gst_adapter_available (lame->adapter)) > 4)) {
653     guint rate, version, layer, size;
654     GstBuffer *mp3_buf;
655     const guint8 *data;
657     data = gst_adapter_peek (lame->adapter, 4);
658     header = GST_READ_UINT32_BE (data);
659     if (!mp3_sync_check (lame, header))
660       goto invalid_header;
662     size = mp3_type_frame_length_from_header (lame, header, &version, &layer,
663         NULL, NULL, &rate, NULL, NULL);
665     if (G_UNLIKELY (layer != 3 || rate != lame->out_samplerate)) {
666       GST_DEBUG_OBJECT (lame,
667           "unexpected mp3 header with rate %u, version %u, layer %u",
668           rate, version, layer);
669       goto invalid_header;
670     }
672     if (size > av) {
673       /* pretty likely to occur when lame is holding back on us */
674       GST_LOG_OBJECT (lame, "frame size %u (> %d)", size, av);
675       break;
676     }
678     /* should be ok now */
679     mp3_buf = gst_adapter_take_buffer (lame->adapter, size);
680     /* number of samples for MPEG-1, layer 3 */
681     result = gst_audio_encoder_finish_frame (GST_AUDIO_ENCODER (lame),
682         mp3_buf, version == 1 ? 1152 : 576);
683   }
685 exit:
686   return result;
688   /* ERRORS */
689 invalid_header:
690   {
691     GST_ELEMENT_ERROR (lame, STREAM, ENCODE,
692         ("invalid lame mp3 sync header %08X", header), (NULL));
693     result = GST_FLOW_ERROR;
694     goto exit;
695   }
698 static GstFlowReturn
699 gst_lamemp3enc_flush_full (GstLameMP3Enc * lame, gboolean push)
701   GstBuffer *buf;
702   gint size;
703   GstFlowReturn result = GST_FLOW_OK;
704   gint av;
706   if (!lame->lgf)
707     return GST_FLOW_OK;
709   buf = gst_buffer_new_and_alloc (7200);
710   size = lame_encode_flush (lame->lgf, GST_BUFFER_DATA (buf), 7200);
712   if (size > 0) {
713     GST_BUFFER_SIZE (buf) = size;
714     GST_DEBUG_OBJECT (lame, "collecting final %d bytes", size);
715     gst_adapter_push (lame->adapter, buf);
716   } else {
717     GST_DEBUG_OBJECT (lame, "no final packet (size=%d, push=%d)", size, push);
718     gst_buffer_unref (buf);
719     result = GST_FLOW_OK;
720   }
722   if (push) {
723     result = gst_lamemp3enc_finish_frames (lame);
724   } else {
725     /* never mind */
726     gst_adapter_clear (lame->adapter);
727   }
729   /* either way, we expect nothing left */
730   if ((av = gst_adapter_available (lame->adapter))) {
731     /* should this be more fatal ?? */
732     GST_WARNING_OBJECT (lame, "unparsed %d bytes left after flushing", av);
733     /* clean up anyway */
734     gst_adapter_clear (lame->adapter);
735   }
737   return result;
740 static void
741 gst_lamemp3enc_flush (GstAudioEncoder * enc)
743   gst_lamemp3enc_flush_full (GST_LAMEMP3ENC (enc), FALSE);
746 static GstFlowReturn
747 gst_lamemp3enc_handle_frame (GstAudioEncoder * enc, GstBuffer * in_buf)
749   GstLameMP3Enc *lame;
750   guchar *mp3_data;
751   gint mp3_buffer_size, mp3_size;
752   GstBuffer *mp3_buf;
753   GstFlowReturn result;
754   gint num_samples;
755   guint8 *data;
756   guint size;
758   lame = GST_LAMEMP3ENC (enc);
760   /* squeeze remaining and push */
761   if (G_UNLIKELY (in_buf == NULL))
762     return gst_lamemp3enc_flush_full (lame, TRUE);
764   data = GST_BUFFER_DATA (in_buf);
765   size = GST_BUFFER_SIZE (in_buf);
767   num_samples = size / 2;
769   /* allocate space for output */
770   mp3_buffer_size = 1.25 * num_samples + 7200;
771   mp3_buf = gst_buffer_new_and_alloc (mp3_buffer_size);
772   mp3_data = GST_BUFFER_DATA (mp3_buf);
774   /* lame seems to be too stupid to get mono interleaved going */
775   if (lame->num_channels == 1) {
776     mp3_size = lame_encode_buffer (lame->lgf,
777         (short int *) data,
778         (short int *) data, num_samples, mp3_data, mp3_buffer_size);
779   } else {
780     mp3_size = lame_encode_buffer_interleaved (lame->lgf,
781         (short int *) data,
782         num_samples / lame->num_channels, mp3_data, mp3_buffer_size);
783   }
785   GST_LOG_OBJECT (lame, "encoded %d bytes of audio to %d bytes of mp3",
786       size, mp3_size);
788   if (G_LIKELY (mp3_size > 0)) {
789     GST_BUFFER_SIZE (mp3_buf) = mp3_size;
790     /* unfortunately lame does not provide frame delineated output,
791      * so collect output and parse into frames ... */
792     gst_adapter_push (lame->adapter, mp3_buf);
793     result = gst_lamemp3enc_finish_frames (lame);
794   } else {
795     if (mp3_size < 0) {
796       /* eat error ? */
797       g_warning ("error %d", mp3_size);
798     }
799     result = GST_FLOW_OK;
800     gst_buffer_unref (mp3_buf);
801   }
803   return result;
806 /* set up the encoder state */
807 static gboolean
808 gst_lamemp3enc_setup (GstLameMP3Enc * lame, GstTagList ** tags)
810   gboolean res;
812 #define CHECK_ERROR(command) G_STMT_START {\
813   if ((command) < 0) { \
814     GST_ERROR_OBJECT (lame, "setup failed: " G_STRINGIFY (command)); \
815     if (*tags) { \
816       gst_tag_list_free (*tags); \
817       *tags = NULL; \
818     } \
819     return FALSE; \
820   } \
821 }G_STMT_END
823   int retval;
824   GstCaps *allowed_caps;
826   GST_DEBUG_OBJECT (lame, "starting setup");
828   lame->lgf = lame_init ();
830   if (lame->lgf == NULL)
831     return FALSE;
833   *tags = gst_tag_list_new ();
835   /* copy the parameters over */
836   lame_set_in_samplerate (lame->lgf, lame->samplerate);
838   /* let lame choose default samplerate unless outgoing sample rate is fixed */
839   allowed_caps = gst_pad_get_allowed_caps (GST_AUDIO_ENCODER_SRC_PAD (lame));
841   if (allowed_caps != NULL) {
842     GstStructure *structure;
843     gint samplerate;
845     structure = gst_caps_get_structure (allowed_caps, 0);
847     if (gst_structure_get_int (structure, "rate", &samplerate)) {
848       GST_DEBUG_OBJECT (lame, "Setting sample rate to %d as fixed in src caps",
849           samplerate);
850       lame_set_out_samplerate (lame->lgf, samplerate);
851     } else {
852       GST_DEBUG_OBJECT (lame, "Letting lame choose sample rate");
853       lame_set_out_samplerate (lame->lgf, 0);
854     }
855     gst_caps_unref (allowed_caps);
856     allowed_caps = NULL;
857   } else {
858     GST_DEBUG_OBJECT (lame, "No peer yet, letting lame choose sample rate");
859     lame_set_out_samplerate (lame->lgf, 0);
860   }
862   CHECK_ERROR (lame_set_num_channels (lame->lgf, lame->num_channels));
863   CHECK_ERROR (lame_set_bWriteVbrTag (lame->lgf, 0));
865   if (lame->target == LAMEMP3ENC_TARGET_QUALITY) {
866     CHECK_ERROR (lame_set_VBR (lame->lgf, vbr_default));
867     CHECK_ERROR (lame_set_VBR_quality (lame->lgf, lame->quality));
868   } else {
869     if (lame->cbr) {
870       CHECK_AND_FIXUP_BITRATE (lame, "bitrate", lame->bitrate);
871       CHECK_ERROR (lame_set_VBR (lame->lgf, vbr_off));
872       CHECK_ERROR (lame_set_brate (lame->lgf, lame->bitrate));
873     } else {
874       CHECK_ERROR (lame_set_VBR (lame->lgf, vbr_abr));
875       CHECK_ERROR (lame_set_VBR_mean_bitrate_kbps (lame->lgf, lame->bitrate));
876     }
877     gst_tag_list_add (*tags, GST_TAG_MERGE_REPLACE, GST_TAG_BITRATE,
878         lame->bitrate * 1000, NULL);
879   }
881   if (lame->encoding_engine_quality == LAMEMP3ENC_ENCODING_ENGINE_QUALITY_FAST)
882     CHECK_ERROR (lame_set_quality (lame->lgf, 7));
883   else if (lame->encoding_engine_quality ==
884       LAMEMP3ENC_ENCODING_ENGINE_QUALITY_HIGH)
885     CHECK_ERROR (lame_set_quality (lame->lgf, 2));
886   /* else default */
888   if (lame->mono)
889     CHECK_ERROR (lame_set_mode (lame->lgf, MONO));
891   /* initialize the lame encoder */
892   if ((retval = lame_init_params (lame->lgf)) >= 0) {
893     /* FIXME: it would be nice to print out the mode here */
894     GST_INFO
895         ("lame encoder setup (target %s, quality %f, bitrate %d, %d Hz, %d channels)",
896         (lame->target == LAMEMP3ENC_TARGET_QUALITY) ? "quality" : "bitrate",
897         lame->quality, lame->bitrate, lame->samplerate, lame->num_channels);
898     res = TRUE;
899   } else {
900     GST_ERROR_OBJECT (lame, "lame_init_params returned %d", retval);
901     res = FALSE;
902   }
904   GST_DEBUG_OBJECT (lame, "done with setup");
905   return res;
906 #undef CHECK_ERROR
909 gboolean
910 gst_lamemp3enc_register (GstPlugin * plugin)
912   GST_DEBUG_CATEGORY_INIT (debug, "lamemp3enc", 0, "lame mp3 encoder");
914   if (!gst_element_register (plugin, "lamemp3enc", GST_RANK_PRIMARY,
915           GST_TYPE_LAMEMP3ENC))
916     return FALSE;
918   return TRUE;