ext/lame/gstlame.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  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 /**
  23  * SECTION:element-lame
  24  * @see_also: lame, mad, vorbisenc
  25  *
  26  * This element encodes raw integer audio into an MPEG-1 layer 3 (MP3) stream.
  27  * Note that <ulink url="http://en.wikipedia.org/wiki/MP3">MP3</ulink> is not
  28  * a free format, there are licensing and patent issues to take into
  29  * consideration. See <ulink url="http://www.vorbis.com/">Ogg/Vorbis</ulink>
  30  * for a royalty free (and often higher quality) alternative.
  31  *
  32  * <refsect2>
  33  * <title>Note</title>
  34  * This element is deprecated, use the lame element instead
  35  * which provides a much simpler interface and results in better MP3 files.
  36  * </refsect2>
  37  *
  38  * <refsect2>
  39  * <title>Output sample rate</title>
  40  * If no fixed output sample rate is negotiated on the element's src pad,
  41  * the element will choose an optimal sample rate to resample to internally.
  42  * For example, a 16-bit 44.1 KHz mono audio stream encoded at 48 kbit will
  43  * get resampled to 32 KHz.  Use filter caps on the src pad to force a
  44  * particular sample rate.
  45  * </refsect2>
  46  * <refsect2>
  47  * <title>Writing metadata (tags)</title>
  48  * Whilst the lame encoder element does claim to implement the GstTagSetter
  49  * interface, it does so only for backwards compatibility reasons. Tag writing
  50  * has been removed from lame. Use external elements like id3v2mux or apev2mux
  51  * to add tags to your MP3 streams. The same goes for XING headers: use the
  52  * xingmux element to add XING headers to your VBR mp3 file.
  53  * </refsect2>
  54  * <refsect2>
  55  * <title>Example pipelines</title>
  56  * |[
  57  * gst-launch -v audiotestsrc wave=sine num-buffers=100 ! audioconvert ! lame ! filesink location=sine.mp3
  58  * ]| Encode a test sine signal to MP3.
  59  * |[
  60  * gst-launch -v alsasrc ! audioconvert ! lame bitrate=192 ! filesink location=alsasrc.mp3
  61  * ]| Record from a sound card using ALSA and encode to MP3
  62  * |[
  63  * gst-launch -v filesrc location=music.wav ! decodebin ! audioconvert ! audioresample ! lame bitrate=192 ! id3v2mux ! filesink location=music.mp3
  64  * ]| Transcode from a .wav file to MP3 (the id3v2mux element is optional)
  65  * |[
  66  * gst-launch -v cdda://5 ! audioconvert ! lame bitrate=192 ! filesink location=track5.mp3
  67  * ]| Encode Audio CD track 5 to MP3
  68  * |[
  69  * gst-launch -v audiotestsrc num-buffers=10 ! audio/x-raw-int,rate=44100,channels=1 ! lame bitrate=48 mode=3 ! filesink location=test.mp3
  70  * ]| Encode to a fixed sample rate
  71  * </refsect2>
  72  *
  73  * Last reviewed on 2007-07-24 (0.10.7)
  74  */
  75
  76 /* FIXME 0.11: Remove all properties except the useful ones. Nobody knows what most
  77  * properties are doing and they're intended for LAME developers only.
  78  */
  79
  80 #ifdef HAVE_CONFIG_H
  81 #include "config.h"
  82 #endif
  83
  84 #include "string.h"
  85 #include "gstlame.h"
  86 #include "gst/gst-i18n-plugin.h"
  87
  88 #ifdef lame_set_preset
  89 #define GST_LAME_PRESET
  90 #endif
  91
  92 GST_DEBUG_CATEGORY_STATIC (debug);
  93 #define GST_CAT_DEFAULT debug
  94
  95 /* LAME can do MPEG-1, MPEG-2, and MPEG-2.5, so it has 9 possible
  96  * sample rates it supports */
  97 static GstStaticPadTemplate gst_lame_sink_template =
  98 GST_STATIC_PAD_TEMPLATE ("sink",
  99     GST_PAD_SINK,
 100     GST_PAD_ALWAYS,
 101     GST_STATIC_CAPS ("audio/x-raw-int, "
 102         "endianness = (int) " G_STRINGIFY (G_BYTE_ORDER) ", "
 103         "signed = (boolean) true, "
 104         "width = (int) 16, "
 105         "depth = (int) 16, "
 106         "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, "
 107         "channels = (int) [ 1, 2 ]")
 108     );
 109
 110 static GstStaticPadTemplate gst_lame_src_template =
 111 GST_STATIC_PAD_TEMPLATE ("src",
 112     GST_PAD_SRC,
 113     GST_PAD_ALWAYS,
 114     GST_STATIC_CAPS ("audio/mpeg, "
 115         "mpegversion = (int) 1, "
 116         "layer = (int) 3, "
 117         "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, "
 118         "channels = (int) [ 1, 2 ]")
 119     );
 120
 121 static struct
 122 {
 123   gint bitrate;
 124   gfloat compression_ratio;
 125   gint quality;
 126   gint mode;
 127   gboolean force_ms;
 128   gboolean free_format;
 129   gboolean copyright;
 130   gboolean original;
 131   gboolean error_protection;
 132   gboolean extension;
 133   gboolean strict_iso;
 134   gboolean disable_reservoir;
 135   gint vbr;
 136   gint vbr_quality;
 137   gint vbr_mean_bitrate;
 138   gint vbr_min_bitrate;
 139   gint vbr_max_bitrate;
 140   gint vbr_hard_min;
 141   gint lowpass_freq;
 142   gint lowpass_width;
 143   gint highpass_freq;
 144   gint highpass_width;
 145   gboolean ath_only;
 146   gboolean ath_short;
 147   gboolean no_ath;
 148   gint ath_type;
 149   gint ath_lower;
 150   gboolean allow_diff_short;
 151   gboolean no_short_blocks;
 152   gboolean emphasis;
 153   gint preset;
 154 } gst_lame_default_settings;
 155
 156 /********** Define useful types for non-programmatic interfaces **********/
 157 #define GST_TYPE_LAME_MODE (gst_lame_mode_get_type())
 158 static GType
 159 gst_lame_mode_get_type (void)
 160 {
 161   static GType lame_mode_type = 0;
 162   static GEnumValue lame_modes[] = {
 163     {0, "Stereo", "stereo"},
 164     {1, "Joint Stereo", "joint"},
 165     {2, "Dual Channel", "dual"},
 166     {3, "Mono", "mono"},
 167     {4, "Auto", "auto"},
 168     {0, NULL, NULL}
 169   };
 170
 171   if (!lame_mode_type) {
 172     lame_mode_type = g_enum_register_static ("GstLameMode", lame_modes);
 173   }
 174   return lame_mode_type;
 175 }
 176
 177 #define GST_TYPE_LAME_QUALITY (gst_lame_quality_get_type())
 178 static GType
 179 gst_lame_quality_get_type (void)
 180 {
 181   static GType lame_quality_type = 0;
 182   static GEnumValue lame_quality[] = {
 183     {0, "0 - Best", "0"},
 184     {1, "1", "1"},
 185     {2, "2", "2"},
 186     {3, "3", "3"},
 187     {4, "4", "4"},
 188     {5, "5 - Default", "5"},
 189     {6, "6", "6"},
 190     {7, "7", "7"},
 191     {8, "8", "8"},
 192     {9, "9 - Worst", "9"},
 193     {0, NULL, NULL}
 194   };
 195
 196   if (!lame_quality_type) {
 197     lame_quality_type = g_enum_register_static ("GstLameQuality", lame_quality);
 198   }
 199   return lame_quality_type;
 200 }
 201
 202 #define GST_TYPE_LAME_PADDING (gst_lame_padding_get_type())
 203 static GType
 204 gst_lame_padding_get_type (void)
 205 {
 206   static GType lame_padding_type = 0;
 207   static GEnumValue lame_padding[] = {
 208     {0, "No Padding", "never"},
 209     {1, "Always Pad", "always"},
 210     {2, "Adjust Padding", "adjust"},
 211     {0, NULL, NULL}
 212   };
 213
 214   if (!lame_padding_type) {
 215     lame_padding_type = g_enum_register_static ("GstLamePadding", lame_padding);
 216   }
 217   return lame_padding_type;
 218 }
 219
 220 #define GST_TYPE_LAME_VBRMODE (gst_lame_vbrmode_get_type())
 221 static GType
 222 gst_lame_vbrmode_get_type (void)
 223 {
 224   static GType lame_vbrmode_type = 0;
 225   static GEnumValue lame_vbrmode[] = {
 226     {vbr_off, "No VBR (Constant Bitrate)", "none"},
 227     {vbr_rh, "Lame's old VBR algorithm", "old"},
 228     {vbr_abr, "VBR Average Bitrate", "abr"},
 229     {vbr_mtrh, "Lame's new VBR algorithm", "new"},
 230     {0, NULL, NULL}
 231   };
 232
 233   if (!lame_vbrmode_type) {
 234     lame_vbrmode_type = g_enum_register_static ("GstLameVbrmode", lame_vbrmode);
 235   }
 236
 237   return lame_vbrmode_type;
 238 }
 239
 240 #ifdef GSTLAME_PRESET
 241 #define GST_TYPE_LAME_PRESET (gst_lame_preset_get_type())
 242 static GType
 243 gst_lame_preset_get_type (void)
 244 {
 245   static GType gst_lame_preset = 0;
 246   static GEnumValue gst_lame_presets[] = {
 247     {0, "None", "none"},
 248     {MEDIUM, "Medium", "medium"},
 249     {STANDARD, "Standard", "standard"},
 250     {EXTREME, "Extreme", "extreme"},
 251     {INSANE, "Insane", "insane"},
 252     {0, NULL, NULL}
 253   };
 254
 255   if (!gst_lame_preset) {
 256     gst_lame_preset =
 257         g_enum_register_static ("GstLamePreset", gst_lame_presets);
 258   }
 259
 260   return gst_lame_preset;
 261 }
 262 #endif
 263
 264 /********** Standard stuff for signals and arguments **********/
 265
 266 enum
 267 {
 268   ARG_0,
 269   ARG_BITRATE,
 270   ARG_COMPRESSION_RATIO,
 271   ARG_QUALITY,
 272   ARG_MODE,
 273   ARG_FORCE_MS,
 274   ARG_FREE_FORMAT,
 275   ARG_COPYRIGHT,
 276   ARG_ORIGINAL,
 277   ARG_ERROR_PROTECTION,
 278   ARG_PADDING_TYPE,             /* FIXME: remove in 0.11 */
 279   ARG_EXTENSION,
 280   ARG_STRICT_ISO,
 281   ARG_DISABLE_RESERVOIR,
 282   ARG_VBR,
 283   ARG_VBR_MEAN_BITRATE,
 284   ARG_VBR_MIN_BITRATE,
 285   ARG_VBR_MAX_BITRATE,
 286   ARG_VBR_HARD_MIN,
 287   ARG_LOWPASS_FREQ,
 288   ARG_LOWPASS_WIDTH,
 289   ARG_HIGHPASS_FREQ,
 290   ARG_HIGHPASS_WIDTH,
 291   ARG_ATH_ONLY,
 292   ARG_ATH_SHORT,
 293   ARG_NO_ATH,
 294   ARG_ATH_LOWER,
 295   ARG_CWLIMIT,                  /* FIXME: remove in 0.11 */
 296   ARG_ALLOW_DIFF_SHORT,
 297   ARG_NO_SHORT_BLOCKS,
 298   ARG_EMPHASIS,
 299   ARG_VBR_QUALITY,
 300 #ifdef GSTLAME_PRESET
 301   ARG_XINGHEADER,               /* FIXME: remove in 0.11 */
 302   ARG_PRESET
 303 #else
 304   ARG_XINGHEADER                /* FIXME: remove in 0.11 */
 305 #endif
 306 };
 307
 308 static gboolean gst_lame_start (GstAudioEncoder * enc);
 309 static gboolean gst_lame_stop (GstAudioEncoder * enc);
 310 static gboolean gst_lame_set_format (GstAudioEncoder * enc,
 311     GstAudioInfo * info);
 312 static GstFlowReturn gst_lame_handle_frame (GstAudioEncoder * enc,
 313     GstBuffer * in_buf);
 314 static void gst_lame_flush (GstAudioEncoder * enc);
 315
 316 static void gst_lame_set_property (GObject * object, guint prop_id,
 317     const GValue * value, GParamSpec * pspec);
 318 static void gst_lame_get_property (GObject * object, guint prop_id,
 319     GValue * value, GParamSpec * pspec);
 320 static gboolean gst_lame_setup (GstLame * lame);
 321
 322 static void
 323 gst_lame_add_interfaces (GType lame_type)
 324 {
 325   static const GInterfaceInfo tag_setter_info = { NULL, NULL, NULL };
 326
 327   /* FIXME: remove support for the GstTagSetter interface in 0.11 */
 328   g_type_add_interface_static (lame_type, GST_TYPE_TAG_SETTER,
 329       &tag_setter_info);
 330 }
 331
 332 GST_BOILERPLATE_FULL (GstLame, gst_lame, GstAudioEncoder,
 333     GST_TYPE_AUDIO_ENCODER, gst_lame_add_interfaces);
 334
 335 static void
 336 gst_lame_release_memory (GstLame * lame)
 337 {
 338   if (lame->lgf) {
 339     lame_close (lame->lgf);
 340     lame->lgf = NULL;
 341   }
 342 }
 343
 344 static void
 345 gst_lame_finalize (GObject * obj)
 346 {
 347   gst_lame_release_memory (GST_LAME (obj));
 348
 349   G_OBJECT_CLASS (parent_class)->finalize (obj);
 350 }
 351
 352 static void
 353 gst_lame_base_init (gpointer g_class)
 354 {
 355   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 356
 357   gst_element_class_add_static_pad_template (element_class,
 358       &gst_lame_src_template);
 359   gst_element_class_add_static_pad_template (element_class,
 360       &gst_lame_sink_template);
 361   gst_element_class_set_details_simple (element_class, "L.A.M.E. mp3 encoder",
 362       "Codec/Encoder/Audio",
 363       "High-quality free MP3 encoder (deprecated)",
 364       "Erik Walthinsen <omega@cse.ogi.edu>, " "Wim Taymans <wim@fluendo.com>");
 365 }
 366
 367 static void
 368 gst_lame_class_init (GstLameClass * klass)
 369 {
 370   GObjectClass *gobject_class;
 371   GstAudioEncoderClass *base_class;
 372
 373   gobject_class = (GObjectClass *) klass;
 374   base_class = (GstAudioEncoderClass *) klass;
 375
 376   gobject_class->set_property = gst_lame_set_property;
 377   gobject_class->get_property = gst_lame_get_property;
 378   gobject_class->finalize = gst_lame_finalize;
 379
 380   base_class->start = GST_DEBUG_FUNCPTR (gst_lame_start);
 381   base_class->stop = GST_DEBUG_FUNCPTR (gst_lame_stop);
 382   base_class->set_format = GST_DEBUG_FUNCPTR (gst_lame_set_format);
 383   base_class->handle_frame = GST_DEBUG_FUNCPTR (gst_lame_handle_frame);
 384   base_class->flush = GST_DEBUG_FUNCPTR (gst_lame_flush);
 385
 386   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BITRATE,
 387       g_param_spec_int ("bitrate", "Bitrate (kb/s)",
 388           "Bitrate in kbit/sec (8, 16, 24, 32, 40, 48, 56, 64, 80, 96, "
 389           "112, 128, 160, 192, 224, 256 or 320)",
 390           0, 320, gst_lame_default_settings.bitrate,
 391           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 392   /* compression ratio set to 0.0 by default otherwise it overrides the bitrate setting */
 393   g_object_class_install_property (G_OBJECT_CLASS (klass),
 394       ARG_COMPRESSION_RATIO, g_param_spec_float ("compression-ratio",
 395           "Compression Ratio",
 396           "let lame choose bitrate to achieve selected compression ratio", 0.0,
 397           200.0, gst_lame_default_settings.compression_ratio,
 398           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 399   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_QUALITY,
 400       g_param_spec_enum ("quality", "Quality",
 401           "Quality of algorithm used for encoding", GST_TYPE_LAME_QUALITY,
 402           gst_lame_default_settings.quality,
 403           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 404   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MODE,
 405       g_param_spec_enum ("mode", "Mode", "Encoding mode", GST_TYPE_LAME_MODE,
 406           gst_lame_default_settings.mode,
 407           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 408   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FORCE_MS,
 409       g_param_spec_boolean ("force-ms", "Force ms",
 410           "Force ms_stereo on all frames", gst_lame_default_settings.force_ms,
 411           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 412   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FREE_FORMAT,
 413       g_param_spec_boolean ("free-format", "Free format",
 414           "Produce a free format bitstream",
 415           gst_lame_default_settings.free_format,
 416           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 417   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_COPYRIGHT,
 418       g_param_spec_boolean ("copyright", "Copyright", "Mark as copyright",
 419           gst_lame_default_settings.copyright,
 420           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 421   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ORIGINAL,
 422       g_param_spec_boolean ("original", "Original", "Mark as original",
 423           gst_lame_default_settings.original,
 424           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 425   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ERROR_PROTECTION,
 426       g_param_spec_boolean ("error-protection", "Error protection",
 427           "Adds 16 bit checksum to every frame",
 428           gst_lame_default_settings.error_protection,
 429           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 430   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PADDING_TYPE,
 431       g_param_spec_enum ("padding-type", "Padding type",
 432           "Padding type " "(DEPRECATED: this setting has no effect)",
 433           GST_TYPE_LAME_PADDING, FALSE,
 434           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 435   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EXTENSION,
 436       g_param_spec_boolean ("extension", "Extension", "Extension",
 437           gst_lame_default_settings.extension,
 438           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 439   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_STRICT_ISO,
 440       g_param_spec_boolean ("strict-iso", "Strict ISO",
 441           "Comply as much as possible to ISO MPEG spec", TRUE,
 442           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 443   g_object_class_install_property (G_OBJECT_CLASS (klass),
 444       ARG_DISABLE_RESERVOIR, g_param_spec_boolean ("disable-reservoir",
 445           "Disable reservoir", "Disable the bit reservoir", TRUE,
 446           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 447   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR,
 448       g_param_spec_enum ("vbr", "VBR", "Specify bitrate mode",
 449           GST_TYPE_LAME_VBRMODE, gst_lame_default_settings.vbr,
 450           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 451   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_QUALITY,
 452       g_param_spec_enum ("vbr-quality", "VBR Quality", "VBR Quality",
 453           GST_TYPE_LAME_QUALITY, gst_lame_default_settings.vbr_quality,
 454           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 455   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_MEAN_BITRATE,
 456       g_param_spec_int ("vbr-mean-bitrate", "VBR mean bitrate",
 457           "Specify mean VBR bitrate", 0, 320,
 458           gst_lame_default_settings.vbr_mean_bitrate,
 459           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 460   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_MIN_BITRATE,
 461       g_param_spec_int ("vbr-min-bitrate", "VBR min bitrate",
 462           "Specify minimum VBR bitrate (8, 16, 24, 32, 40, 48, 56, 64, 80, 96, "
 463           "112, 128, 160, 192, 224, 256 or 320)", 0, 320,
 464           gst_lame_default_settings.vbr_min_bitrate,
 465           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 466   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_MAX_BITRATE,
 467       g_param_spec_int ("vbr-max-bitrate", "VBR max bitrate",
 468           "Specify maximum VBR bitrate (8, 16, 24, 32, 40, 48, 56, 64, 80, 96, "
 469           "112, 128, 160, 192, 224, 256 or 320)", 0, 320,
 470           gst_lame_default_settings.vbr_max_bitrate,
 471           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 472   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_HARD_MIN,
 473       g_param_spec_int ("vbr-hard-min", "VBR hard min",
 474           "Specify whether min VBR bitrate is a hard limit. Normally, "
 475           "it can be violated for silence", 0, 1,
 476           gst_lame_default_settings.vbr_hard_min,
 477           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 478   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOWPASS_FREQ,
 479       g_param_spec_int ("lowpass-freq", "Lowpass freq",
 480           "frequency(kHz), lowpass filter cutoff above freq", 0, 50000,
 481           gst_lame_default_settings.lowpass_freq,
 482           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 483   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOWPASS_WIDTH,
 484       g_param_spec_int ("lowpass-width", "Lowpass width",
 485           "frequency(kHz) - default 15% of lowpass freq", -1, G_MAXINT,
 486           gst_lame_default_settings.lowpass_width,
 487           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 488   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_HIGHPASS_FREQ,
 489       g_param_spec_int ("highpass-freq", "Highpass freq",
 490           "frequency(kHz), highpass filter cutoff below freq", 0, 50000,
 491           gst_lame_default_settings.highpass_freq,
 492           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 493   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_HIGHPASS_WIDTH,
 494       g_param_spec_int ("highpass-width", "Highpass width",
 495           "frequency(kHz) - default 15% of highpass freq", -1, G_MAXINT,
 496           gst_lame_default_settings.highpass_width,
 497           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 498   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ATH_ONLY,
 499       g_param_spec_boolean ("ath-only", "ATH only",
 500           "Ignore GPSYCHO completely, use ATH only",
 501           gst_lame_default_settings.ath_only,
 502           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 503   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ATH_SHORT,
 504       g_param_spec_boolean ("ath-short", "ATH short",
 505           "Ignore GPSYCHO for short blocks, use ATH only",
 506           gst_lame_default_settings.ath_short,
 507           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 508   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NO_ATH,
 509       g_param_spec_boolean ("no-ath", "No ath",
 510           "turns ATH down to a flat noise floor",
 511           gst_lame_default_settings.no_ath,
 512           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 513   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ATH_LOWER,
 514       g_param_spec_int ("ath-lower", "ATH lower", "lowers ATH by x dB",
 515           G_MININT, G_MAXINT, gst_lame_default_settings.ath_lower,
 516           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 517   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_CWLIMIT,
 518       g_param_spec_int ("cwlimit", "Cwlimit",
 519           "Compute tonality up to freq (in kHz) default 8.8717 "
 520           "(DEPRECATED: this setting has no effect)", 0, 50000, 0,
 521           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 522   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ALLOW_DIFF_SHORT,
 523       g_param_spec_boolean ("allow-diff-short", "Allow diff short",
 524           "Allow diff short", gst_lame_default_settings.allow_diff_short,
 525           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 526   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NO_SHORT_BLOCKS,
 527       g_param_spec_boolean ("no-short-blocks", "No short blocks",
 528           "Do not use short blocks", gst_lame_default_settings.no_short_blocks,
 529           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 530   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EMPHASIS,
 531       g_param_spec_boolean ("emphasis", "Emphasis", "Emphasis",
 532           gst_lame_default_settings.emphasis,
 533           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 534   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_XINGHEADER,
 535       g_param_spec_boolean ("xingheader", "Output Xing Header",
 536           "Output Xing Header (BROKEN, use xingmux instead)", FALSE,
 537           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 538 #ifdef GSTLAME_PRESET
 539   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PRESET,
 540       g_param_spec_enum ("preset", "Lame Preset", "Lame Preset",
 541           GST_TYPE_LAME_PRESET, gst_lame_default_settings.preset,
 542           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 543 #endif
 544 }
 545
 546 static gboolean
 547 gst_lame_set_format (GstAudioEncoder * enc, GstAudioInfo * info)
 548 {
 549   GstLame *lame;
 550   gint out_samplerate;
 551   gint version;
 552   GstCaps *othercaps;
 553   GstClockTime latency;
 554
 555   lame = GST_LAME (enc);
 556
 557   /* parameters already parsed for us */
 558   lame->samplerate = GST_AUDIO_INFO_RATE (info);
 559   lame->num_channels = GST_AUDIO_INFO_CHANNELS (info);
 560
 561   /* but we might be asked to reconfigure, so reset */
 562   gst_lame_release_memory (lame);
 563
 564   GST_DEBUG_OBJECT (lame, "setting up lame");
 565   if (!gst_lame_setup (lame))
 566     goto setup_failed;
 567
 568   out_samplerate = lame_get_out_samplerate (lame->lgf);
 569   if (out_samplerate == 0)
 570     goto zero_output_rate;
 571   if (out_samplerate != lame->samplerate) {
 572     GST_WARNING_OBJECT (lame,
 573         "output samplerate %d is different from incoming samplerate %d",
 574         out_samplerate, lame->samplerate);
 575   }
 576
 577   version = lame_get_version (lame->lgf);
 578   if (version == 0)
 579     version = 2;
 580   else if (version == 1)
 581     version = 1;
 582   else if (version == 2)
 583     version = 3;
 584
 585   othercaps =
 586       gst_caps_new_simple ("audio/mpeg",
 587       "mpegversion", G_TYPE_INT, 1,
 588       "mpegaudioversion", G_TYPE_INT, version,
 589       "layer", G_TYPE_INT, 3,
 590       "channels", G_TYPE_INT, lame->mode == MONO ? 1 : lame->num_channels,
 591       "rate", G_TYPE_INT, out_samplerate, NULL);
 592
 593   /* and use these caps */
 594   gst_pad_set_caps (GST_AUDIO_ENCODER_SRC_PAD (lame), othercaps);
 595   gst_caps_unref (othercaps);
 596
 597   /* base class feedback:
 598    * - we will handle buffers, just hand us all available
 599    * - report latency */
 600   latency = gst_util_uint64_scale_int (lame_get_framesize (lame->lgf),
 601       GST_SECOND, lame->samplerate);
 602   gst_audio_encoder_set_latency (enc, latency, latency);
 603
 604   return TRUE;
 605
 606 zero_output_rate:
 607   {
 608     GST_ELEMENT_ERROR (lame, LIBRARY, SETTINGS, (NULL),
 609         ("LAME decided on a zero sample rate"));
 610     return FALSE;
 611   }
 612 setup_failed:
 613   {
 614     GST_ELEMENT_ERROR (lame, LIBRARY, SETTINGS,
 615         (_("Failed to configure LAME encoder. Check your encoding parameters.")), (NULL));
 616     return FALSE;
 617   }
 618 }
 619
 620 static void
 621 gst_lame_init (GstLame * lame, GstLameClass * klass)
 622 {
 623   GST_DEBUG_OBJECT (lame, "starting initialization");
 624
 625   /* Set default settings */
 626   lame->bitrate = gst_lame_default_settings.bitrate;
 627   lame->compression_ratio = gst_lame_default_settings.compression_ratio;
 628   lame->quality = gst_lame_default_settings.quality;
 629   lame->mode = gst_lame_default_settings.mode;
 630   lame->requested_mode = lame->mode;
 631   lame->force_ms = gst_lame_default_settings.force_ms;
 632   lame->free_format = gst_lame_default_settings.free_format;
 633   lame->copyright = gst_lame_default_settings.copyright;
 634   lame->original = gst_lame_default_settings.original;
 635   lame->error_protection = gst_lame_default_settings.error_protection;
 636   lame->extension = gst_lame_default_settings.extension;
 637   lame->strict_iso = gst_lame_default_settings.strict_iso;
 638   lame->disable_reservoir = gst_lame_default_settings.disable_reservoir;
 639   lame->vbr = gst_lame_default_settings.vbr;
 640   lame->vbr_quality = gst_lame_default_settings.vbr_quality;
 641   lame->vbr_mean_bitrate = gst_lame_default_settings.vbr_mean_bitrate;
 642   lame->vbr_min_bitrate = gst_lame_default_settings.vbr_min_bitrate;
 643   lame->vbr_max_bitrate = gst_lame_default_settings.vbr_max_bitrate;
 644   lame->vbr_hard_min = gst_lame_default_settings.vbr_hard_min;
 645   lame->lowpass_freq = gst_lame_default_settings.lowpass_freq;
 646   lame->lowpass_width = gst_lame_default_settings.lowpass_width;
 647   lame->highpass_freq = gst_lame_default_settings.highpass_freq;
 648   lame->highpass_width = gst_lame_default_settings.highpass_width;
 649   lame->ath_only = gst_lame_default_settings.ath_only;
 650   lame->ath_short = gst_lame_default_settings.ath_short;
 651   lame->no_ath = gst_lame_default_settings.no_ath;
 652   lame->ath_lower = gst_lame_default_settings.ath_lower;
 653   lame->allow_diff_short = gst_lame_default_settings.allow_diff_short;
 654   lame->no_short_blocks = gst_lame_default_settings.no_short_blocks;
 655   lame->emphasis = gst_lame_default_settings.emphasis;
 656   lame->preset = gst_lame_default_settings.preset;
 657
 658   GST_DEBUG_OBJECT (lame, "done initializing");
 659 }
 660
 661 static gboolean
 662 gst_lame_start (GstAudioEncoder * enc)
 663 {
 664   GstLame *lame = GST_LAME (enc);
 665
 666   GST_DEBUG_OBJECT (lame, "start");
 667   return TRUE;
 668 }
 669
 670 static gboolean
 671 gst_lame_stop (GstAudioEncoder * enc)
 672 {
 673   GstLame *lame = GST_LAME (enc);
 674
 675   GST_DEBUG_OBJECT (lame, "stop");
 676
 677   gst_lame_release_memory (lame);
 678   return TRUE;
 679 }
 680
 681
 682 /* <php-emulation-mode>three underscores for ___rate is really really really
 683  * private as opposed to one underscore<php-emulation-mode> */
 684 /* call this MACRO outside of the NULL state so that we have a higher chance
 685  * of actually having a pipeline and bus to get the message through */
 686
 687 #define CHECK_AND_FIXUP_BITRATE(obj,param,rate,free_format)               \
 688 G_STMT_START {                                                            \
 689   gint ___rate = rate;                                                    \
 690   gint maxrate = 320;                                                     \
 691   gint multiplier = 64;                                                   \
 692   if (!free_format) {                                                     \
 693     if (rate == 0) {                                                      \
 694       ___rate = rate;                                                     \
 695     } else if (rate <= 64) {                                              \
 696       maxrate = 64; multiplier = 8;                                       \
 697       if ((rate % 8) != 0) ___rate = GST_ROUND_UP_8 (rate);               \
 698     } else if (rate <= 128) {                                             \
 699       maxrate = 128; multiplier = 16;                                     \
 700       if ((rate % 16) != 0) ___rate = GST_ROUND_UP_16 (rate);             \
 701     } else if (rate <= 256) {                                             \
 702       maxrate = 256; multiplier = 32;                                     \
 703       if ((rate % 32) != 0) ___rate = GST_ROUND_UP_32 (rate);             \
 704     } else if (rate <= 320) {                                             \
 705       maxrate = 320; multiplier = 64;                                     \
 706       if ((rate % 64) != 0) ___rate = GST_ROUND_UP_64 (rate);             \
 707     }                                                                     \
 708     if (___rate != rate) {                                                \
 709       GST_ELEMENT_WARNING (obj, LIBRARY, SETTINGS,                        \
 710           (_("The requested bitrate %d kbit/s for property '%s' "         \
 711              "is not allowed. "                                           \
 712             "The bitrate was changed to %d kbit/s."), rate,               \
 713             param,  ___rate),                                             \
 714           ("A bitrate below %d should be a multiple of %d.",              \
 715               maxrate, multiplier));                                      \
 716       rate = ___rate;                                                     \
 717     }                                                                     \
 718   }                                                                       \
 719 } G_STMT_END
 720
 721 static void
 722 gst_lame_set_property (GObject * object, guint prop_id, const GValue * value,
 723     GParamSpec * pspec)
 724 {
 725   GstLame *lame;
 726
 727   lame = GST_LAME (object);
 728
 729   switch (prop_id) {
 730     case ARG_BITRATE:
 731       lame->bitrate = g_value_get_int (value);
 732       break;
 733     case ARG_COMPRESSION_RATIO:
 734       lame->compression_ratio = g_value_get_float (value);
 735       break;
 736     case ARG_QUALITY:
 737       lame->quality = g_value_get_enum (value);
 738       break;
 739     case ARG_MODE:
 740       lame->requested_mode = g_value_get_enum (value);
 741       break;
 742     case ARG_FORCE_MS:
 743       lame->force_ms = g_value_get_boolean (value);
 744       break;
 745     case ARG_FREE_FORMAT:
 746       lame->free_format = g_value_get_boolean (value);
 747       break;
 748     case ARG_COPYRIGHT:
 749       lame->copyright = g_value_get_boolean (value);
 750       break;
 751     case ARG_ORIGINAL:
 752       lame->original = g_value_get_boolean (value);
 753       break;
 754     case ARG_ERROR_PROTECTION:
 755       lame->error_protection = g_value_get_boolean (value);
 756       break;
 757     case ARG_PADDING_TYPE:
 758       break;
 759     case ARG_EXTENSION:
 760       lame->extension = g_value_get_boolean (value);
 761       break;
 762     case ARG_STRICT_ISO:
 763       lame->strict_iso = g_value_get_boolean (value);
 764       break;
 765     case ARG_DISABLE_RESERVOIR:
 766       lame->disable_reservoir = g_value_get_boolean (value);
 767       break;
 768     case ARG_VBR:
 769       lame->vbr = g_value_get_enum (value);
 770       break;
 771     case ARG_VBR_QUALITY:
 772       lame->vbr_quality = g_value_get_enum (value);
 773       break;
 774     case ARG_VBR_MEAN_BITRATE:
 775       lame->vbr_mean_bitrate = g_value_get_int (value);
 776       break;
 777     case ARG_VBR_MIN_BITRATE:
 778       lame->vbr_min_bitrate = g_value_get_int (value);
 779       break;
 780     case ARG_VBR_MAX_BITRATE:
 781       lame->vbr_max_bitrate = g_value_get_int (value);
 782       break;
 783     case ARG_VBR_HARD_MIN:
 784       lame->vbr_hard_min = g_value_get_int (value);
 785       break;
 786     case ARG_LOWPASS_FREQ:
 787       lame->lowpass_freq = g_value_get_int (value);
 788       break;
 789     case ARG_LOWPASS_WIDTH:
 790       lame->lowpass_width = g_value_get_int (value);
 791       break;
 792     case ARG_HIGHPASS_FREQ:
 793       lame->highpass_freq = g_value_get_int (value);
 794       break;
 795     case ARG_HIGHPASS_WIDTH:
 796       lame->highpass_width = g_value_get_int (value);
 797       break;
 798     case ARG_ATH_ONLY:
 799       lame->ath_only = g_value_get_boolean (value);
 800       break;
 801     case ARG_ATH_SHORT:
 802       lame->ath_short = g_value_get_boolean (value);
 803       break;
 804     case ARG_NO_ATH:
 805       lame->no_ath = g_value_get_boolean (value);
 806       break;
 807     case ARG_ATH_LOWER:
 808       lame->ath_lower = g_value_get_int (value);
 809       break;
 810     case ARG_CWLIMIT:
 811       break;
 812     case ARG_ALLOW_DIFF_SHORT:
 813       lame->allow_diff_short = g_value_get_boolean (value);
 814       break;
 815     case ARG_NO_SHORT_BLOCKS:
 816       lame->no_short_blocks = g_value_get_boolean (value);
 817       break;
 818     case ARG_EMPHASIS:
 819       lame->emphasis = g_value_get_boolean (value);
 820       break;
 821     case ARG_XINGHEADER:
 822       break;
 823 #ifdef GSTLAME_PRESET
 824     case ARG_PRESET:
 825       lame->preset = g_value_get_enum (value);
 826       break;
 827 #endif
 828     default:
 829       break;
 830   }
 831
 832 }
 833
 834 static void
 835 gst_lame_get_property (GObject * object, guint prop_id, GValue * value,
 836     GParamSpec * pspec)
 837 {
 838   GstLame *lame;
 839
 840   lame = GST_LAME (object);
 841
 842   switch (prop_id) {
 843     case ARG_BITRATE:
 844       g_value_set_int (value, lame->bitrate);
 845       break;
 846     case ARG_COMPRESSION_RATIO:
 847       g_value_set_float (value, lame->compression_ratio);
 848       break;
 849     case ARG_QUALITY:
 850       g_value_set_enum (value, lame->quality);
 851       break;
 852     case ARG_MODE:
 853       g_value_set_enum (value, lame->requested_mode);
 854       break;
 855     case ARG_FORCE_MS:
 856       g_value_set_boolean (value, lame->force_ms);
 857       break;
 858     case ARG_FREE_FORMAT:
 859       g_value_set_boolean (value, lame->free_format);
 860       break;
 861     case ARG_COPYRIGHT:
 862       g_value_set_boolean (value, lame->copyright);
 863       break;
 864     case ARG_ORIGINAL:
 865       g_value_set_boolean (value, lame->original);
 866       break;
 867     case ARG_ERROR_PROTECTION:
 868       g_value_set_boolean (value, lame->error_protection);
 869       break;
 870     case ARG_PADDING_TYPE:
 871       break;
 872     case ARG_EXTENSION:
 873       g_value_set_boolean (value, lame->extension);
 874       break;
 875     case ARG_STRICT_ISO:
 876       g_value_set_boolean (value, lame->strict_iso);
 877       break;
 878     case ARG_DISABLE_RESERVOIR:
 879       g_value_set_boolean (value, lame->disable_reservoir);
 880       break;
 881     case ARG_VBR:
 882       g_value_set_enum (value, lame->vbr);
 883       break;
 884     case ARG_VBR_QUALITY:
 885       g_value_set_enum (value, lame->vbr_quality);
 886       break;
 887     case ARG_VBR_MEAN_BITRATE:
 888       g_value_set_int (value, lame->vbr_mean_bitrate);
 889       break;
 890     case ARG_VBR_MIN_BITRATE:
 891       g_value_set_int (value, lame->vbr_min_bitrate);
 892       break;
 893     case ARG_VBR_MAX_BITRATE:
 894       g_value_set_int (value, lame->vbr_max_bitrate);
 895       break;
 896     case ARG_VBR_HARD_MIN:
 897       g_value_set_int (value, lame->vbr_hard_min);
 898       break;
 899     case ARG_LOWPASS_FREQ:
 900       g_value_set_int (value, lame->lowpass_freq);
 901       break;
 902     case ARG_LOWPASS_WIDTH:
 903       g_value_set_int (value, lame->lowpass_width);
 904       break;
 905     case ARG_HIGHPASS_FREQ:
 906       g_value_set_int (value, lame->highpass_freq);
 907       break;
 908     case ARG_HIGHPASS_WIDTH:
 909       g_value_set_int (value, lame->highpass_width);
 910       break;
 911     case ARG_ATH_ONLY:
 912       g_value_set_boolean (value, lame->ath_only);
 913       break;
 914     case ARG_ATH_SHORT:
 915       g_value_set_boolean (value, lame->ath_short);
 916       break;
 917     case ARG_NO_ATH:
 918       g_value_set_boolean (value, lame->no_ath);
 919       break;
 920     case ARG_ATH_LOWER:
 921       g_value_set_int (value, lame->ath_lower);
 922       break;
 923     case ARG_CWLIMIT:
 924       break;
 925     case ARG_ALLOW_DIFF_SHORT:
 926       g_value_set_boolean (value, lame->allow_diff_short);
 927       break;
 928     case ARG_NO_SHORT_BLOCKS:
 929       g_value_set_boolean (value, lame->no_short_blocks);
 930       break;
 931     case ARG_EMPHASIS:
 932       g_value_set_boolean (value, lame->emphasis);
 933       break;
 934     case ARG_XINGHEADER:
 935       break;
 936 #ifdef GSTLAME_PRESET
 937     case ARG_PRESET:
 938       g_value_set_enum (value, lame->preset);
 939       break;
 940 #endif
 941     default:
 942       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 943       break;
 944   }
 945 }
 946
 947 static GstFlowReturn
 948 gst_lame_flush_full (GstLame * lame, gboolean push)
 949 {
 950   GstBuffer *buf;
 951   gint size;
 952   GstFlowReturn result = GST_FLOW_OK;
 953
 954   if (!lame->lgf)
 955     return GST_FLOW_OK;
 956
 957   buf = gst_buffer_new_and_alloc (7200);
 958   size = lame_encode_flush (lame->lgf, GST_BUFFER_DATA (buf), 7200);
 959
 960   if (size > 0 && push) {
 961     GST_BUFFER_SIZE (buf) = size;
 962     GST_DEBUG_OBJECT (lame, "pushing final packet of %u bytes", size);
 963     result = gst_audio_encoder_finish_frame (GST_AUDIO_ENCODER (lame), buf, -1);
 964   } else {
 965     GST_DEBUG_OBJECT (lame, "no final packet (size=%d, push=%d)", size, push);
 966     gst_buffer_unref (buf);
 967     result = GST_FLOW_OK;
 968   }
 969   return result;
 970 }
 971
 972 static void
 973 gst_lame_flush (GstAudioEncoder * enc)
 974 {
 975   gst_lame_flush_full (GST_LAME (enc), FALSE);
 976 }
 977
 978 static GstFlowReturn
 979 gst_lame_handle_frame (GstAudioEncoder * enc, GstBuffer * buf)
 980 {
 981   GstLame *lame;
 982   guchar *mp3_data;
 983   GstBuffer *mp3_buf;
 984   gint mp3_buffer_size, mp3_size;
 985   GstFlowReturn result;
 986   gint num_samples;
 987   guint8 *data;
 988   guint size;
 989
 990   lame = GST_LAME (enc);
 991
 992   /* squeeze remaining and push */
 993   if (G_UNLIKELY (buf == NULL))
 994     return gst_lame_flush_full (lame, TRUE);
 995
 996   data = GST_BUFFER_DATA (buf);
 997   size = GST_BUFFER_SIZE (buf);
 998
 999   num_samples = size / 2;
1000
1001   /* allocate space for output */
1002   mp3_buffer_size = 1.25 * num_samples + 7200;
1003   mp3_buf = gst_buffer_new_and_alloc (mp3_buffer_size);
1004   mp3_data = GST_BUFFER_DATA (mp3_buf);
1005
1006   /* lame seems to be too stupid to get mono interleaved going */
1007   if (lame->num_channels == 1) {
1008     mp3_size = lame_encode_buffer (lame->lgf,
1009         (short int *) data,
1010         (short int *) data, num_samples, mp3_data, mp3_buffer_size);
1011   } else {
1012     mp3_size = lame_encode_buffer_interleaved (lame->lgf,
1013         (short int *) data,
1014         num_samples / lame->num_channels, mp3_data, mp3_buffer_size);
1015   }
1016
1017   GST_LOG_OBJECT (lame, "encoded %d bytes of audio to %d bytes of mp3",
1018       size, mp3_size);
1019
1020   if (mp3_size < 0) {
1021     g_warning ("error %d", mp3_size);
1022   }
1023
1024   if (G_LIKELY (mp3_size > 0)) {
1025     GST_BUFFER_SIZE (mp3_buf) = mp3_size;
1026     result = gst_audio_encoder_finish_frame (enc, mp3_buf, -1);
1027   } else {
1028     if (mp3_size < 0) {
1029       /* eat error ? */
1030       g_warning ("error %d", mp3_size);
1031     }
1032     result = GST_FLOW_OK;
1033     gst_buffer_unref (mp3_buf);
1034   }
1035
1036   return result;
1037 }
1038
1039 /* set up the encoder state */
1040 static gboolean
1041 gst_lame_setup (GstLame * lame)
1042 {
1043
1044 #define CHECK_ERROR(command) G_STMT_START {\
1045   if ((command) < 0) { \
1046     GST_ERROR_OBJECT (lame, "setup failed: " G_STRINGIFY (command)); \
1047     return FALSE; \
1048   } \
1049 }G_STMT_END
1050
1051   int retval;
1052   GstCaps *allowed_caps;
1053
1054   GST_DEBUG_OBJECT (lame, "starting setup");
1055
1056   /* check if we're already setup; if we are, we might want to check
1057    * if this initialization is compatible with the previous one */
1058   /* FIXME: do this */
1059   if (lame->setup) {
1060     GST_WARNING_OBJECT (lame, "already setup");
1061     lame->setup = FALSE;
1062   }
1063
1064   lame->lgf = lame_init ();
1065
1066   if (lame->lgf == NULL)
1067     return FALSE;
1068
1069   /* copy the parameters over */
1070   lame_set_in_samplerate (lame->lgf, lame->samplerate);
1071
1072   /* let lame choose default samplerate unless outgoing sample rate is fixed */
1073   allowed_caps = gst_pad_get_allowed_caps (GST_AUDIO_ENCODER_SRC_PAD (lame));
1074
1075   if (allowed_caps != NULL) {
1076     GstStructure *structure;
1077     gint samplerate;
1078
1079     structure = gst_caps_get_structure (allowed_caps, 0);
1080
1081     if (gst_structure_get_int (structure, "rate", &samplerate)) {
1082       GST_DEBUG_OBJECT (lame, "Setting sample rate to %d as fixed in src caps",
1083           samplerate);
1084       lame_set_out_samplerate (lame->lgf, samplerate);
1085     } else {
1086       GST_DEBUG_OBJECT (lame, "Letting lame choose sample rate");
1087       lame_set_out_samplerate (lame->lgf, 0);
1088     }
1089     gst_caps_unref (allowed_caps);
1090     allowed_caps = NULL;
1091   } else {
1092     GST_DEBUG_OBJECT (lame, "No peer yet, letting lame choose sample rate");
1093     lame_set_out_samplerate (lame->lgf, 0);
1094   }
1095
1096   /* force mono encoding if we only have one channel */
1097   if (lame->num_channels == 1)
1098     lame->mode = 3;
1099   else
1100     lame->mode = lame->requested_mode;
1101
1102   CHECK_ERROR (lame_set_num_channels (lame->lgf, lame->num_channels));
1103   CHECK_AND_FIXUP_BITRATE (lame, "bitrate", lame->bitrate, lame->free_format);
1104   CHECK_ERROR (lame_set_brate (lame->lgf, lame->bitrate));
1105   CHECK_ERROR (lame_set_compression_ratio (lame->lgf, lame->compression_ratio));
1106   CHECK_ERROR (lame_set_quality (lame->lgf, lame->quality));
1107   CHECK_ERROR (lame_set_mode (lame->lgf, lame->mode));
1108   CHECK_ERROR (lame_set_force_ms (lame->lgf, lame->force_ms));
1109   CHECK_ERROR (lame_set_free_format (lame->lgf, lame->free_format));
1110   CHECK_ERROR (lame_set_copyright (lame->lgf, lame->copyright));
1111   CHECK_ERROR (lame_set_original (lame->lgf, lame->original));
1112   CHECK_ERROR (lame_set_error_protection (lame->lgf, lame->error_protection));
1113   CHECK_ERROR (lame_set_extension (lame->lgf, lame->extension));
1114   CHECK_ERROR (lame_set_strict_ISO (lame->lgf, lame->strict_iso));
1115   CHECK_ERROR (lame_set_disable_reservoir (lame->lgf, lame->disable_reservoir));
1116   CHECK_ERROR (lame_set_VBR (lame->lgf, lame->vbr));
1117   CHECK_ERROR (lame_set_VBR_q (lame->lgf, lame->vbr_quality));
1118   CHECK_ERROR (lame_set_VBR_mean_bitrate_kbps (lame->lgf,
1119           lame->vbr_mean_bitrate));
1120   CHECK_AND_FIXUP_BITRATE (lame, "vbr-min-bitrate", lame->vbr_min_bitrate,
1121       lame->free_format);
1122   CHECK_ERROR (lame_set_VBR_min_bitrate_kbps (lame->lgf,
1123           lame->vbr_min_bitrate));
1124   CHECK_AND_FIXUP_BITRATE (lame, "vbr-max-bitrate", lame->vbr_max_bitrate,
1125       lame->free_format);
1126   CHECK_ERROR (lame_set_VBR_max_bitrate_kbps (lame->lgf,
1127           lame->vbr_max_bitrate));
1128   CHECK_ERROR (lame_set_VBR_hard_min (lame->lgf, lame->vbr_hard_min));
1129   CHECK_ERROR (lame_set_lowpassfreq (lame->lgf, lame->lowpass_freq));
1130   CHECK_ERROR (lame_set_lowpasswidth (lame->lgf, lame->lowpass_width));
1131   CHECK_ERROR (lame_set_highpassfreq (lame->lgf, lame->highpass_freq));
1132   CHECK_ERROR (lame_set_highpasswidth (lame->lgf, lame->highpass_width));
1133   CHECK_ERROR (lame_set_ATHonly (lame->lgf, lame->ath_only));
1134   CHECK_ERROR (lame_set_ATHshort (lame->lgf, lame->ath_short));
1135   CHECK_ERROR (lame_set_noATH (lame->lgf, lame->no_ath));
1136   CHECK_ERROR (lame_set_ATHlower (lame->lgf, lame->ath_lower));
1137   CHECK_ERROR (lame_set_allow_diff_short (lame->lgf, lame->allow_diff_short));
1138   CHECK_ERROR (lame_set_no_short_blocks (lame->lgf, lame->no_short_blocks));
1139   CHECK_ERROR (lame_set_emphasis (lame->lgf, lame->emphasis));
1140   CHECK_ERROR (lame_set_bWriteVbrTag (lame->lgf, 0));
1141 #ifdef GSTLAME_PRESET
1142   if (lame->preset > 0) {
1143     CHECK_ERROR (lame_set_preset (lame->lgf, lame->preset));
1144   }
1145 #endif
1146
1147   /* initialize the lame encoder */
1148   if ((retval = lame_init_params (lame->lgf)) >= 0) {
1149     lame->setup = TRUE;
1150     /* FIXME: it would be nice to print out the mode here */
1151     GST_INFO ("lame encoder setup (%d kbit/s, %d Hz, %d channels)",
1152         lame->bitrate, lame->samplerate, lame->num_channels);
1153   } else {
1154     GST_ERROR_OBJECT (lame, "lame_init_params returned %d", retval);
1155   }
1156
1157   GST_DEBUG_OBJECT (lame, "done with setup");
1158
1159   return lame->setup;
1160 #undef CHECK_ERROR
1161 }
1162
1163 static gboolean
1164 gst_lame_get_default_settings (void)
1165 {
1166   lame_global_flags *lgf = NULL;
1167
1168   lgf = lame_init ();
1169   if (lgf == NULL) {
1170     GST_ERROR ("Error initializing LAME");
1171     return FALSE;
1172   }
1173
1174   if (lame_init_params (lgf) < 0) {
1175     GST_ERROR ("Error getting default settings");
1176     return FALSE;
1177   }
1178
1179   gst_lame_default_settings.bitrate = lame_get_brate (lgf);
1180   gst_lame_default_settings.compression_ratio = 0.0;    /* lame_get_compression_ratio (lgf); */
1181   gst_lame_default_settings.quality = lame_get_quality (lgf);
1182   gst_lame_default_settings.mode = lame_get_mode (lgf);
1183   gst_lame_default_settings.force_ms = lame_get_force_ms (lgf);
1184   gst_lame_default_settings.free_format = lame_get_free_format (lgf);
1185   gst_lame_default_settings.copyright = lame_get_copyright (lgf);
1186   gst_lame_default_settings.original = lame_get_original (lgf);
1187   gst_lame_default_settings.error_protection = lame_get_error_protection (lgf);
1188   gst_lame_default_settings.extension = lame_get_extension (lgf);
1189   gst_lame_default_settings.strict_iso = lame_get_strict_ISO (lgf);
1190   gst_lame_default_settings.disable_reservoir =
1191       lame_get_disable_reservoir (lgf);
1192   gst_lame_default_settings.vbr = lame_get_VBR (lgf);
1193   gst_lame_default_settings.vbr_quality = lame_get_VBR_q (lgf);
1194   gst_lame_default_settings.vbr_mean_bitrate =
1195       lame_get_VBR_mean_bitrate_kbps (lgf);
1196   gst_lame_default_settings.vbr_min_bitrate =
1197       lame_get_VBR_min_bitrate_kbps (lgf);
1198   gst_lame_default_settings.vbr_max_bitrate =
1199       lame_get_VBR_max_bitrate_kbps (lgf);
1200   gst_lame_default_settings.vbr_hard_min = lame_get_VBR_hard_min (lgf);
1201   gst_lame_default_settings.lowpass_freq = lame_get_lowpassfreq (lgf);
1202   gst_lame_default_settings.lowpass_width = lame_get_lowpasswidth (lgf);
1203   gst_lame_default_settings.highpass_freq = lame_get_highpassfreq (lgf);
1204   gst_lame_default_settings.highpass_width = lame_get_highpasswidth (lgf);
1205   gst_lame_default_settings.ath_only = lame_get_ATHonly (lgf);
1206   gst_lame_default_settings.ath_short = lame_get_ATHshort (lgf);
1207   gst_lame_default_settings.no_ath = lame_get_noATH (lgf);
1208   gst_lame_default_settings.ath_type = lame_get_ATHtype (lgf);
1209   gst_lame_default_settings.ath_lower = lame_get_ATHlower (lgf);
1210   gst_lame_default_settings.allow_diff_short = lame_get_allow_diff_short (lgf);
1211   gst_lame_default_settings.no_short_blocks = lame_get_no_short_blocks (lgf);
1212   gst_lame_default_settings.emphasis = lame_get_emphasis (lgf);
1213   gst_lame_default_settings.preset = 0;
1214
1215   lame_close (lgf);
1216
1217   return TRUE;
1218 }
1219
1220 gboolean
1221 gst_lame_register (GstPlugin * plugin)
1222 {
1223   GST_DEBUG_CATEGORY_INIT (debug, "lame", 0, "lame mp3 encoder");
1224
1225   if (!gst_lame_get_default_settings ())
1226     return FALSE;
1227
1228   if (!gst_element_register (plugin, "lame", GST_RANK_MARGINAL, GST_TYPE_LAME))
1229     return FALSE;
1230
1231   return TRUE;
1232 }