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