ext/lame/gstlame.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23 #include "string.h"
  24 #include "gstlame.h"
  25
  26 #ifdef lame_set_preset
  27 #define GST_LAME_PRESET
  28 #endif
  29
  30 GST_DEBUG_CATEGORY_STATIC (debug);
  31 #define GST_CAT_DEFAULT debug
  32
  33 /* elementfactory information */
  34 static GstElementDetails gst_lame_details = {
  35   "L.A.M.E. mp3 encoder",
  36   "Codec/Encoder/Audio",
  37   "High-quality free MP3 encoder",
  38   "Erik Walthinsen <omega@cse.ogi.edu>",
  39 };
  40
  41 /* LAME can do MPEG-1, MPEG-2, and MPEG-2.5, so it has 9 possible
  42  * sample rates it supports */
  43 static GstStaticPadTemplate gst_lame_sink_template =
  44 GST_STATIC_PAD_TEMPLATE ("sink",
  45     GST_PAD_SINK,
  46     GST_PAD_ALWAYS,
  47     GST_STATIC_CAPS ("audio/x-raw-int, "
  48         "endianness = (int) " G_STRINGIFY (G_BYTE_ORDER) ", "
  49         "signed = (boolean) true, "
  50         "width = (int) 16, "
  51         "depth = (int) 16, "
  52         "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, "
  53         "channels = (int) [ 1, 2 ]")
  54     );
  55
  56 static GstStaticPadTemplate gst_lame_src_template =
  57 GST_STATIC_PAD_TEMPLATE ("src",
  58     GST_PAD_SRC,
  59     GST_PAD_ALWAYS,
  60     GST_STATIC_CAPS ("audio/mpeg, "
  61         "mpegversion = (int) 1, "
  62         "layer = (int) 3, "
  63         "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, "
  64         "channels = (int) [ 1, 2 ]")
  65     );
  66
  67 /********** Define useful types for non-programmatic interfaces **********/
  68 #define GST_TYPE_LAME_MODE (gst_lame_mode_get_type())
  69 static GType
  70 gst_lame_mode_get_type (void)
  71 {
  72   static GType lame_mode_type = 0;
  73   static GEnumValue lame_modes[] = {
  74     {0, "0", "Stereo"},
  75     {1, "1", "Joint-Stereo"},
  76     {2, "2", "Dual channel"},
  77     {3, "3", "Mono"},
  78     {4, "4", "Auto"},
  79     {0, NULL, NULL}
  80   };
  81
  82   if (!lame_mode_type) {
  83     lame_mode_type = g_enum_register_static ("GstLameMode", lame_modes);
  84   }
  85   return lame_mode_type;
  86 }
  87
  88 #define GST_TYPE_LAME_QUALITY (gst_lame_quality_get_type())
  89 static GType
  90 gst_lame_quality_get_type (void)
  91 {
  92   static GType lame_quality_type = 0;
  93   static GEnumValue lame_quality[] = {
  94     {0, "0", "0 - Best"},
  95     {1, "1", "1"},
  96     {2, "2", "2"},
  97     {3, "3", "3"},
  98     {4, "4", "4"},
  99     {5, "5", "5 - Default"},
 100     {6, "6", "6"},
 101     {7, "7", "7"},
 102     {8, "8", "8"},
 103     {9, "9", "9 - Worst"},
 104     {0, NULL, NULL}
 105   };
 106
 107   if (!lame_quality_type) {
 108     lame_quality_type = g_enum_register_static ("GstLameQuality", lame_quality);
 109   }
 110   return lame_quality_type;
 111 }
 112
 113 #define GST_TYPE_LAME_PADDING (gst_lame_padding_get_type())
 114 static GType
 115 gst_lame_padding_get_type (void)
 116 {
 117   static GType lame_padding_type = 0;
 118   static GEnumValue lame_padding[] = {
 119     {0, "0", "No Padding"},
 120     {1, "1", "Always Pad"},
 121     {2, "2", "Adjust Padding"},
 122     {0, NULL, NULL}
 123   };
 124
 125   if (!lame_padding_type) {
 126     lame_padding_type = g_enum_register_static ("GstLamePadding", lame_padding);
 127   }
 128   return lame_padding_type;
 129 }
 130
 131 #define GST_TYPE_LAME_VBRMODE (gst_lame_vbrmode_get_type())
 132 static GType
 133 gst_lame_vbrmode_get_type (void)
 134 {
 135   static GType lame_vbrmode_type = 0;
 136   static GEnumValue lame_vbrmode[] = {
 137     {vbr_off, "cbr", "No VBR (Constant Bitrate)"},
 138     {vbr_rh, "old", "Lame's old VBR algorithm"},
 139     {vbr_abr, "abr", "VBR Average Bitrate"},
 140     {vbr_mtrh, "new", "Lame's new VBR algorithm"},
 141     {0, NULL, NULL}
 142   };
 143
 144   if (!lame_vbrmode_type) {
 145     lame_vbrmode_type = g_enum_register_static ("GstLameVbrmode", lame_vbrmode);
 146   }
 147
 148   return lame_vbrmode_type;
 149 }
 150
 151 #ifdef GSTLAME_PRESET
 152 #define GST_TYPE_LAME_PRESET (gst_lame_preset_get_type())
 153 static GType
 154 gst_lame_preset_get_type (void)
 155 {
 156   static GType gst_lame_preset = 0;
 157   static GEnumValue gst_lame_presets[] = {
 158     {0, "none", "None"},
 159     {MEDIUM, "medium", "Medium"},
 160     {STANDARD, "standard", "Standard"},
 161     {EXTREME, "extreme", "Extreme"},
 162     {INSANE, "insane", "Insane"},
 163     {0, NULL, NULL}
 164   };
 165
 166   if (!gst_lame_preset) {
 167     gst_lame_preset =
 168         g_enum_register_static ("GstLamePreset", gst_lame_presets);
 169   }
 170
 171   return gst_lame_preset;
 172 }
 173 #endif
 174
 175 /********** Standard stuff for signals and arguments **********/
 176 /* GstLame signals and args */
 177 enum
 178 {
 179   /* FILL_ME */
 180   LAST_SIGNAL
 181 };
 182
 183 enum
 184 {
 185   ARG_0,
 186   ARG_BITRATE,
 187   ARG_COMPRESSION_RATIO,
 188   ARG_QUALITY,
 189   ARG_MODE,
 190   ARG_FORCE_MS,
 191   ARG_FREE_FORMAT,
 192   ARG_COPYRIGHT,
 193   ARG_ORIGINAL,
 194   ARG_ERROR_PROTECTION,
 195   ARG_PADDING_TYPE,
 196   ARG_EXTENSION,
 197   ARG_STRICT_ISO,
 198   ARG_DISABLE_RESERVOIR,
 199   ARG_VBR,
 200   ARG_VBR_MEAN_BITRATE,
 201   ARG_VBR_MIN_BITRATE,
 202   ARG_VBR_MAX_BITRATE,
 203   ARG_VBR_HARD_MIN,
 204   ARG_LOWPASS_FREQ,
 205   ARG_LOWPASS_WIDTH,
 206   ARG_HIGHPASS_FREQ,
 207   ARG_HIGHPASS_WIDTH,
 208   ARG_ATH_ONLY,
 209   ARG_ATH_SHORT,
 210   ARG_NO_ATH,
 211   ARG_ATH_LOWER,
 212   ARG_CWLIMIT,
 213   ARG_ALLOW_DIFF_SHORT,
 214   ARG_NO_SHORT_BLOCKS,
 215   ARG_EMPHASIS,
 216   ARG_VBR_QUALITY,
 217 #ifdef GSTLAME_PRESET
 218   ARG_XINGHEADER,
 219   ARG_PRESET
 220 #else
 221   ARG_XINGHEADER
 222 #endif
 223 };
 224
 225 static void gst_lame_base_init (gpointer g_class);
 226 static void gst_lame_class_init (GstLameClass * klass);
 227 static void gst_lame_init (GstLame * gst_lame);
 228
 229 static void gst_lame_set_property (GObject * object, guint prop_id,
 230     const GValue * value, GParamSpec * pspec);
 231 static void gst_lame_get_property (GObject * object, guint prop_id,
 232     GValue * value, GParamSpec * pspec);
 233 static void gst_lame_chain (GstPad * pad, GstData * _data);
 234 static gboolean gst_lame_setup (GstLame * lame);
 235 static GstElementStateReturn gst_lame_change_state (GstElement * element);
 236
 237 static GstElementClass *parent_class = NULL;
 238
 239 /* static guint gst_lame_signals[LAST_SIGNAL] = { 0 }; */
 240
 241 GType
 242 gst_lame_get_type (void)
 243 {
 244   static GType gst_lame_type = 0;
 245
 246   if (!gst_lame_type) {
 247     static const GTypeInfo gst_lame_info = {
 248       sizeof (GstLameClass),
 249       gst_lame_base_init,
 250       NULL,
 251       (GClassInitFunc) gst_lame_class_init,
 252       NULL,
 253       NULL,
 254       sizeof (GstLame),
 255       0,
 256       (GInstanceInitFunc) gst_lame_init,
 257     };
 258
 259     static const GInterfaceInfo tag_setter_info = {
 260       NULL,
 261       NULL,
 262       NULL
 263     };
 264
 265     gst_lame_type =
 266         g_type_register_static (GST_TYPE_ELEMENT, "GstLame", &gst_lame_info, 0);
 267     g_type_add_interface_static (gst_lame_type, GST_TYPE_TAG_SETTER,
 268         &tag_setter_info);
 269
 270   }
 271   return gst_lame_type;
 272 }
 273
 274 static void
 275 gst_lame_base_init (gpointer g_class)
 276 {
 277   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 278
 279   gst_element_class_add_pad_template (element_class,
 280       gst_static_pad_template_get (&gst_lame_src_template));
 281   gst_element_class_add_pad_template (element_class,
 282       gst_static_pad_template_get (&gst_lame_sink_template));
 283   gst_element_class_set_details (element_class, &gst_lame_details);
 284 }
 285
 286 static void
 287 gst_lame_class_init (GstLameClass * klass)
 288 {
 289   GObjectClass *gobject_class;
 290   GstElementClass *gstelement_class;
 291
 292   gobject_class = (GObjectClass *) klass;
 293   gstelement_class = (GstElementClass *) klass;
 294
 295   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 296
 297   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BITRATE,
 298       g_param_spec_int ("bitrate", "Bitrate (kb/s)", "Bitrate in kbit/sec",
 299           8, 320, 128, G_PARAM_READWRITE));
 300   /* compression ratio set to 0.0 by default otherwise it overrides the bitrate setting */
 301   g_object_class_install_property (G_OBJECT_CLASS (klass),
 302       ARG_COMPRESSION_RATIO, g_param_spec_float ("compression_ratio",
 303           "Compression Ratio",
 304           "let lame choose bitrate to achieve selected compression ratio", 0.0,
 305           200.0, 0.0, G_PARAM_READWRITE));
 306   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_QUALITY,
 307       g_param_spec_enum ("quality", "Quality",
 308           "Quality of algorithm used for encoding", GST_TYPE_LAME_QUALITY, 5,
 309           G_PARAM_READWRITE));
 310   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MODE,
 311       g_param_spec_enum ("mode", "Mode", "Encoding mode", GST_TYPE_LAME_MODE, 0,
 312           G_PARAM_READWRITE));
 313   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FORCE_MS,
 314       g_param_spec_boolean ("force_ms", "Force ms",
 315           "Force ms_stereo on all frames", TRUE, G_PARAM_READWRITE));
 316   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FREE_FORMAT,
 317       g_param_spec_boolean ("free_format", "Free format",
 318           "Produce a free format bitstream", TRUE, G_PARAM_READWRITE));
 319   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_COPYRIGHT,
 320       g_param_spec_boolean ("copyright", "Copyright", "Mark as copyright", TRUE,
 321           G_PARAM_READWRITE));
 322   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ORIGINAL,
 323       g_param_spec_boolean ("original", "Original", "Mark as non-original",
 324           TRUE, G_PARAM_READWRITE));
 325   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ERROR_PROTECTION,
 326       g_param_spec_boolean ("error_protection", "Error protection",
 327           "Adds 16 bit checksum to every frame", TRUE, G_PARAM_READWRITE));
 328   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PADDING_TYPE,
 329       g_param_spec_enum ("padding_type", "Padding type", "Padding type",
 330           GST_TYPE_LAME_PADDING, 0, G_PARAM_READWRITE));
 331   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EXTENSION,
 332       g_param_spec_boolean ("extension", "Extension", "Extension", TRUE,
 333           G_PARAM_READWRITE));
 334   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_STRICT_ISO,
 335       g_param_spec_boolean ("strict_iso", "Strict ISO",
 336           "Comply as much as possible to ISO MPEG spec", TRUE,
 337           G_PARAM_READWRITE));
 338   g_object_class_install_property (G_OBJECT_CLASS (klass),
 339       ARG_DISABLE_RESERVOIR, g_param_spec_boolean ("disable_reservoir",
 340           "Disable reservoir", "Disable the bit reservoir", TRUE,
 341           G_PARAM_READWRITE));
 342   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR,
 343       g_param_spec_enum ("vbr", "VBR", "Specify bitrate mode",
 344           GST_TYPE_LAME_VBRMODE, vbr_off, G_PARAM_READWRITE));
 345   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_QUALITY,
 346       g_param_spec_enum ("vbr_quality", "VBR Quality", "VBR Quality",
 347           GST_TYPE_LAME_QUALITY, 5, G_PARAM_READWRITE));
 348   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_MEAN_BITRATE,
 349       g_param_spec_int ("vbr_mean_bitrate", "VBR mean bitrate",
 350           "Specify mean bitrate", 0, G_MAXINT, 0, G_PARAM_READWRITE));
 351   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_MIN_BITRATE,
 352       g_param_spec_int ("vbr_min_bitrate", "VBR min bitrate",
 353           "Specify min bitrate", 0, G_MAXINT, 0, G_PARAM_READWRITE));
 354   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_MAX_BITRATE,
 355       g_param_spec_int ("vbr_max_bitrate", "VBR max bitrate",
 356           "Specify max bitrate", 0, G_MAXINT, 0, G_PARAM_READWRITE));
 357   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_HARD_MIN,
 358       g_param_spec_int ("vbr_hard_min", "VBR hard min",
 359           "Specify hard min bitrate", 0, G_MAXINT, 0, G_PARAM_READWRITE));
 360   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOWPASS_FREQ,
 361       g_param_spec_int ("lowpass_freq", "Lowpass freq",
 362           "frequency(kHz), lowpass filter cutoff above freq", 0, 50000, 0,
 363           G_PARAM_READWRITE));
 364   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOWPASS_WIDTH,
 365       g_param_spec_int ("lowpass_width", "Lowpass width",
 366           "frequency(kHz) - default 15% of lowpass freq", 0, G_MAXINT, 0,
 367           G_PARAM_READWRITE));
 368   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_HIGHPASS_FREQ,
 369       g_param_spec_int ("highpass_freq", "Highpass freq",
 370           "frequency(kHz), highpass filter cutoff below freq", 0, 50000, 0,
 371           G_PARAM_READWRITE));
 372   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_HIGHPASS_WIDTH,
 373       g_param_spec_int ("highpass_width", "Highpass width",
 374           "frequency(kHz) - default 15% of highpass freq", 0, G_MAXINT, 0,
 375           G_PARAM_READWRITE));
 376   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ATH_ONLY,
 377       g_param_spec_boolean ("ath_only", "ATH only",
 378           "Ignore GPSYCHO completely, use ATH only", TRUE, G_PARAM_READWRITE));
 379   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ATH_SHORT,
 380       g_param_spec_boolean ("ath_short", "ATH short",
 381           "Ignore GPSYCHO for short blocks, use ATH only", TRUE,
 382           G_PARAM_READWRITE));
 383   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NO_ATH,
 384       g_param_spec_boolean ("no_ath", "No ath",
 385           "turns ATH down to a flat noise floor", TRUE, G_PARAM_READWRITE));
 386   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ATH_LOWER,
 387       g_param_spec_int ("ath_lower", "ATH lower", "lowers ATH by x dB",
 388           G_MININT, G_MAXINT, 0, G_PARAM_READWRITE));
 389   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_CWLIMIT,
 390       g_param_spec_int ("cwlimit", "Cwlimit",
 391           "Compute tonality up to freq (in kHz) default 8.8717", 0, 50000, 0,
 392           G_PARAM_READWRITE));
 393   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ALLOW_DIFF_SHORT,
 394       g_param_spec_boolean ("allow_diff_short", "Allow diff short",
 395           "Allow diff short", TRUE, G_PARAM_READWRITE));
 396   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NO_SHORT_BLOCKS,
 397       g_param_spec_boolean ("no_short_blocks", "No short blocks",
 398           "Do not use short blocks", TRUE, G_PARAM_READWRITE));
 399   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EMPHASIS,
 400       g_param_spec_boolean ("emphasis", "Emphasis", "Emphasis", TRUE,
 401           G_PARAM_READWRITE));
 402   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_XINGHEADER,
 403       g_param_spec_boolean ("xingheader", "Output Xing Header",
 404           "Output Xing Header", FALSE, G_PARAM_READWRITE));
 405 #ifdef GSTLAME_PRESET
 406   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PRESET,
 407       g_param_spec_enum ("preset", "Lame Preset", "Lame Preset",
 408           GST_TYPE_LAME_PRESET, 0, G_PARAM_READWRITE));
 409 #endif
 410   gobject_class->set_property = gst_lame_set_property;
 411   gobject_class->get_property = gst_lame_get_property;
 412
 413   gstelement_class->change_state = gst_lame_change_state;
 414 }
 415
 416 static GstCaps *
 417 gst_lame_src_getcaps (GstPad * pad)
 418 {
 419   GstLame *lame;
 420   GstCaps *caps;
 421
 422   lame = GST_LAME (gst_pad_get_parent (pad));
 423
 424   if (!gst_lame_setup (lame)) {
 425     GST_DEBUG_OBJECT (lame, "problem doing lame setup");
 426     return
 427         gst_caps_copy (gst_pad_template_get_caps (gst_static_pad_template_get
 428             (&gst_lame_src_template)));
 429   }
 430
 431   caps = gst_caps_new_simple ("audio/mpeg",
 432       "mpegversion", G_TYPE_INT, 1,
 433       "layer", G_TYPE_INT, 3,
 434       "rate", G_TYPE_INT, lame_get_out_samplerate (lame->lgf),
 435       "channels", G_TYPE_INT, lame->num_channels, NULL);
 436
 437   return caps;
 438 }
 439
 440 static GstPadLinkReturn
 441 gst_lame_src_link (GstPad * pad, const GstCaps * caps)
 442 {
 443   GstLame *lame;
 444   gint out_samplerate;
 445   GstStructure *structure;
 446   GstCaps *othercaps, *channelcaps;
 447   GstPadLinkReturn result;
 448
 449   lame = GST_LAME (gst_pad_get_parent (pad));
 450   structure = gst_caps_get_structure (caps, 0);
 451
 452   if (!gst_structure_get_int (structure, "rate", &out_samplerate) ||
 453       !gst_structure_get_int (structure, "channels", &lame->num_channels))
 454     g_return_val_if_reached (GST_PAD_LINK_REFUSED);
 455
 456   if (lame_set_out_samplerate (lame->lgf, out_samplerate) != 0)
 457     return GST_PAD_LINK_REFUSED;
 458
 459   /* we don't do channel conversion */
 460   channelcaps = gst_caps_new_simple ("audio/x-raw-int", "channels", G_TYPE_INT,
 461       lame->num_channels, NULL);
 462   othercaps = gst_caps_intersect (gst_pad_get_pad_template_caps (lame->sinkpad),
 463       channelcaps);
 464   gst_caps_free (channelcaps);
 465
 466   result = gst_pad_try_set_caps_nonfixed (lame->sinkpad, othercaps);
 467
 468   if (GST_PAD_LINK_FAILED (result))
 469     return result;
 470
 471   caps = gst_pad_get_negotiated_caps (lame->sinkpad);
 472   structure = gst_caps_get_structure (caps, 0);
 473   if (!gst_structure_get_int (structure, "rate", &lame->samplerate))
 474     g_return_val_if_reached (GST_PAD_LINK_REFUSED);
 475
 476   if (!gst_lame_setup (lame)) {
 477     GST_ELEMENT_ERROR (lame, CORE, NEGOTIATION, (NULL),
 478         ("could not initialize encoder (wrong parameters?)"));
 479     return GST_PAD_LINK_REFUSED;
 480   }
 481
 482   return result;
 483 }
 484
 485 static GstPadLinkReturn
 486 gst_lame_sink_link (GstPad * pad, const GstCaps * caps)
 487 {
 488   GstLame *lame;
 489   gint out_samplerate;
 490   GstStructure *structure;
 491   GstCaps *othercaps;
 492
 493   lame = GST_LAME (gst_pad_get_parent (pad));
 494   structure = gst_caps_get_structure (caps, 0);
 495
 496   if (!gst_structure_get_int (structure, "rate", &lame->samplerate) ||
 497       !gst_structure_get_int (structure, "channels", &lame->num_channels))
 498     g_return_val_if_reached (GST_PAD_LINK_REFUSED);
 499
 500   lame_set_out_samplerate (lame->lgf, 0);
 501   if (!gst_lame_setup (lame)) {
 502     GST_ELEMENT_ERROR (lame, CORE, NEGOTIATION, (NULL),
 503         ("could not initialize encoder (wrong parameters?)"));
 504     return GST_PAD_LINK_REFUSED;
 505   }
 506
 507   out_samplerate = lame_get_out_samplerate (lame->lgf);
 508   othercaps =
 509       gst_caps_new_simple ("audio/mpeg",
 510       "mpegversion", G_TYPE_INT, 1,
 511       "layer", G_TYPE_INT, 3,
 512       "channels", G_TYPE_INT, lame->num_channels,
 513       "rate", G_TYPE_INT, out_samplerate, NULL);
 514
 515   return gst_pad_try_set_caps (lame->srcpad, othercaps);
 516 }
 517
 518 static void
 519 gst_lame_init (GstLame * lame)
 520 {
 521   GST_DEBUG_OBJECT (lame, "starting initialization");
 522
 523   lame->sinkpad =
 524       gst_pad_new_from_template (gst_static_pad_template_get
 525       (&gst_lame_sink_template), "sink");
 526   gst_element_add_pad (GST_ELEMENT (lame), lame->sinkpad);
 527   gst_pad_set_chain_function (lame->sinkpad, gst_lame_chain);
 528   gst_pad_set_link_function (lame->sinkpad, gst_lame_sink_link);
 529
 530   lame->srcpad =
 531       gst_pad_new_from_template (gst_static_pad_template_get
 532       (&gst_lame_src_template), "src");
 533   gst_element_add_pad (GST_ELEMENT (lame), lame->srcpad);
 534   gst_pad_set_link_function (lame->srcpad, gst_lame_src_link);
 535   gst_pad_set_getcaps_function (lame->srcpad, gst_lame_src_getcaps);
 536   GST_FLAG_SET (lame, GST_ELEMENT_EVENT_AWARE);
 537
 538   GST_DEBUG ("setting up lame encoder");
 539   lame->lgf = lame_init ();
 540
 541   lame->samplerate = 44100;
 542   lame->num_channels = 2;
 543   lame->initialized = FALSE;
 544
 545   lame->bitrate = 128;          /* lame_get_brate (lame->lgf); => 0/out of range */
 546   lame->compression_ratio = 0.0;        /* lame_get_compression_ratio (lame->lgf); => 0/out of range ... NOTE: 0.0 makes bitrate take precedence */
 547   lame->quality = 5;            /* lame_get_quality (lame->lgf); => -1/out of range */
 548   lame->mode = lame_get_mode (lame->lgf);
 549   lame->force_ms = lame_get_force_ms (lame->lgf);
 550   lame->free_format = lame_get_free_format (lame->lgf);
 551   lame->copyright = lame_get_copyright (lame->lgf);
 552   lame->original = lame_get_original (lame->lgf);
 553   lame->error_protection = lame_get_error_protection (lame->lgf);
 554   lame->padding_type = lame_get_padding_type (lame->lgf);
 555   lame->extension = lame_get_extension (lame->lgf);
 556   lame->strict_iso = lame_get_strict_ISO (lame->lgf);
 557   lame->disable_reservoir = lame_get_disable_reservoir (lame->lgf);
 558   lame->vbr = vbr_off;          /* lame_get_VBR (lame->lgf); */
 559   lame->vbr_quality = 5;
 560   lame->vbr_mean_bitrate = lame_get_VBR_mean_bitrate_kbps (lame->lgf);
 561   lame->vbr_min_bitrate = lame_get_VBR_min_bitrate_kbps (lame->lgf);
 562   lame->vbr_max_bitrate = 320;  /* lame_get_VBR_max_bitrate_kbps (lame->lgf); => 0/no vbr possible */
 563   lame->vbr_hard_min = lame_get_VBR_hard_min (lame->lgf);
 564   //lame->lowpass_freq = 50000;   /* lame_get_lowpassfreq (lame->lgf); => 0/lowpass on everything ? */
 565   lame->lowpass_freq = 0;
 566   lame->lowpass_width = 0;      /* lame_get_lowpasswidth (lame->lgf); => -1/out of range */
 567   lame->highpass_freq = lame_get_highpassfreq (lame->lgf);
 568   lame->highpass_width = 0;     /* lame_get_highpasswidth (lame->lgf); => -1/out of range */
 569   lame->ath_only = lame_get_ATHonly (lame->lgf);
 570   lame->ath_short = lame_get_ATHshort (lame->lgf);
 571   lame->no_ath = lame_get_noATH (lame->lgf);
 572   /*  lame->ath_type = lame_get_ATHtype (lame->lgf); */
 573   lame->ath_lower = lame_get_ATHlower (lame->lgf);
 574   lame->cwlimit = 8.8717;       /* lame_get_cwlimit (lame->lgf); => 0 */
 575   lame->allow_diff_short = lame_get_allow_diff_short (lame->lgf);
 576   lame->no_short_blocks = TRUE; /* lame_get_no_short_blocks (lame->lgf); */
 577   lame->emphasis = lame_get_emphasis (lame->lgf);
 578   lame->xingheader = FALSE;
 579   lame->preset = 0;
 580   lame->tags = gst_tag_list_new ();
 581
 582   id3tag_init (lame->lgf);
 583
 584   lame->newmediacount = 0;
 585   GST_DEBUG_OBJECT (lame, "done initializing");
 586 }
 587
 588 typedef struct _GstLameTagMatch GstLameTagMatch;
 589 typedef void (*GstLameTagFunc) (lame_global_flags * gfp, const char *value);
 590
 591 struct _GstLameTagMatch
 592 {
 593   gchar *gstreamer_tag;
 594   GstLameTagFunc tag_func;
 595 };
 596
 597 static GstLameTagMatch tag_matches[] = {
 598   {GST_TAG_TITLE, id3tag_set_title},
 599   {GST_TAG_DATE, id3tag_set_year},
 600   {GST_TAG_TRACK_NUMBER, id3tag_set_track},
 601   {GST_TAG_COMMENT, id3tag_set_comment},
 602   {GST_TAG_ARTIST, id3tag_set_artist},
 603   {GST_TAG_ALBUM, id3tag_set_album},
 604   {GST_TAG_GENRE, (GstLameTagFunc) id3tag_set_genre},
 605   {NULL, NULL}
 606 };
 607
 608 static void
 609 add_one_tag (const GstTagList * list, const gchar * tag, gpointer user_data)
 610 {
 611   GstLame *lame;
 612   gchar *value;
 613   int i = 0;
 614
 615   lame = GST_LAME (user_data);
 616   g_return_if_fail (lame != NULL);
 617
 618   while (tag_matches[i].gstreamer_tag != NULL) {
 619     if (strcmp (tag, tag_matches[i].gstreamer_tag) == 0) {
 620       break;
 621     }
 622     i++;
 623   }
 624
 625   if (tag_matches[i].tag_func == NULL) {
 626     g_print ("Couldn't find matching gstreamer tag for %s\n", tag);
 627     return;
 628   }
 629
 630   switch (gst_tag_get_type (tag)) {
 631     case G_TYPE_UINT:{
 632       guint ivalue;
 633
 634       if (!gst_tag_list_get_uint (list, tag, &ivalue)) {
 635         GST_DEBUG ("Error reading \"%s\" tag value\n", tag);
 636         return;
 637       }
 638       value = g_strdup_printf ("%u", ivalue);
 639       break;
 640     }
 641     case G_TYPE_STRING:
 642       if (!gst_tag_list_get_string (list, tag, &value)) {
 643         GST_DEBUG ("Error reading \"%s\" tag value\n", tag);
 644         return;
 645       };
 646       break;
 647     default:
 648       GST_DEBUG ("Couldn't write tag %s", tag);
 649       break;
 650   }
 651
 652   tag_matches[i].tag_func (lame->lgf, value);
 653
 654   if (gst_tag_get_type (tag) == G_TYPE_UINT) {
 655     g_free (value);
 656   }
 657 }
 658
 659 static void
 660 gst_lame_set_metadata (GstLame * lame)
 661 {
 662   const GstTagList *user_tags;
 663   GstTagList *copy;
 664
 665   g_return_if_fail (lame != NULL);
 666   user_tags = gst_tag_setter_get_list (GST_TAG_SETTER (lame));
 667   if ((lame->tags == NULL) && (user_tags == NULL)) {
 668     return;
 669   }
 670   copy = gst_tag_list_merge (user_tags, lame->tags,
 671       gst_tag_setter_get_merge_mode (GST_TAG_SETTER (lame)));
 672   gst_tag_list_foreach ((GstTagList *) copy, add_one_tag, lame);
 673
 674   gst_tag_list_free (copy);
 675 }
 676
 677
 678
 679 static void
 680 gst_lame_set_property (GObject * object, guint prop_id, const GValue * value,
 681     GParamSpec * pspec)
 682 {
 683   GstLame *lame;
 684
 685   /* it's not null if we got it, but it might not be ours */
 686   g_return_if_fail (GST_IS_LAME (object));
 687
 688   lame = GST_LAME (object);
 689
 690   switch (prop_id) {
 691     case ARG_BITRATE:
 692       lame->bitrate = g_value_get_int (value);
 693       break;
 694     case ARG_COMPRESSION_RATIO:
 695       lame->compression_ratio = g_value_get_float (value);
 696       break;
 697     case ARG_QUALITY:
 698       lame->quality = g_value_get_enum (value);
 699       break;
 700     case ARG_MODE:
 701       lame->mode = g_value_get_enum (value);
 702       break;
 703     case ARG_FORCE_MS:
 704       lame->force_ms = g_value_get_boolean (value);
 705       break;
 706     case ARG_FREE_FORMAT:
 707       lame->free_format = g_value_get_boolean (value);
 708       break;
 709     case ARG_COPYRIGHT:
 710       lame->copyright = g_value_get_boolean (value);
 711       break;
 712     case ARG_ORIGINAL:
 713       lame->original = g_value_get_boolean (value);
 714       break;
 715     case ARG_ERROR_PROTECTION:
 716       lame->error_protection = g_value_get_boolean (value);
 717       break;
 718     case ARG_PADDING_TYPE:
 719       lame->padding_type = g_value_get_int (value);
 720       break;
 721     case ARG_EXTENSION:
 722       lame->extension = g_value_get_boolean (value);
 723       break;
 724     case ARG_STRICT_ISO:
 725       lame->strict_iso = g_value_get_boolean (value);
 726       break;
 727     case ARG_DISABLE_RESERVOIR:
 728       lame->disable_reservoir = g_value_get_boolean (value);
 729       break;
 730     case ARG_VBR:
 731       lame->vbr = g_value_get_enum (value);
 732       break;
 733     case ARG_VBR_QUALITY:
 734       lame->vbr_quality = g_value_get_enum (value);
 735       break;
 736     case ARG_VBR_MEAN_BITRATE:
 737       lame->vbr_mean_bitrate = g_value_get_int (value);
 738       break;
 739     case ARG_VBR_MIN_BITRATE:
 740       lame->vbr_min_bitrate = g_value_get_int (value);
 741       break;
 742     case ARG_VBR_MAX_BITRATE:
 743       lame->vbr_max_bitrate = g_value_get_int (value);
 744       break;
 745     case ARG_VBR_HARD_MIN:
 746       lame->vbr_hard_min = g_value_get_int (value);
 747       break;
 748     case ARG_LOWPASS_FREQ:
 749       lame->lowpass_freq = g_value_get_int (value);
 750       break;
 751     case ARG_LOWPASS_WIDTH:
 752       lame->lowpass_width = g_value_get_int (value);
 753       break;
 754     case ARG_HIGHPASS_FREQ:
 755       lame->highpass_freq = g_value_get_int (value);
 756       break;
 757     case ARG_HIGHPASS_WIDTH:
 758       lame->highpass_width = g_value_get_int (value);
 759       break;
 760     case ARG_ATH_ONLY:
 761       lame->ath_only = g_value_get_boolean (value);
 762       break;
 763     case ARG_ATH_SHORT:
 764       lame->ath_short = g_value_get_boolean (value);
 765       break;
 766     case ARG_NO_ATH:
 767       lame->no_ath = g_value_get_boolean (value);
 768       break;
 769     case ARG_ATH_LOWER:
 770       lame->ath_lower = g_value_get_int (value);
 771       break;
 772     case ARG_CWLIMIT:
 773       lame->cwlimit = g_value_get_int (value);
 774       break;
 775     case ARG_ALLOW_DIFF_SHORT:
 776       lame->allow_diff_short = g_value_get_boolean (value);
 777       break;
 778     case ARG_NO_SHORT_BLOCKS:
 779       lame->no_short_blocks = g_value_get_boolean (value);
 780       break;
 781     case ARG_EMPHASIS:
 782       lame->emphasis = g_value_get_boolean (value);
 783       break;
 784     case ARG_XINGHEADER:
 785       lame->xingheader = g_value_get_boolean (value);
 786       break;
 787 #ifdef GSTLAME_PRESET
 788     case ARG_PRESET:
 789       lame->preset = g_value_get_enum (value);
 790       break;
 791 #endif
 792     default:
 793       break;
 794   }
 795
 796 }
 797
 798 static void
 799 gst_lame_get_property (GObject * object, guint prop_id, GValue * value,
 800     GParamSpec * pspec)
 801 {
 802   GstLame *lame;
 803
 804   /* it's not null if we got it, but it might not be ours */
 805   g_return_if_fail (GST_IS_LAME (object));
 806
 807   lame = GST_LAME (object);
 808
 809   switch (prop_id) {
 810     case ARG_BITRATE:
 811       g_value_set_int (value, lame->bitrate);
 812       break;
 813     case ARG_COMPRESSION_RATIO:
 814       g_value_set_float (value, lame->compression_ratio);
 815       break;
 816     case ARG_QUALITY:
 817       g_value_set_enum (value, lame->quality);
 818       break;
 819     case ARG_MODE:
 820       g_value_set_enum (value, lame->mode);
 821       break;
 822     case ARG_FORCE_MS:
 823       g_value_set_boolean (value, lame->force_ms);
 824       break;
 825     case ARG_FREE_FORMAT:
 826       g_value_set_boolean (value, lame->free_format);
 827       break;
 828     case ARG_COPYRIGHT:
 829       g_value_set_boolean (value, lame->copyright);
 830       break;
 831     case ARG_ORIGINAL:
 832       g_value_set_boolean (value, lame->original);
 833       break;
 834     case ARG_ERROR_PROTECTION:
 835       g_value_set_boolean (value, lame->error_protection);
 836       break;
 837     case ARG_PADDING_TYPE:
 838       g_value_set_enum (value, lame->padding_type);
 839       break;
 840     case ARG_EXTENSION:
 841       g_value_set_boolean (value, lame->extension);
 842       break;
 843     case ARG_STRICT_ISO:
 844       g_value_set_boolean (value, lame->strict_iso);
 845       break;
 846     case ARG_DISABLE_RESERVOIR:
 847       g_value_set_boolean (value, lame->disable_reservoir);
 848       break;
 849     case ARG_VBR:
 850       g_value_set_enum (value, lame->vbr);
 851       break;
 852     case ARG_VBR_QUALITY:
 853       g_value_set_enum (value, lame->vbr_quality);
 854       break;
 855     case ARG_VBR_MEAN_BITRATE:
 856       g_value_set_int (value, lame->vbr_mean_bitrate);
 857       break;
 858     case ARG_VBR_MIN_BITRATE:
 859       g_value_set_int (value, lame->vbr_min_bitrate);
 860       break;
 861     case ARG_VBR_MAX_BITRATE:
 862       g_value_set_int (value, lame->vbr_max_bitrate);
 863       break;
 864     case ARG_VBR_HARD_MIN:
 865       g_value_set_int (value, lame->vbr_hard_min);
 866       break;
 867     case ARG_LOWPASS_FREQ:
 868       g_value_set_int (value, lame->lowpass_freq);
 869       break;
 870     case ARG_LOWPASS_WIDTH:
 871       g_value_set_int (value, lame->lowpass_width);
 872       break;
 873     case ARG_HIGHPASS_FREQ:
 874       g_value_set_int (value, lame->highpass_freq);
 875       break;
 876     case ARG_HIGHPASS_WIDTH:
 877       g_value_set_int (value, lame->highpass_width);
 878       break;
 879     case ARG_ATH_ONLY:
 880       g_value_set_boolean (value, lame->ath_only);
 881       break;
 882     case ARG_ATH_SHORT:
 883       g_value_set_boolean (value, lame->ath_short);
 884       break;
 885     case ARG_NO_ATH:
 886       g_value_set_boolean (value, lame->no_ath);
 887       break;
 888     case ARG_ATH_LOWER:
 889       g_value_set_int (value, lame->ath_lower);
 890       break;
 891     case ARG_CWLIMIT:
 892       g_value_set_int (value, lame->cwlimit);
 893       break;
 894     case ARG_ALLOW_DIFF_SHORT:
 895       g_value_set_boolean (value, lame->allow_diff_short);
 896       break;
 897     case ARG_NO_SHORT_BLOCKS:
 898       g_value_set_boolean (value, lame->no_short_blocks);
 899       break;
 900     case ARG_EMPHASIS:
 901       g_value_set_boolean (value, lame->emphasis);
 902       break;
 903     case ARG_XINGHEADER:
 904       g_value_set_boolean (value, lame->xingheader);
 905       break;
 906 #ifdef GSTLAME_PRESET
 907     case ARG_PRESET:
 908       g_value_set_enum (value, lame->preset);
 909       break;
 910 #endif
 911     default:
 912       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 913       break;
 914   }
 915 }
 916
 917 static void
 918 gst_lame_chain (GstPad * pad, GstData * _data)
 919 {
 920   GstBuffer *buf = GST_BUFFER (_data);
 921   GstLame *lame;
 922   GstBuffer *outbuf;
 923   gchar *mp3_data = NULL;
 924   gint mp3_buffer_size, mp3_size = 0;
 925   gboolean eos = FALSE;
 926
 927   lame = GST_LAME (gst_pad_get_parent (pad));
 928
 929   GST_LOG_OBJECT (lame, "entered chain");
 930
 931   if (GST_IS_EVENT (buf)) {
 932     switch (GST_EVENT_TYPE (buf)) {
 933       case GST_EVENT_EOS:
 934         GST_DEBUG_OBJECT (lame, "handling EOS event");
 935         eos = TRUE;
 936       case GST_EVENT_FLUSH:
 937         GST_DEBUG_OBJECT (lame, "handling FLUSH event");
 938         mp3_buffer_size = 7200;
 939         mp3_data = g_malloc (mp3_buffer_size);
 940
 941         mp3_size = lame_encode_flush (lame->lgf, mp3_data, mp3_buffer_size);
 942         gst_event_unref (GST_EVENT (buf));
 943         break;
 944       case GST_EVENT_TAG:
 945         GST_DEBUG_OBJECT (lame, "handling TAG event");
 946         if (lame->tags) {
 947           gst_tag_list_insert (lame->tags,
 948               gst_event_tag_get_list (GST_EVENT (buf)),
 949               gst_tag_setter_get_merge_mode (GST_TAG_SETTER (lame)));
 950         } else {
 951           g_assert_not_reached ();
 952         }
 953         gst_pad_event_default (pad, GST_EVENT (buf));
 954         break;
 955       case GST_EVENT_DISCONTINUOUS:
 956         if (GST_EVENT_DISCONT_NEW_MEDIA (GST_EVENT (buf))) {
 957           /* do not re-initialise if it is first new media discont */
 958           if (lame->newmediacount++ > 0) {
 959             lame_close (lame->lgf);
 960             lame->lgf = lame_init ();
 961             lame->initialized = FALSE;
 962             lame->last_ts = GST_CLOCK_TIME_NONE;
 963
 964             gst_lame_setup (lame);
 965           }
 966         }
 967         gst_pad_event_default (pad, GST_EVENT (buf));
 968
 969         break;
 970       default:
 971         gst_pad_event_default (pad, GST_EVENT (buf));
 972         break;
 973     }
 974   } else {
 975     gint64 duration;
 976
 977     if (!lame->initialized) {
 978       gst_buffer_unref (buf);
 979       GST_ELEMENT_ERROR (lame, CORE, NEGOTIATION, (NULL),
 980           ("encoder not initialized (input is not audio?)"));
 981       return;
 982     }
 983
 984     /* allocate space for output */
 985     mp3_buffer_size =
 986         ((GST_BUFFER_SIZE (buf) / (2 + lame->num_channels)) * 1.25) + 7200;
 987     mp3_data = g_malloc (mp3_buffer_size);
 988
 989     /* lame seems to be too stupid to get mono interleaved going */
 990     if (lame->num_channels == 1) {
 991       mp3_size = lame_encode_buffer (lame->lgf,
 992           (short int *) (GST_BUFFER_DATA (buf)),
 993           (short int *) (GST_BUFFER_DATA (buf)),
 994           GST_BUFFER_SIZE (buf) / 2, mp3_data, mp3_buffer_size);
 995     } else {
 996       mp3_size = lame_encode_buffer_interleaved (lame->lgf,
 997           (short int *) (GST_BUFFER_DATA (buf)),
 998           GST_BUFFER_SIZE (buf) / 2 / lame->num_channels,
 999           mp3_data, mp3_buffer_size);
1000     }
1001
1002     GST_LOG_OBJECT (lame, "encoded %d bytes of audio to %d bytes of mp3",
1003         GST_BUFFER_SIZE (buf), mp3_size);
1004
1005     duration = (GST_SECOND * GST_BUFFER_SIZE (buf) /
1006         (2 * lame->samplerate * lame->num_channels));
1007
1008     if (GST_BUFFER_DURATION (buf) != GST_CLOCK_TIME_NONE &&
1009         GST_BUFFER_DURATION (buf) != duration)
1010       GST_DEBUG_OBJECT (lame, "incoming buffer had incorrect duration "
1011           GST_TIME_FORMAT "outgoing buffer will have correct duration "
1012           GST_TIME_FORMAT,
1013           GST_TIME_ARGS (GST_BUFFER_DURATION (buf)), GST_TIME_ARGS (duration));
1014
1015     if (lame->last_ts == GST_CLOCK_TIME_NONE) {
1016       lame->last_ts = GST_BUFFER_TIMESTAMP (buf);
1017       lame->last_offs = GST_BUFFER_OFFSET (buf);
1018       lame->last_duration = duration;
1019     } else {
1020       lame->last_duration += duration;
1021     }
1022
1023     gst_buffer_unref (buf);
1024   }
1025
1026   if (mp3_size > 0) {
1027     outbuf = gst_buffer_new ();
1028     GST_BUFFER_DATA (outbuf) = mp3_data;
1029     GST_BUFFER_SIZE (outbuf) = mp3_size;
1030     GST_BUFFER_TIMESTAMP (outbuf) = lame->last_ts;
1031     GST_BUFFER_OFFSET (outbuf) = lame->last_offs;
1032     GST_BUFFER_DURATION (outbuf) = lame->last_duration;
1033
1034     gst_pad_push (lame->srcpad, GST_DATA (outbuf));
1035
1036     lame->last_ts = GST_CLOCK_TIME_NONE;
1037   } else {
1038     g_free (mp3_data);
1039   }
1040
1041   if (eos) {
1042     gst_pad_push (lame->srcpad, GST_DATA (gst_event_new (GST_EVENT_EOS)));
1043     gst_element_set_eos (GST_ELEMENT (lame));
1044   }
1045 }
1046
1047 /* transition to the READY state by configuring the gst_lame encoder */
1048 static gboolean
1049 gst_lame_setup (GstLame * lame)
1050 {
1051 #define CHECK_ERROR(command) G_STMT_START {\
1052   if ((command) < 0) { \
1053     GST_ERROR_OBJECT (lame, "setup failed: " G_STRINGIFY (command)); \
1054     return FALSE; \
1055   } \
1056 }G_STMT_END
1057   int retval;
1058
1059   GST_DEBUG_OBJECT (lame, "starting setup");
1060
1061   /* check if we're already initialized; if we are, we might want to check
1062    * if this initialization is compatible with the previous one */
1063   /* FIXME: do this */
1064   if (lame->initialized) {
1065     GST_WARNING_OBJECT (lame, "already initialized");
1066     lame->initialized = FALSE;
1067   }
1068
1069   /* copy the parameters over */
1070   lame_set_in_samplerate (lame->lgf, lame->samplerate);
1071
1072   /* force mono encoding if we only have one channel */
1073   if (lame->num_channels == 1)
1074     lame->mode = 3;
1075
1076   CHECK_ERROR (lame_set_num_channels (lame->lgf, lame->num_channels));
1077   CHECK_ERROR (lame_set_brate (lame->lgf, lame->bitrate));
1078   CHECK_ERROR (lame_set_compression_ratio (lame->lgf, lame->compression_ratio));
1079   CHECK_ERROR (lame_set_quality (lame->lgf, lame->quality));
1080   CHECK_ERROR (lame_set_mode (lame->lgf, lame->mode));
1081   CHECK_ERROR (lame_set_force_ms (lame->lgf, lame->force_ms));
1082   CHECK_ERROR (lame_set_free_format (lame->lgf, lame->free_format));
1083   CHECK_ERROR (lame_set_copyright (lame->lgf, lame->copyright));
1084   CHECK_ERROR (lame_set_original (lame->lgf, lame->original));
1085   CHECK_ERROR (lame_set_error_protection (lame->lgf, lame->error_protection));
1086   CHECK_ERROR (lame_set_padding_type (lame->lgf, lame->padding_type));
1087   CHECK_ERROR (lame_set_extension (lame->lgf, lame->extension));
1088   CHECK_ERROR (lame_set_strict_ISO (lame->lgf, lame->strict_iso));
1089   CHECK_ERROR (lame_set_disable_reservoir (lame->lgf, lame->disable_reservoir));
1090   CHECK_ERROR (lame_set_VBR (lame->lgf, lame->vbr));
1091   CHECK_ERROR (lame_set_VBR_q (lame->lgf, lame->vbr_quality));
1092   CHECK_ERROR (lame_set_VBR_mean_bitrate_kbps (lame->lgf,
1093           lame->vbr_mean_bitrate));
1094   CHECK_ERROR (lame_set_VBR_min_bitrate_kbps (lame->lgf,
1095           lame->vbr_min_bitrate));
1096   CHECK_ERROR (lame_set_VBR_max_bitrate_kbps (lame->lgf,
1097           lame->vbr_max_bitrate));
1098   CHECK_ERROR (lame_set_VBR_hard_min (lame->lgf, lame->vbr_hard_min));
1099   CHECK_ERROR (lame_set_lowpassfreq (lame->lgf, lame->lowpass_freq));
1100   CHECK_ERROR (lame_set_lowpasswidth (lame->lgf, lame->lowpass_width));
1101   CHECK_ERROR (lame_set_highpassfreq (lame->lgf, lame->highpass_freq));
1102   CHECK_ERROR (lame_set_highpasswidth (lame->lgf, lame->highpass_width));
1103   CHECK_ERROR (lame_set_ATHonly (lame->lgf, lame->ath_only));
1104   CHECK_ERROR (lame_set_ATHshort (lame->lgf, lame->ath_short));
1105   CHECK_ERROR (lame_set_noATH (lame->lgf, lame->no_ath));
1106   CHECK_ERROR (lame_set_ATHlower (lame->lgf, lame->ath_lower));
1107   CHECK_ERROR (lame_set_cwlimit (lame->lgf, lame->cwlimit));
1108   CHECK_ERROR (lame_set_allow_diff_short (lame->lgf, lame->allow_diff_short));
1109   CHECK_ERROR (lame_set_no_short_blocks (lame->lgf, lame->no_short_blocks));
1110   CHECK_ERROR (lame_set_emphasis (lame->lgf, lame->emphasis));
1111   CHECK_ERROR (lame_set_bWriteVbrTag (lame->lgf, lame->xingheader ? 1 : 0));
1112 #ifdef GSTLAME_PRESET
1113   if (lame->preset > 0) {
1114     CHECK_ERROR (lame_set_preset (lame->lgf, lame->preset));
1115   }
1116 #endif
1117   gst_lame_set_metadata (lame);
1118
1119   /* initialize the lame encoder */
1120   if ((retval = lame_init_params (lame->lgf)) >= 0) {
1121     lame->initialized = TRUE;
1122     /* FIXME: it would be nice to print out the mode here */
1123     GST_INFO ("lame encoder initialized (%d kbit/s, %d Hz, %d channels)",
1124         lame->bitrate, lame->samplerate, lame->num_channels);
1125   } else {
1126     GST_ERROR_OBJECT (lame, "lame_init_params returned %d", retval);
1127   }
1128
1129   GST_DEBUG_OBJECT (lame, "done with setup");
1130
1131   return lame->initialized;
1132 #undef CHECK_ERROR
1133 }
1134
1135 static GstElementStateReturn
1136 gst_lame_change_state (GstElement * element)
1137 {
1138   GstLame *lame;
1139
1140   g_return_val_if_fail (GST_IS_LAME (element), GST_STATE_FAILURE);
1141
1142   lame = GST_LAME (element);
1143
1144   GST_DEBUG ("state pending %d", GST_STATE_PENDING (element));
1145
1146   switch (GST_STATE_TRANSITION (element)) {
1147     case GST_STATE_READY_TO_PAUSED:
1148       lame->last_ts = GST_CLOCK_TIME_NONE;
1149       break;
1150     case GST_STATE_READY_TO_NULL:
1151       if (lame->initialized) {
1152         lame_close (lame->lgf);
1153         lame->lgf = lame_init ();
1154         lame->initialized = FALSE;
1155       }
1156       break;
1157     default:
1158       break;
1159   }
1160
1161   /* if we haven't failed already, give the parent class a chance to ;-) */
1162   if (GST_ELEMENT_CLASS (parent_class)->change_state)
1163     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
1164
1165   return GST_STATE_SUCCESS;
1166 }
1167
1168 static gboolean
1169 plugin_init (GstPlugin * plugin)
1170 {
1171   if (!gst_element_register (plugin, "lame", GST_RANK_NONE, GST_TYPE_LAME))
1172     return FALSE;
1173
1174   GST_DEBUG_CATEGORY_INIT (debug, "lame", 0, "lame mp3 encoder");
1175   return TRUE;
1176 }
1177
1178 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1179     GST_VERSION_MINOR,
1180     "lame",
1181     "Encode MP3's with LAME",
1182     plugin_init, VERSION, "LGPL", GST_PACKAGE, GST_ORIGIN)