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   GST_DEBUG_OBJECT (lame, "done initializing");
 585 }
 586
 587 typedef struct _GstLameTagMatch GstLameTagMatch;
 588 typedef void (*GstLameTagFunc) (lame_global_flags * gfp, const char *value);
 589
 590 struct _GstLameTagMatch
 591 {
 592   gchar *gstreamer_tag;
 593   GstLameTagFunc tag_func;
 594 };
 595
 596 static GstLameTagMatch tag_matches[] = {
 597   {GST_TAG_TITLE, id3tag_set_title},
 598   {GST_TAG_DATE, id3tag_set_year},
 599   {GST_TAG_TRACK_NUMBER, id3tag_set_track},
 600   {GST_TAG_COMMENT, id3tag_set_comment},
 601   {GST_TAG_ARTIST, id3tag_set_artist},
 602   {GST_TAG_ALBUM, id3tag_set_album},
 603   {GST_TAG_GENRE, (GstLameTagFunc) id3tag_set_genre},
 604   {NULL, NULL}
 605 };
 606
 607 static void
 608 add_one_tag (const GstTagList * list, const gchar * tag, gpointer user_data)
 609 {
 610   GstLame *lame;
 611   gchar *value;
 612   int i = 0;
 613
 614   lame = GST_LAME (user_data);
 615   g_return_if_fail (lame != NULL);
 616
 617   while (tag_matches[i].gstreamer_tag != NULL) {
 618     if (strcmp (tag, tag_matches[i].gstreamer_tag) == 0) {
 619       break;
 620     }
 621     i++;
 622   }
 623
 624   if (tag_matches[i].tag_func == NULL) {
 625     g_print ("Couldn't find matching gstreamer tag for %s\n", tag);
 626     return;
 627   }
 628
 629   switch (gst_tag_get_type (tag)) {
 630     case G_TYPE_UINT:{
 631       guint ivalue;
 632
 633       if (!gst_tag_list_get_uint (list, tag, &ivalue)) {
 634         GST_DEBUG ("Error reading \"%s\" tag value\n", tag);
 635         return;
 636       }
 637       value = g_strdup_printf ("%u", ivalue);
 638       break;
 639     }
 640     case G_TYPE_STRING:
 641       if (!gst_tag_list_get_string (list, tag, &value)) {
 642         GST_DEBUG ("Error reading \"%s\" tag value\n", tag);
 643         return;
 644       };
 645       break;
 646     default:
 647       GST_DEBUG ("Couldn't write tag %s", tag);
 648       break;
 649   }
 650
 651   tag_matches[i].tag_func (lame->lgf, value);
 652
 653   if (gst_tag_get_type (tag) == G_TYPE_UINT) {
 654     g_free (value);
 655   }
 656 }
 657
 658 static void
 659 gst_lame_set_metadata (GstLame * lame)
 660 {
 661   const GstTagList *user_tags;
 662   GstTagList *copy;
 663
 664   g_return_if_fail (lame != NULL);
 665   user_tags = gst_tag_setter_get_list (GST_TAG_SETTER (lame));
 666   if ((lame->tags == NULL) && (user_tags == NULL)) {
 667     return;
 668   }
 669   copy = gst_tag_list_merge (user_tags, lame->tags,
 670       gst_tag_setter_get_merge_mode (GST_TAG_SETTER (lame)));
 671   gst_tag_list_foreach ((GstTagList *) copy, add_one_tag, lame);
 672
 673   gst_tag_list_free (copy);
 674 }
 675
 676
 677
 678 static void
 679 gst_lame_set_property (GObject * object, guint prop_id, const GValue * value,
 680     GParamSpec * pspec)
 681 {
 682   GstLame *lame;
 683
 684   /* it's not null if we got it, but it might not be ours */
 685   g_return_if_fail (GST_IS_LAME (object));
 686
 687   lame = GST_LAME (object);
 688
 689   switch (prop_id) {
 690     case ARG_BITRATE:
 691       lame->bitrate = g_value_get_int (value);
 692       break;
 693     case ARG_COMPRESSION_RATIO:
 694       lame->compression_ratio = g_value_get_float (value);
 695       break;
 696     case ARG_QUALITY:
 697       lame->quality = g_value_get_enum (value);
 698       break;
 699     case ARG_MODE:
 700       lame->mode = g_value_get_enum (value);
 701       break;
 702     case ARG_FORCE_MS:
 703       lame->force_ms = g_value_get_boolean (value);
 704       break;
 705     case ARG_FREE_FORMAT:
 706       lame->free_format = g_value_get_boolean (value);
 707       break;
 708     case ARG_COPYRIGHT:
 709       lame->copyright = g_value_get_boolean (value);
 710       break;
 711     case ARG_ORIGINAL:
 712       lame->original = g_value_get_boolean (value);
 713       break;
 714     case ARG_ERROR_PROTECTION:
 715       lame->error_protection = g_value_get_boolean (value);
 716       break;
 717     case ARG_PADDING_TYPE:
 718       lame->padding_type = g_value_get_int (value);
 719       break;
 720     case ARG_EXTENSION:
 721       lame->extension = g_value_get_boolean (value);
 722       break;
 723     case ARG_STRICT_ISO:
 724       lame->strict_iso = g_value_get_boolean (value);
 725       break;
 726     case ARG_DISABLE_RESERVOIR:
 727       lame->disable_reservoir = g_value_get_boolean (value);
 728       break;
 729     case ARG_VBR:
 730       lame->vbr = g_value_get_enum (value);
 731       break;
 732     case ARG_VBR_QUALITY:
 733       lame->vbr_quality = g_value_get_enum (value);
 734       break;
 735     case ARG_VBR_MEAN_BITRATE:
 736       lame->vbr_mean_bitrate = g_value_get_int (value);
 737       break;
 738     case ARG_VBR_MIN_BITRATE:
 739       lame->vbr_min_bitrate = g_value_get_int (value);
 740       break;
 741     case ARG_VBR_MAX_BITRATE:
 742       lame->vbr_max_bitrate = g_value_get_int (value);
 743       break;
 744     case ARG_VBR_HARD_MIN:
 745       lame->vbr_hard_min = g_value_get_int (value);
 746       break;
 747     case ARG_LOWPASS_FREQ:
 748       lame->lowpass_freq = g_value_get_int (value);
 749       break;
 750     case ARG_LOWPASS_WIDTH:
 751       lame->lowpass_width = g_value_get_int (value);
 752       break;
 753     case ARG_HIGHPASS_FREQ:
 754       lame->highpass_freq = g_value_get_int (value);
 755       break;
 756     case ARG_HIGHPASS_WIDTH:
 757       lame->highpass_width = g_value_get_int (value);
 758       break;
 759     case ARG_ATH_ONLY:
 760       lame->ath_only = g_value_get_boolean (value);
 761       break;
 762     case ARG_ATH_SHORT:
 763       lame->ath_short = g_value_get_boolean (value);
 764       break;
 765     case ARG_NO_ATH:
 766       lame->no_ath = g_value_get_boolean (value);
 767       break;
 768     case ARG_ATH_LOWER:
 769       lame->ath_lower = g_value_get_int (value);
 770       break;
 771     case ARG_CWLIMIT:
 772       lame->cwlimit = g_value_get_int (value);
 773       break;
 774     case ARG_ALLOW_DIFF_SHORT:
 775       lame->allow_diff_short = g_value_get_boolean (value);
 776       break;
 777     case ARG_NO_SHORT_BLOCKS:
 778       lame->no_short_blocks = g_value_get_boolean (value);
 779       break;
 780     case ARG_EMPHASIS:
 781       lame->emphasis = g_value_get_boolean (value);
 782       break;
 783     case ARG_XINGHEADER:
 784       lame->xingheader = g_value_get_boolean (value);
 785       break;
 786 #ifdef GSTLAME_PRESET
 787     case ARG_PRESET:
 788       lame->preset = g_value_get_enum (value);
 789       break;
 790 #endif
 791     default:
 792       break;
 793   }
 794
 795 }
 796
 797 static void
 798 gst_lame_get_property (GObject * object, guint prop_id, GValue * value,
 799     GParamSpec * pspec)
 800 {
 801   GstLame *lame;
 802
 803   /* it's not null if we got it, but it might not be ours */
 804   g_return_if_fail (GST_IS_LAME (object));
 805
 806   lame = GST_LAME (object);
 807
 808   switch (prop_id) {
 809     case ARG_BITRATE:
 810       g_value_set_int (value, lame->bitrate);
 811       break;
 812     case ARG_COMPRESSION_RATIO:
 813       g_value_set_float (value, lame->compression_ratio);
 814       break;
 815     case ARG_QUALITY:
 816       g_value_set_enum (value, lame->quality);
 817       break;
 818     case ARG_MODE:
 819       g_value_set_enum (value, lame->mode);
 820       break;
 821     case ARG_FORCE_MS:
 822       g_value_set_boolean (value, lame->force_ms);
 823       break;
 824     case ARG_FREE_FORMAT:
 825       g_value_set_boolean (value, lame->free_format);
 826       break;
 827     case ARG_COPYRIGHT:
 828       g_value_set_boolean (value, lame->copyright);
 829       break;
 830     case ARG_ORIGINAL:
 831       g_value_set_boolean (value, lame->original);
 832       break;
 833     case ARG_ERROR_PROTECTION:
 834       g_value_set_boolean (value, lame->error_protection);
 835       break;
 836     case ARG_PADDING_TYPE:
 837       g_value_set_enum (value, lame->padding_type);
 838       break;
 839     case ARG_EXTENSION:
 840       g_value_set_boolean (value, lame->extension);
 841       break;
 842     case ARG_STRICT_ISO:
 843       g_value_set_boolean (value, lame->strict_iso);
 844       break;
 845     case ARG_DISABLE_RESERVOIR:
 846       g_value_set_boolean (value, lame->disable_reservoir);
 847       break;
 848     case ARG_VBR:
 849       g_value_set_enum (value, lame->vbr);
 850       break;
 851     case ARG_VBR_QUALITY:
 852       g_value_set_enum (value, lame->vbr_quality);
 853       break;
 854     case ARG_VBR_MEAN_BITRATE:
 855       g_value_set_int (value, lame->vbr_mean_bitrate);
 856       break;
 857     case ARG_VBR_MIN_BITRATE:
 858       g_value_set_int (value, lame->vbr_min_bitrate);
 859       break;
 860     case ARG_VBR_MAX_BITRATE:
 861       g_value_set_int (value, lame->vbr_max_bitrate);
 862       break;
 863     case ARG_VBR_HARD_MIN:
 864       g_value_set_int (value, lame->vbr_hard_min);
 865       break;
 866     case ARG_LOWPASS_FREQ:
 867       g_value_set_int (value, lame->lowpass_freq);
 868       break;
 869     case ARG_LOWPASS_WIDTH:
 870       g_value_set_int (value, lame->lowpass_width);
 871       break;
 872     case ARG_HIGHPASS_FREQ:
 873       g_value_set_int (value, lame->highpass_freq);
 874       break;
 875     case ARG_HIGHPASS_WIDTH:
 876       g_value_set_int (value, lame->highpass_width);
 877       break;
 878     case ARG_ATH_ONLY:
 879       g_value_set_boolean (value, lame->ath_only);
 880       break;
 881     case ARG_ATH_SHORT:
 882       g_value_set_boolean (value, lame->ath_short);
 883       break;
 884     case ARG_NO_ATH:
 885       g_value_set_boolean (value, lame->no_ath);
 886       break;
 887     case ARG_ATH_LOWER:
 888       g_value_set_int (value, lame->ath_lower);
 889       break;
 890     case ARG_CWLIMIT:
 891       g_value_set_int (value, lame->cwlimit);
 892       break;
 893     case ARG_ALLOW_DIFF_SHORT:
 894       g_value_set_boolean (value, lame->allow_diff_short);
 895       break;
 896     case ARG_NO_SHORT_BLOCKS:
 897       g_value_set_boolean (value, lame->no_short_blocks);
 898       break;
 899     case ARG_EMPHASIS:
 900       g_value_set_boolean (value, lame->emphasis);
 901       break;
 902     case ARG_XINGHEADER:
 903       g_value_set_boolean (value, lame->xingheader);
 904       break;
 905 #ifdef GSTLAME_PRESET
 906     case ARG_PRESET:
 907       g_value_set_enum (value, lame->preset);
 908       break;
 909 #endif
 910     default:
 911       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 912       break;
 913   }
 914 }
 915
 916 static void
 917 gst_lame_chain (GstPad * pad, GstData * _data)
 918 {
 919   GstBuffer *buf = GST_BUFFER (_data);
 920   GstLame *lame;
 921   GstBuffer *outbuf;
 922   gchar *mp3_data = NULL;
 923   gint mp3_buffer_size, mp3_size = 0;
 924   gboolean eos = FALSE;
 925
 926   lame = GST_LAME (gst_pad_get_parent (pad));
 927
 928   GST_LOG_OBJECT (lame, "entered chain");
 929
 930   if (GST_IS_EVENT (buf)) {
 931     switch (GST_EVENT_TYPE (buf)) {
 932       case GST_EVENT_EOS:
 933         GST_DEBUG_OBJECT (lame, "handling EOS event");
 934         eos = TRUE;
 935       case GST_EVENT_FLUSH:
 936         GST_DEBUG_OBJECT (lame, "handling FLUSH event");
 937         mp3_buffer_size = 7200;
 938         mp3_data = g_malloc (mp3_buffer_size);
 939
 940         mp3_size = lame_encode_flush (lame->lgf, mp3_data, mp3_buffer_size);
 941         gst_event_unref (GST_EVENT (buf));
 942         break;
 943       case GST_EVENT_TAG:
 944         GST_DEBUG_OBJECT (lame, "handling TAG event");
 945         if (lame->tags) {
 946           gst_tag_list_insert (lame->tags,
 947               gst_event_tag_get_list (GST_EVENT (buf)),
 948               gst_tag_setter_get_merge_mode (GST_TAG_SETTER (lame)));
 949         } else {
 950           g_assert_not_reached ();
 951         }
 952         gst_pad_event_default (pad, GST_EVENT (buf));
 953         break;
 954       default:
 955         gst_pad_event_default (pad, GST_EVENT (buf));
 956         break;
 957     }
 958   } else {
 959     gint64 duration;
 960
 961     if (!lame->initialized) {
 962       gst_buffer_unref (buf);
 963       GST_ELEMENT_ERROR (lame, CORE, NEGOTIATION, (NULL),
 964           ("encoder not initialized (input is not audio?)"));
 965       return;
 966     }
 967
 968     /* allocate space for output */
 969     mp3_buffer_size =
 970         ((GST_BUFFER_SIZE (buf) / (2 + lame->num_channels)) * 1.25) + 7200;
 971     mp3_data = g_malloc (mp3_buffer_size);
 972
 973     /* lame seems to be too stupid to get mono interleaved going */
 974     if (lame->num_channels == 1) {
 975       mp3_size = lame_encode_buffer (lame->lgf,
 976           (short int *) (GST_BUFFER_DATA (buf)),
 977           (short int *) (GST_BUFFER_DATA (buf)),
 978           GST_BUFFER_SIZE (buf) / 2, mp3_data, mp3_buffer_size);
 979     } else {
 980       mp3_size = lame_encode_buffer_interleaved (lame->lgf,
 981           (short int *) (GST_BUFFER_DATA (buf)),
 982           GST_BUFFER_SIZE (buf) / 2 / lame->num_channels,
 983           mp3_data, mp3_buffer_size);
 984     }
 985
 986     GST_LOG_OBJECT (lame, "encoded %d bytes of audio to %d bytes of mp3",
 987         GST_BUFFER_SIZE (buf), mp3_size);
 988
 989     duration = (GST_SECOND * GST_BUFFER_SIZE (buf) /
 990         (2 * lame->samplerate * lame->num_channels));
 991
 992     if (GST_BUFFER_DURATION (buf) != GST_CLOCK_TIME_NONE &&
 993         GST_BUFFER_DURATION (buf) != duration)
 994       GST_DEBUG_OBJECT (lame, "incoming buffer had incorrect duration "
 995           GST_TIME_FORMAT "outgoing buffer will have correct duration "
 996           GST_TIME_FORMAT,
 997           GST_TIME_ARGS (GST_BUFFER_DURATION (buf)), GST_TIME_ARGS (duration));
 998
 999     if (lame->last_ts == GST_CLOCK_TIME_NONE) {
1000       lame->last_ts = GST_BUFFER_TIMESTAMP (buf);
1001       lame->last_offs = GST_BUFFER_OFFSET (buf);
1002       lame->last_duration = duration;
1003     } else {
1004       lame->last_duration += duration;
1005     }
1006
1007     gst_buffer_unref (buf);
1008   }
1009
1010   if (mp3_size > 0) {
1011     outbuf = gst_buffer_new ();
1012     GST_BUFFER_DATA (outbuf) = mp3_data;
1013     GST_BUFFER_SIZE (outbuf) = mp3_size;
1014     GST_BUFFER_TIMESTAMP (outbuf) = lame->last_ts;
1015     GST_BUFFER_OFFSET (outbuf) = lame->last_offs;
1016     GST_BUFFER_DURATION (outbuf) = lame->last_duration;
1017
1018     gst_pad_push (lame->srcpad, GST_DATA (outbuf));
1019
1020     lame->last_ts = GST_CLOCK_TIME_NONE;
1021   } else {
1022     g_free (mp3_data);
1023   }
1024
1025   if (eos) {
1026     gst_pad_push (lame->srcpad, GST_DATA (gst_event_new (GST_EVENT_EOS)));
1027     gst_element_set_eos (GST_ELEMENT (lame));
1028   }
1029 }
1030
1031 /* transition to the READY state by configuring the gst_lame encoder */
1032 static gboolean
1033 gst_lame_setup (GstLame * lame)
1034 {
1035 #define CHECK_ERROR(command) G_STMT_START {\
1036   if ((command) < 0) { \
1037     GST_ERROR_OBJECT (lame, "setup failed: " G_STRINGIFY (command)); \
1038     return FALSE; \
1039   } \
1040 }G_STMT_END
1041   int retval;
1042
1043   GST_DEBUG_OBJECT (lame, "starting setup");
1044
1045   /* check if we're already initialized; if we are, we might want to check
1046    * if this initialization is compatible with the previous one */
1047   /* FIXME: do this */
1048   if (lame->initialized) {
1049     GST_WARNING_OBJECT (lame, "already initialized");
1050     lame->initialized = FALSE;
1051   }
1052
1053   /* copy the parameters over */
1054   lame_set_in_samplerate (lame->lgf, lame->samplerate);
1055
1056   /* force mono encoding if we only have one channel */
1057   if (lame->num_channels == 1)
1058     lame->mode = 3;
1059
1060   CHECK_ERROR (lame_set_num_channels (lame->lgf, lame->num_channels));
1061   CHECK_ERROR (lame_set_brate (lame->lgf, lame->bitrate));
1062   CHECK_ERROR (lame_set_compression_ratio (lame->lgf, lame->compression_ratio));
1063   CHECK_ERROR (lame_set_quality (lame->lgf, lame->quality));
1064   CHECK_ERROR (lame_set_mode (lame->lgf, lame->mode));
1065   CHECK_ERROR (lame_set_force_ms (lame->lgf, lame->force_ms));
1066   CHECK_ERROR (lame_set_free_format (lame->lgf, lame->free_format));
1067   CHECK_ERROR (lame_set_copyright (lame->lgf, lame->copyright));
1068   CHECK_ERROR (lame_set_original (lame->lgf, lame->original));
1069   CHECK_ERROR (lame_set_error_protection (lame->lgf, lame->error_protection));
1070   CHECK_ERROR (lame_set_padding_type (lame->lgf, lame->padding_type));
1071   CHECK_ERROR (lame_set_extension (lame->lgf, lame->extension));
1072   CHECK_ERROR (lame_set_strict_ISO (lame->lgf, lame->strict_iso));
1073   CHECK_ERROR (lame_set_disable_reservoir (lame->lgf, lame->disable_reservoir));
1074   CHECK_ERROR (lame_set_VBR (lame->lgf, lame->vbr));
1075   CHECK_ERROR (lame_set_VBR_q (lame->lgf, lame->vbr_quality));
1076   CHECK_ERROR (lame_set_VBR_mean_bitrate_kbps (lame->lgf,
1077           lame->vbr_mean_bitrate));
1078   CHECK_ERROR (lame_set_VBR_min_bitrate_kbps (lame->lgf,
1079           lame->vbr_min_bitrate));
1080   CHECK_ERROR (lame_set_VBR_max_bitrate_kbps (lame->lgf,
1081           lame->vbr_max_bitrate));
1082   CHECK_ERROR (lame_set_VBR_hard_min (lame->lgf, lame->vbr_hard_min));
1083   CHECK_ERROR (lame_set_lowpassfreq (lame->lgf, lame->lowpass_freq));
1084   CHECK_ERROR (lame_set_lowpasswidth (lame->lgf, lame->lowpass_width));
1085   CHECK_ERROR (lame_set_highpassfreq (lame->lgf, lame->highpass_freq));
1086   CHECK_ERROR (lame_set_highpasswidth (lame->lgf, lame->highpass_width));
1087   CHECK_ERROR (lame_set_ATHonly (lame->lgf, lame->ath_only));
1088   CHECK_ERROR (lame_set_ATHshort (lame->lgf, lame->ath_short));
1089   CHECK_ERROR (lame_set_noATH (lame->lgf, lame->no_ath));
1090   CHECK_ERROR (lame_set_ATHlower (lame->lgf, lame->ath_lower));
1091   CHECK_ERROR (lame_set_cwlimit (lame->lgf, lame->cwlimit));
1092   CHECK_ERROR (lame_set_allow_diff_short (lame->lgf, lame->allow_diff_short));
1093   CHECK_ERROR (lame_set_no_short_blocks (lame->lgf, lame->no_short_blocks));
1094   CHECK_ERROR (lame_set_emphasis (lame->lgf, lame->emphasis));
1095   CHECK_ERROR (lame_set_bWriteVbrTag (lame->lgf, lame->xingheader ? 1 : 0));
1096 #ifdef GSTLAME_PRESET
1097   if (lame->preset > 0) {
1098     CHECK_ERROR (lame_set_preset (lame->lgf, lame->preset));
1099   }
1100 #endif
1101   gst_lame_set_metadata (lame);
1102
1103   /* initialize the lame encoder */
1104   if ((retval = lame_init_params (lame->lgf)) >= 0) {
1105     lame->initialized = TRUE;
1106     /* FIXME: it would be nice to print out the mode here */
1107     GST_INFO ("lame encoder initialized (%d kbit/s, %d Hz, %d channels)",
1108         lame->bitrate, lame->samplerate, lame->num_channels);
1109   } else {
1110     GST_ERROR_OBJECT (lame, "lame_init_params returned %d", retval);
1111   }
1112
1113   GST_DEBUG_OBJECT (lame, "done with setup");
1114
1115   return lame->initialized;
1116 #undef CHECK_ERROR
1117 }
1118
1119 static GstElementStateReturn
1120 gst_lame_change_state (GstElement * element)
1121 {
1122   GstLame *lame;
1123
1124   g_return_val_if_fail (GST_IS_LAME (element), GST_STATE_FAILURE);
1125
1126   lame = GST_LAME (element);
1127
1128   GST_DEBUG ("state pending %d", GST_STATE_PENDING (element));
1129
1130   switch (GST_STATE_TRANSITION (element)) {
1131     case GST_STATE_READY_TO_PAUSED:
1132       lame->last_ts = GST_CLOCK_TIME_NONE;
1133       break;
1134     case GST_STATE_READY_TO_NULL:
1135       if (lame->initialized) {
1136         lame_close (lame->lgf);
1137         lame->lgf = lame_init ();
1138         lame->initialized = FALSE;
1139       }
1140       break;
1141     default:
1142       break;
1143   }
1144
1145   /* if we haven't failed already, give the parent class a chance to ;-) */
1146   if (GST_ELEMENT_CLASS (parent_class)->change_state)
1147     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
1148
1149   return GST_STATE_SUCCESS;
1150 }
1151
1152 static gboolean
1153 plugin_init (GstPlugin * plugin)
1154 {
1155   if (!gst_element_register (plugin, "lame", GST_RANK_NONE, GST_TYPE_LAME))
1156     return FALSE;
1157
1158   GST_DEBUG_CATEGORY_INIT (debug, "lame", 0, "lame mp3 encoder");
1159   return TRUE;
1160 }
1161
1162 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1163     GST_VERSION_MINOR,
1164     "lame",
1165     "Encode MP3's with LAME",
1166     plugin_init, VERSION, "LGPL", GST_PACKAGE, GST_ORIGIN)