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  */
  22
  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  */
  62
  63 #ifdef HAVE_CONFIG_H
  64 #include "config.h"
  65 #endif
  66
  67 #include <string.h>
  68 #include "gstlamemp3enc.h"
  69 #include <gst/gst-i18n-plugin.h>
  70
  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
  75
  76 GST_DEBUG_CATEGORY_STATIC (debug);
  77 #define GST_CAT_DEFAULT debug
  78
  79 /* elementfactory information */
  80
  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     );
  95
  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     );
 106
 107 /********** Define useful types for non-programmatic interfaces **********/
 108 enum
 109 {
 110   LAMEMP3ENC_TARGET_QUALITY = 0,
 111   LAMEMP3ENC_TARGET_BITRATE
 112 };
 113
 114 #define GST_TYPE_LAMEMP3ENC_TARGET (gst_lamemp3enc_target_get_type())
 115 static GType
 116 gst_lamemp3enc_target_get_type (void)
 117 {
 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   };
 124
 125   if (!lame_target_type) {
 126     lame_target_type =
 127         g_enum_register_static ("GstLameMP3EncTarget", lame_targets);
 128   }
 129   return lame_target_type;
 130 }
 131
 132 enum
 133 {
 134   LAMEMP3ENC_ENCODING_ENGINE_QUALITY_FAST = 0,
 135   LAMEMP3ENC_ENCODING_ENGINE_QUALITY_STANDARD,
 136   LAMEMP3ENC_ENCODING_ENGINE_QUALITY_HIGH
 137 };
 138
 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)
 142 {
 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   };
 150
 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;
 157 }
 158
 159 /********** Standard stuff for signals and arguments **********/
 160
 161 enum
 162 {
 163   ARG_0,
 164   ARG_TARGET,
 165   ARG_BITRATE,
 166   ARG_CBR,
 167   ARG_QUALITY,
 168   ARG_ENCODING_ENGINE_QUALITY,
 169   ARG_MONO
 170 };
 171
 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
 178
 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);
 186
 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);
 192
 193 GST_BOILERPLATE (GstLameMP3Enc, gst_lamemp3enc, GstAudioEncoder,
 194     GST_TYPE_AUDIO_ENCODER);
 195
 196 static void
 197 gst_lamemp3enc_release_memory (GstLameMP3Enc * lame)
 198 {
 199   if (lame->lgf) {
 200     lame_close (lame->lgf);
 201     lame->lgf = NULL;
 202   }
 203 }
 204
 205 static void
 206 gst_lamemp3enc_finalize (GObject * obj)
 207 {
 208   gst_lamemp3enc_release_memory (GST_LAMEMP3ENC (obj));
 209
 210   G_OBJECT_CLASS (parent_class)->finalize (obj);
 211 }
 212
 213 static void
 214 gst_lamemp3enc_base_init (gpointer g_class)
 215 {
 216   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 217
 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>");
 226 }
 227
 228 static void
 229 gst_lamemp3enc_class_init (GstLameMP3EncClass * klass)
 230 {
 231   GObjectClass *gobject_class;
 232   GstAudioEncoderClass *base_class;
 233
 234   gobject_class = (GObjectClass *) klass;
 235   base_class = (GstAudioEncoderClass *) klass;
 236
 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;
 240
 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);
 246
 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));
 279 }
 280
 281 static void
 282 gst_lamemp3enc_init (GstLameMP3Enc * lame, GstLameMP3EncClass * klass)
 283 {
 284 }
 285
 286 static gboolean
 287 gst_lamemp3enc_start (GstAudioEncoder * enc)
 288 {
 289   GstLameMP3Enc *lame = GST_LAMEMP3ENC (enc);
 290
 291   GST_DEBUG_OBJECT (lame, "start");
 292
 293   if (!lame->adapter)
 294     lame->adapter = gst_adapter_new ();
 295   gst_adapter_clear (lame->adapter);
 296
 297   return TRUE;
 298 }
 299
 300 static gboolean
 301 gst_lamemp3enc_stop (GstAudioEncoder * enc)
 302 {
 303   GstLameMP3Enc *lame = GST_LAMEMP3ENC (enc);
 304
 305   GST_DEBUG_OBJECT (lame, "stop");
 306
 307   if (lame->adapter) {
 308     g_object_unref (lame->adapter);
 309     lame->adapter = NULL;
 310   }
 311
 312   gst_lamemp3enc_release_memory (lame);
 313   return TRUE;
 314 }
 315
 316 static gboolean
 317 gst_lamemp3enc_set_format (GstAudioEncoder * enc, GstAudioInfo * info)
 318 {
 319   GstLameMP3Enc *lame;
 320   gint out_samplerate;
 321   gint version;
 322   GstCaps *othercaps;
 323   GstClockTime latency;
 324   GstTagList *tags = NULL;
 325
 326   lame = GST_LAMEMP3ENC (enc);
 327
 328   /* parameters already parsed for us */
 329   lame->samplerate = GST_AUDIO_INFO_RATE (info);
 330   lame->num_channels = GST_AUDIO_INFO_CHANNELS (info);
 331
 332   /* but we might be asked to reconfigure, so reset */
 333   gst_lamemp3enc_release_memory (lame);
 334
 335   GST_DEBUG_OBJECT (lame, "setting up lame");
 336   if (!gst_lamemp3enc_setup (lame, &tags))
 337     goto setup_failed;
 338
 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;
 348
 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;
 356
 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);
 364
 365   /* and use these caps */
 366   gst_pad_set_caps (GST_AUDIO_ENCODER_SRC_PAD (enc), othercaps);
 367   gst_caps_unref (othercaps);
 368
 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);
 375
 376   if (tags) {
 377     gst_audio_encoder_merge_tags (enc, tags, GST_TAG_MERGE_REPLACE);
 378     gst_tag_list_free (tags);
 379   }
 380
 381   return TRUE;
 382
 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   }
 397 }
 398
 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 */
 403
 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
 435
 436 static void
 437 gst_lamemp3enc_set_property (GObject * object, guint prop_id,
 438     const GValue * value, GParamSpec * pspec)
 439 {
 440   GstLameMP3Enc *lame;
 441
 442   lame = GST_LAMEMP3ENC (object);
 443
 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   }
 467 }
 468
 469 static void
 470 gst_lamemp3enc_get_property (GObject * object, guint prop_id, GValue * value,
 471     GParamSpec * pspec)
 472 {
 473   GstLameMP3Enc *lame;
 474
 475   lame = GST_LAMEMP3ENC (object);
 476
 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   }
 500 }
 501
 502 /* **** credits go to mpegaudioparse **** */
 503
 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 };
 516
 517 static const guint mp3types_freqs[3][3] = { {44100, 48000, 32000},
 518 {22050, 24000, 16000},
 519 {11025, 12000, 8000}
 520 };
 521
 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)
 527 {
 528   guint length;
 529   gulong mode, samplerate, bitrate, layer, channels, padding, crc;
 530   gulong version;
 531   gint lsf, mpg25;
 532
 533   if (header & (1 << 20)) {
 534     lsf = (header & (1 << 19)) ? 0 : 1;
 535     mpg25 = 0;
 536   } else {
 537     lsf = 1;
 538     mpg25 = 1;
 539   }
 540
 541   version = 1 + lsf + mpg25;
 542
 543   layer = 4 - ((header >> 17) & 0x3);
 544
 545   crc = (header >> 16) & 0x1;
 546
 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);
 552
 553   samplerate = (header >> 10) & 0x3;
 554   samplerate = mp3types_freqs[lsf + mpg25][samplerate];
 555
 556   padding = (header >> 9) & 0x1;
 557
 558   mode = (header >> 6) & 0x3;
 559   channels = (mode == 3) ? 1 : 2;
 560
 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   }
 573
 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);
 578
 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;
 593
 594   return length;
 595 }
 596
 597 static gboolean
 598 mp3_sync_check (GstLameMP3Enc * lame, unsigned long head)
 599 {
 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   }
 631
 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   }
 637
 638   return TRUE;
 639 }
 640
 641 /* **** end mpegaudioparse **** */
 642
 643 static GstFlowReturn
 644 gst_lamemp3enc_finish_frames (GstLameMP3Enc * lame)
 645 {
 646   gint av;
 647   guint header;
 648   GstFlowReturn result = GST_FLOW_OK;
 649
 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;
 656
 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;
 661
 662     size = mp3_type_frame_length_from_header (lame, header, &version, &layer,
 663         NULL, NULL, &rate, NULL, NULL);
 664
 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     }
 671
 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     }
 677
 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   }
 684
 685 exit:
 686   return result;
 687
 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   }
 696 }
 697
 698 static GstFlowReturn
 699 gst_lamemp3enc_flush_full (GstLameMP3Enc * lame, gboolean push)
 700 {
 701   GstBuffer *buf;
 702   gint size;
 703   GstFlowReturn result = GST_FLOW_OK;
 704   gint av;
 705
 706   if (!lame->lgf)
 707     return GST_FLOW_OK;
 708
 709   buf = gst_buffer_new_and_alloc (7200);
 710   size = lame_encode_flush (lame->lgf, GST_BUFFER_DATA (buf), 7200);
 711
 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   }
 721
 722   if (push) {
 723     result = gst_lamemp3enc_finish_frames (lame);
 724   } else {
 725     /* never mind */
 726     gst_adapter_clear (lame->adapter);
 727   }
 728
 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   }
 736
 737   return result;
 738 }
 739
 740 static void
 741 gst_lamemp3enc_flush (GstAudioEncoder * enc)
 742 {
 743   gst_lamemp3enc_flush_full (GST_LAMEMP3ENC (enc), FALSE);
 744 }
 745
 746 static GstFlowReturn
 747 gst_lamemp3enc_handle_frame (GstAudioEncoder * enc, GstBuffer * in_buf)
 748 {
 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;
 757
 758   lame = GST_LAMEMP3ENC (enc);
 759
 760   /* squeeze remaining and push */
 761   if (G_UNLIKELY (in_buf == NULL))
 762     return gst_lamemp3enc_flush_full (lame, TRUE);
 763
 764   data = GST_BUFFER_DATA (in_buf);
 765   size = GST_BUFFER_SIZE (in_buf);
 766
 767   num_samples = size / 2;
 768
 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);
 773
 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   }
 784
 785   GST_LOG_OBJECT (lame, "encoded %d bytes of audio to %d bytes of mp3",
 786       size, mp3_size);
 787
 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   }
 802
 803   return result;
 804 }
 805
 806 /* set up the encoder state */
 807 static gboolean
 808 gst_lamemp3enc_setup (GstLameMP3Enc * lame, GstTagList ** tags)
 809 {
 810   gboolean res;
 811
 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
 822
 823   int retval;
 824   GstCaps *allowed_caps;
 825
 826   GST_DEBUG_OBJECT (lame, "starting setup");
 827
 828   lame->lgf = lame_init ();
 829
 830   if (lame->lgf == NULL)
 831     return FALSE;
 832
 833   *tags = gst_tag_list_new ();
 834
 835   /* copy the parameters over */
 836   lame_set_in_samplerate (lame->lgf, lame->samplerate);
 837
 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));
 840
 841   if (allowed_caps != NULL) {
 842     GstStructure *structure;
 843     gint samplerate;
 844
 845     structure = gst_caps_get_structure (allowed_caps, 0);
 846
 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   }
 861
 862   CHECK_ERROR (lame_set_num_channels (lame->lgf, lame->num_channels));
 863   CHECK_ERROR (lame_set_bWriteVbrTag (lame->lgf, 0));
 864
 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   }
 880
 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 */
 887
 888   if (lame->mono)
 889     CHECK_ERROR (lame_set_mode (lame->lgf, MONO));
 890
 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   }
 903
 904   GST_DEBUG_OBJECT (lame, "done with setup");
 905   return res;
 906 #undef CHECK_ERROR
 907 }
 908
 909 gboolean
 910 gst_lamemp3enc_register (GstPlugin * plugin)
 911 {
 912   GST_DEBUG_CATEGORY_INIT (debug, "lamemp3enc", 0, "lame mp3 encoder");
 913
 914   if (!gst_element_register (plugin, "lamemp3enc", GST_RANK_PRIMARY,
 915           GST_TYPE_LAMEMP3ENC))
 916     return FALSE;
 917
 918   return TRUE;
 919 }