]> Gitweb @ Texas Instruments - Open Source Git Repositories - git.TI.com/gitweb - glsdk/gst-plugins-ugly0-10.git/blobdiff - ext/lame/gstlame.c
lame: fix printf format in debug statements
[glsdk/gst-plugins-ugly0-10.git] / ext / lame / gstlame.c
index 9c167a48708a88f23cd10023a7a6de393434d4f6..9ce689d3f0a637bd2a81d3a9137beae3e3e3535a 100644 (file)
@@ -21,7 +21,7 @@
 
 /**
  * SECTION:element-lame
- * @see_also: mad, vorbisenc
+ * @see_also: lame, mad, vorbisenc
  *
  * This element encodes raw integer audio into an MPEG-1 layer 3 (MP3) stream.
  * Note that <ulink url="http://en.wikipedia.org/wiki/MP3">MP3</ulink> is not
  * for a royalty free (and often higher quality) alternative.
  *
  * <refsect2>
+ * <title>Note</title>
+ * This element is deprecated, use the lame element instead
+ * which provides a much simpler interface and results in better MP3 files.
+ * </refsect2>
+ *
+ * <refsect2>
  * <title>Output sample rate</title>
  * If no fixed output sample rate is negotiated on the element's src pad,
  * the element will choose an optimal sample rate to resample to internally.
  * Last reviewed on 2007-07-24 (0.10.7)
  */
 
+/* FIXME 0.11: Remove all properties except the useful ones. Nobody knows what most
+ * properties are doing and they're intended for LAME developers only.
+ */
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 GST_DEBUG_CATEGORY_STATIC (debug);
 #define GST_CAT_DEFAULT debug
 
-#define DEFAULT_MIN_VBR_BITRATE 112
-#define DEFAULT_MAX_VBR_BITRATE 160
-#define DEFAULT_MEAN_VBR_BITRATE 128
-
-/* elementfactory information */
-static GstElementDetails gst_lame_details = {
-  "L.A.M.E. mp3 encoder",
-  "Codec/Encoder/Audio",
-  "High-quality free MP3 encoder",
-  "Erik Walthinsen <omega@cse.ogi.edu>, " "Wim Taymans <wim@fluendo.com>",
-};
-
 /* LAME can do MPEG-1, MPEG-2, and MPEG-2.5, so it has 9 possible
  * sample rates it supports */
 static GstStaticPadTemplate gst_lame_sink_template =
@@ -120,6 +118,41 @@ GST_STATIC_PAD_TEMPLATE ("src",
         "channels = (int) [ 1, 2 ]")
     );
 
+static struct
+{
+  gint bitrate;
+  gfloat compression_ratio;
+  gint quality;
+  gint mode;
+  gboolean force_ms;
+  gboolean free_format;
+  gboolean copyright;
+  gboolean original;
+  gboolean error_protection;
+  gboolean extension;
+  gboolean strict_iso;
+  gboolean disable_reservoir;
+  gint vbr;
+  gint vbr_quality;
+  gint vbr_mean_bitrate;
+  gint vbr_min_bitrate;
+  gint vbr_max_bitrate;
+  gint vbr_hard_min;
+  gint lowpass_freq;
+  gint lowpass_width;
+  gint highpass_freq;
+  gint highpass_width;
+  gboolean ath_only;
+  gboolean ath_short;
+  gboolean no_ath;
+  gint ath_type;
+  gint ath_lower;
+  gboolean allow_diff_short;
+  gboolean no_short_blocks;
+  gboolean emphasis;
+  gint preset;
+} gst_lame_default_settings;
+
 /********** Define useful types for non-programmatic interfaces **********/
 #define GST_TYPE_LAME_MODE (gst_lame_mode_get_type())
 static GType
@@ -272,56 +305,33 @@ enum
 #endif
 };
 
-static void gst_lame_base_init (gpointer g_class);
-static void gst_lame_class_init (GstLameClass * klass);
-static void gst_lame_init (GstLame * gst_lame);
+static gboolean gst_lame_start (GstAudioEncoder * enc);
+static gboolean gst_lame_stop (GstAudioEncoder * enc);
+static gboolean gst_lame_set_format (GstAudioEncoder * enc,
+    GstAudioInfo * info);
+static GstFlowReturn gst_lame_handle_frame (GstAudioEncoder * enc,
+    GstBuffer * in_buf);
+static void gst_lame_flush (GstAudioEncoder * enc);
 
 static void gst_lame_set_property (GObject * object, guint prop_id,
     const GValue * value, GParamSpec * pspec);
 static void gst_lame_get_property (GObject * object, guint prop_id,
     GValue * value, GParamSpec * pspec);
-static gboolean gst_lame_sink_event (GstPad * pad, GstEvent * event);
-static GstFlowReturn gst_lame_chain (GstPad * pad, GstBuffer * buf);
 static gboolean gst_lame_setup (GstLame * lame);
-static GstStateChangeReturn gst_lame_change_state (GstElement * element,
-    GstStateChange transition);
-
-static GstElementClass *parent_class = NULL;
 
-GType
-gst_lame_get_type (void)
+static void
+gst_lame_add_interfaces (GType lame_type)
 {
-  static GType gst_lame_type = 0;
-
-  if (!gst_lame_type) {
-    static const GTypeInfo gst_lame_info = {
-      sizeof (GstLameClass),
-      gst_lame_base_init,
-      NULL,
-      (GClassInitFunc) gst_lame_class_init,
-      NULL,
-      NULL,
-      sizeof (GstLame),
-      0,
-      (GInstanceInitFunc) gst_lame_init,
-    };
-
-    /* FIXME: remove support for the GstTagSetter interface in 0.11 */
-    static const GInterfaceInfo tag_setter_info = {
-      NULL,
-      NULL,
-      NULL
-    };
-
-    gst_lame_type =
-        g_type_register_static (GST_TYPE_ELEMENT, "GstLame", &gst_lame_info, 0);
-    g_type_add_interface_static (gst_lame_type, GST_TYPE_TAG_SETTER,
-        &tag_setter_info);
+  static const GInterfaceInfo tag_setter_info = { NULL, NULL, NULL };
 
-  }
-  return gst_lame_type;
+  /* FIXME: remove support for the GstTagSetter interface in 0.11 */
+  g_type_add_interface_static (lame_type, GST_TYPE_TAG_SETTER,
+      &tag_setter_info);
 }
 
+GST_BOILERPLATE_FULL (GstLame, gst_lame, GstAudioEncoder,
+    GST_TYPE_AUDIO_ENCODER, gst_lame_add_interfaces);
+
 static void
 gst_lame_release_memory (GstLame * lame)
 {
@@ -344,185 +354,217 @@ gst_lame_base_init (gpointer g_class)
 {
   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 
-  gst_element_class_add_pad_template (element_class,
-      gst_static_pad_template_get (&gst_lame_src_template));
-  gst_element_class_add_pad_template (element_class,
-      gst_static_pad_template_get (&gst_lame_sink_template));
-  gst_element_class_set_details (element_class, &gst_lame_details);
+  gst_element_class_add_static_pad_template (element_class,
+      &gst_lame_src_template);
+  gst_element_class_add_static_pad_template (element_class,
+      &gst_lame_sink_template);
+  gst_element_class_set_details_simple (element_class, "L.A.M.E. mp3 encoder",
+      "Codec/Encoder/Audio",
+      "High-quality free MP3 encoder (deprecated)",
+      "Erik Walthinsen <omega@cse.ogi.edu>, " "Wim Taymans <wim@fluendo.com>");
 }
 
 static void
 gst_lame_class_init (GstLameClass * klass)
 {
   GObjectClass *gobject_class;
-  GstElementClass *gstelement_class;
+  GstAudioEncoderClass *base_class;
 
   gobject_class = (GObjectClass *) klass;
-  gstelement_class = (GstElementClass *) klass;
-
-  parent_class = g_type_class_peek_parent (klass);
+  base_class = (GstAudioEncoderClass *) klass;
 
   gobject_class->set_property = gst_lame_set_property;
   gobject_class->get_property = gst_lame_get_property;
   gobject_class->finalize = gst_lame_finalize;
 
+  base_class->start = GST_DEBUG_FUNCPTR (gst_lame_start);
+  base_class->stop = GST_DEBUG_FUNCPTR (gst_lame_stop);
+  base_class->set_format = GST_DEBUG_FUNCPTR (gst_lame_set_format);
+  base_class->handle_frame = GST_DEBUG_FUNCPTR (gst_lame_handle_frame);
+  base_class->flush = GST_DEBUG_FUNCPTR (gst_lame_flush);
+
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BITRATE,
       g_param_spec_int ("bitrate", "Bitrate (kb/s)",
           "Bitrate in kbit/sec (8, 16, 24, 32, 40, 48, 56, 64, 80, 96, "
           "112, 128, 160, 192, 224, 256 or 320)",
-          8, 320, 128, G_PARAM_READWRITE));
+          0, 320, gst_lame_default_settings.bitrate,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   /* compression ratio set to 0.0 by default otherwise it overrides the bitrate setting */
   g_object_class_install_property (G_OBJECT_CLASS (klass),
-      ARG_COMPRESSION_RATIO, g_param_spec_float ("compression_ratio",
+      ARG_COMPRESSION_RATIO, g_param_spec_float ("compression-ratio",
           "Compression Ratio",
           "let lame choose bitrate to achieve selected compression ratio", 0.0,
-          200.0, 0.0, G_PARAM_READWRITE));
+          200.0, gst_lame_default_settings.compression_ratio,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_QUALITY,
       g_param_spec_enum ("quality", "Quality",
-          "Quality of algorithm used for encoding", GST_TYPE_LAME_QUALITY, 5,
-          G_PARAM_READWRITE));
+          "Quality of algorithm used for encoding", GST_TYPE_LAME_QUALITY,
+          gst_lame_default_settings.quality,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MODE,
-      g_param_spec_enum ("mode", "Mode", "Encoding mode", GST_TYPE_LAME_MODE, 0,
-          G_PARAM_READWRITE));
+      g_param_spec_enum ("mode", "Mode", "Encoding mode", GST_TYPE_LAME_MODE,
+          gst_lame_default_settings.mode,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FORCE_MS,
       g_param_spec_boolean ("force-ms", "Force ms",
-          "Force ms_stereo on all frames", TRUE, G_PARAM_READWRITE));
+          "Force ms_stereo on all frames", gst_lame_default_settings.force_ms,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FREE_FORMAT,
       g_param_spec_boolean ("free-format", "Free format",
-          "Produce a free format bitstream", TRUE, G_PARAM_READWRITE));
+          "Produce a free format bitstream",
+          gst_lame_default_settings.free_format,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_COPYRIGHT,
-      g_param_spec_boolean ("copyright", "Copyright", "Mark as copyright", TRUE,
-          G_PARAM_READWRITE));
+      g_param_spec_boolean ("copyright", "Copyright", "Mark as copyright",
+          gst_lame_default_settings.copyright,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ORIGINAL,
-      g_param_spec_boolean ("original", "Original", "Mark as non-original",
-          TRUE, G_PARAM_READWRITE));
+      g_param_spec_boolean ("original", "Original", "Mark as original",
+          gst_lame_default_settings.original,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ERROR_PROTECTION,
       g_param_spec_boolean ("error-protection", "Error protection",
-          "Adds 16 bit checksum to every frame", TRUE, G_PARAM_READWRITE));
+          "Adds 16 bit checksum to every frame",
+          gst_lame_default_settings.error_protection,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PADDING_TYPE,
-      g_param_spec_enum ("padding-type", "Padding type", "Padding type "
-          "(DEPRECATED: this setting has no effect)",
-          GST_TYPE_LAME_PADDING, 0, G_PARAM_READWRITE));
+      g_param_spec_enum ("padding-type", "Padding type",
+          "Padding type " "(DEPRECATED: this setting has no effect)",
+          GST_TYPE_LAME_PADDING, FALSE,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EXTENSION,
-      g_param_spec_boolean ("extension", "Extension", "Extension", TRUE,
-          G_PARAM_READWRITE));
+      g_param_spec_boolean ("extension", "Extension", "Extension",
+          gst_lame_default_settings.extension,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_STRICT_ISO,
       g_param_spec_boolean ("strict-iso", "Strict ISO",
           "Comply as much as possible to ISO MPEG spec", TRUE,
-          G_PARAM_READWRITE));
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass),
       ARG_DISABLE_RESERVOIR, g_param_spec_boolean ("disable-reservoir",
           "Disable reservoir", "Disable the bit reservoir", TRUE,
-          G_PARAM_READWRITE));
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR,
       g_param_spec_enum ("vbr", "VBR", "Specify bitrate mode",
-          GST_TYPE_LAME_VBRMODE, vbr_off, G_PARAM_READWRITE));
+          GST_TYPE_LAME_VBRMODE, gst_lame_default_settings.vbr,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_QUALITY,
       g_param_spec_enum ("vbr-quality", "VBR Quality", "VBR Quality",
-          GST_TYPE_LAME_QUALITY, 5, G_PARAM_READWRITE));
+          GST_TYPE_LAME_QUALITY, gst_lame_default_settings.vbr_quality,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_MEAN_BITRATE,
       g_param_spec_int ("vbr-mean-bitrate", "VBR mean bitrate",
-          "Specify mean VBR bitrate", 8, 320,
-          DEFAULT_MEAN_VBR_BITRATE, G_PARAM_READWRITE));
+          "Specify mean VBR bitrate", 0, 320,
+          gst_lame_default_settings.vbr_mean_bitrate,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_MIN_BITRATE,
       g_param_spec_int ("vbr-min-bitrate", "VBR min bitrate",
           "Specify minimum VBR bitrate (8, 16, 24, 32, 40, 48, 56, 64, 80, 96, "
-          "112, 128, 160, 192, 224, 256 or 320)",
-          8, 320, DEFAULT_MIN_VBR_BITRATE, G_PARAM_READWRITE));
+          "112, 128, 160, 192, 224, 256 or 320)", 0, 320,
+          gst_lame_default_settings.vbr_min_bitrate,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_MAX_BITRATE,
       g_param_spec_int ("vbr-max-bitrate", "VBR max bitrate",
           "Specify maximum VBR bitrate (8, 16, 24, 32, 40, 48, 56, 64, 80, 96, "
-          "112, 128, 160, 192, 224, 256 or 320)",
-          8, 320, DEFAULT_MAX_VBR_BITRATE, G_PARAM_READWRITE));
+          "112, 128, 160, 192, 224, 256 or 320)", 0, 320,
+          gst_lame_default_settings.vbr_max_bitrate,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_HARD_MIN,
       g_param_spec_int ("vbr-hard-min", "VBR hard min",
           "Specify whether min VBR bitrate is a hard limit. Normally, "
-          "it can be violated for silence", 0, 1, 0, G_PARAM_READWRITE));
+          "it can be violated for silence", 0, 1,
+          gst_lame_default_settings.vbr_hard_min,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOWPASS_FREQ,
       g_param_spec_int ("lowpass-freq", "Lowpass freq",
-          "frequency(kHz), lowpass filter cutoff above freq", 0, 50000, 0,
-          G_PARAM_READWRITE));
+          "frequency(kHz), lowpass filter cutoff above freq", 0, 50000,
+          gst_lame_default_settings.lowpass_freq,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOWPASS_WIDTH,
       g_param_spec_int ("lowpass-width", "Lowpass width",
-          "frequency(kHz) - default 15% of lowpass freq", 0, G_MAXINT, 0,
-          G_PARAM_READWRITE));
+          "frequency(kHz) - default 15% of lowpass freq", -1, G_MAXINT,
+          gst_lame_default_settings.lowpass_width,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_HIGHPASS_FREQ,
       g_param_spec_int ("highpass-freq", "Highpass freq",
-          "frequency(kHz), highpass filter cutoff below freq", 0, 50000, 0,
-          G_PARAM_READWRITE));
+          "frequency(kHz), highpass filter cutoff below freq", 0, 50000,
+          gst_lame_default_settings.highpass_freq,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_HIGHPASS_WIDTH,
       g_param_spec_int ("highpass-width", "Highpass width",
-          "frequency(kHz) - default 15% of highpass freq", 0, G_MAXINT, 0,
-          G_PARAM_READWRITE));
+          "frequency(kHz) - default 15% of highpass freq", -1, G_MAXINT,
+          gst_lame_default_settings.highpass_width,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ATH_ONLY,
       g_param_spec_boolean ("ath-only", "ATH only",
-          "Ignore GPSYCHO completely, use ATH only", TRUE, G_PARAM_READWRITE));
+          "Ignore GPSYCHO completely, use ATH only",
+          gst_lame_default_settings.ath_only,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ATH_SHORT,
       g_param_spec_boolean ("ath-short", "ATH short",
-          "Ignore GPSYCHO for short blocks, use ATH only", TRUE,
-          G_PARAM_READWRITE));
+          "Ignore GPSYCHO for short blocks, use ATH only",
+          gst_lame_default_settings.ath_short,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NO_ATH,
       g_param_spec_boolean ("no-ath", "No ath",
-          "turns ATH down to a flat noise floor", TRUE, G_PARAM_READWRITE));
+          "turns ATH down to a flat noise floor",
+          gst_lame_default_settings.no_ath,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ATH_LOWER,
       g_param_spec_int ("ath-lower", "ATH lower", "lowers ATH by x dB",
-          G_MININT, G_MAXINT, 0, G_PARAM_READWRITE));
+          G_MININT, G_MAXINT, gst_lame_default_settings.ath_lower,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_CWLIMIT,
       g_param_spec_int ("cwlimit", "Cwlimit",
           "Compute tonality up to freq (in kHz) default 8.8717 "
           "(DEPRECATED: this setting has no effect)", 0, 50000, 0,
-          G_PARAM_READWRITE));
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ALLOW_DIFF_SHORT,
       g_param_spec_boolean ("allow-diff-short", "Allow diff short",
-          "Allow diff short", TRUE, G_PARAM_READWRITE));
+          "Allow diff short", gst_lame_default_settings.allow_diff_short,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NO_SHORT_BLOCKS,
       g_param_spec_boolean ("no-short-blocks", "No short blocks",
-          "Do not use short blocks", TRUE, G_PARAM_READWRITE));
+          "Do not use short blocks", gst_lame_default_settings.no_short_blocks,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EMPHASIS,
-      g_param_spec_boolean ("emphasis", "Emphasis", "Emphasis", TRUE,
-          G_PARAM_READWRITE));
+      g_param_spec_boolean ("emphasis", "Emphasis", "Emphasis",
+          gst_lame_default_settings.emphasis,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_XINGHEADER,
       g_param_spec_boolean ("xingheader", "Output Xing Header",
-          "Output Xing Header (BROKEN, use xingmux instead)",
-          FALSE, G_PARAM_READWRITE));
+          "Output Xing Header (BROKEN, use xingmux instead)", FALSE,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 #ifdef GSTLAME_PRESET
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PRESET,
       g_param_spec_enum ("preset", "Lame Preset", "Lame Preset",
-          GST_TYPE_LAME_PRESET, 0, G_PARAM_READWRITE));
+          GST_TYPE_LAME_PRESET, gst_lame_default_settings.preset,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 #endif
-
-  gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_lame_change_state);
-}
-
-static gboolean
-gst_lame_src_setcaps (GstPad * pad, GstCaps * caps)
-{
-  GST_DEBUG_OBJECT (pad, "caps: %" GST_PTR_FORMAT, caps);
-  return TRUE;
 }
 
 static gboolean
-gst_lame_sink_setcaps (GstPad * pad, GstCaps * caps)
+gst_lame_set_format (GstAudioEncoder * enc, GstAudioInfo * info)
 {
   GstLame *lame;
   gint out_samplerate;
   gint version;
-  GstStructure *structure;
   GstCaps *othercaps;
+  GstClockTime latency;
 
-  lame = GST_LAME (GST_PAD_PARENT (pad));
-  structure = gst_caps_get_structure (caps, 0);
+  lame = GST_LAME (enc);
 
-  if (!gst_structure_get_int (structure, "rate", &lame->samplerate))
-    goto no_rate;
-  if (!gst_structure_get_int (structure, "channels", &lame->num_channels))
-    goto no_channels;
+  /* parameters already parsed for us */
+  lame->samplerate = GST_AUDIO_INFO_RATE (info);
+  lame->num_channels = GST_AUDIO_INFO_CHANNELS (info);
+
+  /* but we might be asked to reconfigure, so reset */
+  gst_lame_release_memory (lame);
 
   GST_DEBUG_OBJECT (lame, "setting up lame");
   if (!gst_lame_setup (lame))
     goto setup_failed;
 
-
   out_samplerate = lame_get_out_samplerate (lame->lgf);
   if (out_samplerate == 0)
     goto zero_output_rate;
@@ -531,6 +573,7 @@ gst_lame_sink_setcaps (GstPad * pad, GstCaps * caps)
         "output samplerate %d is different from incoming samplerate %d",
         out_samplerate, lame->samplerate);
   }
+  lame->out_samplerate = out_samplerate;
 
   version = lame_get_version (lame->lgf);
   if (version == 0)
@@ -549,21 +592,18 @@ gst_lame_sink_setcaps (GstPad * pad, GstCaps * caps)
       "rate", G_TYPE_INT, out_samplerate, NULL);
 
   /* and use these caps */
-  gst_pad_set_caps (lame->srcpad, othercaps);
+  gst_pad_set_caps (GST_AUDIO_ENCODER_SRC_PAD (lame), othercaps);
   gst_caps_unref (othercaps);
 
+  /* base class feedback:
+   * - we will handle buffers, just hand us all available
+   * - report latency */
+  latency = gst_util_uint64_scale_int (lame_get_framesize (lame->lgf),
+      GST_SECOND, lame->samplerate);
+  gst_audio_encoder_set_latency (enc, latency, latency);
+
   return TRUE;
 
-no_rate:
-  {
-    GST_ERROR_OBJECT (lame, "input caps have no sample rate field");
-    return FALSE;
-  }
-no_channels:
-  {
-    GST_ERROR_OBJECT (lame, "input caps have no channels field");
-    return FALSE;
-  }
 zero_output_rate:
   {
     GST_ELEMENT_ERROR (lame, LIBRARY, SETTINGS, (NULL),
@@ -579,106 +619,76 @@ setup_failed:
 }
 
 static void
-gst_lame_init (GstLame * lame)
+gst_lame_init (GstLame * lame, GstLameClass * klass)
 {
   GST_DEBUG_OBJECT (lame, "starting initialization");
 
-  lame->sinkpad =
-      gst_pad_new_from_static_template (&gst_lame_sink_template, "sink");
-  gst_pad_set_event_function (lame->sinkpad,
-      GST_DEBUG_FUNCPTR (gst_lame_sink_event));
-  gst_pad_set_chain_function (lame->sinkpad,
-      GST_DEBUG_FUNCPTR (gst_lame_chain));
-  gst_pad_set_setcaps_function (lame->sinkpad,
-      GST_DEBUG_FUNCPTR (gst_lame_sink_setcaps));
-  gst_element_add_pad (GST_ELEMENT (lame), lame->sinkpad);
-
-  lame->srcpad =
-      gst_pad_new_from_static_template (&gst_lame_src_template, "src");
-  gst_pad_set_setcaps_function (lame->srcpad,
-      GST_DEBUG_FUNCPTR (gst_lame_src_setcaps));
-  gst_element_add_pad (GST_ELEMENT (lame), lame->srcpad);
-
-  /* create an encoder state so we can ask about defaults */
-  lame->lgf = lame_init ();
-  if (lame->lgf == NULL)
-    goto init_error;
-
-  if (lame_init_params (lame->lgf) < 0)
-    goto init_error;
-
-  lame->samplerate = 44100;
-  lame->num_channels = 2;
-  lame->setup = FALSE;
-
-  lame->bitrate = 128;          /* lame_get_brate (lame->lgf);
-                                 * => 0/out of range */
-  lame->compression_ratio = 0.0;        /* lame_get_compression_ratio (lame->lgf);
-                                         * => 0/out of range ...
-                                         * NOTE: 0.0 makes bitrate take precedence */
-  lame->quality = 5;            /* lame_get_quality (lame->lgf);
-                                 * => -1/out of range */
-  lame->mode = lame_get_mode (lame->lgf);
+  /* Set default settings */
+  lame->bitrate = gst_lame_default_settings.bitrate;
+  lame->compression_ratio = gst_lame_default_settings.compression_ratio;
+  lame->quality = gst_lame_default_settings.quality;
+  lame->mode = gst_lame_default_settings.mode;
   lame->requested_mode = lame->mode;
-  lame->force_ms = lame_get_force_ms (lame->lgf);
-  lame->free_format = lame_get_free_format (lame->lgf);
-  lame->copyright = lame_get_copyright (lame->lgf);
-  lame->original = lame_get_original (lame->lgf);
-  lame->error_protection = lame_get_error_protection (lame->lgf);
-  lame->extension = lame_get_extension (lame->lgf);
-  lame->strict_iso = lame_get_strict_ISO (lame->lgf);
-  lame->disable_reservoir = lame_get_disable_reservoir (lame->lgf);
-  lame->vbr = vbr_off;          /* lame_get_VBR (lame->lgf); */
-  lame->vbr_quality = 5;
-#if 0
-  /* Replaced by our own more informative constants, 
-     rather than LAME's defaults */
-  lame->vbr_mean_bitrate = lame_get_VBR_mean_bitrate_kbps (lame->lgf);
-  lame->vbr_min_bitrate = lame_get_VBR_min_bitrate_kbps (lame->lgf);
-  lame->vbr_max_bitrate = 0;    /* lame_get_VBR_max_bitrate_kbps (lame->lgf);
-                                 * => 0/no vbr possible */
-#else
-  lame->vbr_mean_bitrate = DEFAULT_MEAN_VBR_BITRATE;
-  lame->vbr_min_bitrate = DEFAULT_MIN_VBR_BITRATE;
-  lame->vbr_max_bitrate = DEFAULT_MAX_VBR_BITRATE;
-#endif
-  lame->vbr_hard_min = lame_get_VBR_hard_min (lame->lgf);
-  /* lame->lowpass_freq = 50000;    lame_get_lowpassfreq (lame->lgf);
-   * => 0/lowpass on everything ? */
-  lame->lowpass_freq = 0;
-  lame->lowpass_width = 0;      /* lame_get_lowpasswidth (lame->lgf);
-                                 * => -1/out of range */
-  lame->highpass_freq = lame_get_highpassfreq (lame->lgf);
-  lame->highpass_width = 0;     /* lame_get_highpasswidth (lame->lgf);
-                                 * => -1/out of range */
-  lame->ath_only = lame_get_ATHonly (lame->lgf);
-  lame->ath_short = lame_get_ATHshort (lame->lgf);
-  lame->no_ath = lame_get_noATH (lame->lgf);
-  /*  lame->ath_type = lame_get_ATHtype (lame->lgf); */
-  lame->ath_lower = lame_get_ATHlower (lame->lgf);
-  lame->allow_diff_short = lame_get_allow_diff_short (lame->lgf);
-  lame->no_short_blocks = TRUE; /* lame_get_no_short_blocks (lame->lgf); */
-  lame->emphasis = lame_get_emphasis (lame->lgf);
-  lame->preset = 0;
-  lame_close (lame->lgf);
-  lame->lgf = NULL;
+  lame->force_ms = gst_lame_default_settings.force_ms;
+  lame->free_format = gst_lame_default_settings.free_format;
+  lame->copyright = gst_lame_default_settings.copyright;
+  lame->original = gst_lame_default_settings.original;
+  lame->error_protection = gst_lame_default_settings.error_protection;
+  lame->extension = gst_lame_default_settings.extension;
+  lame->strict_iso = gst_lame_default_settings.strict_iso;
+  lame->disable_reservoir = gst_lame_default_settings.disable_reservoir;
+  lame->vbr = gst_lame_default_settings.vbr;
+  lame->vbr_quality = gst_lame_default_settings.vbr_quality;
+  lame->vbr_mean_bitrate = gst_lame_default_settings.vbr_mean_bitrate;
+  lame->vbr_min_bitrate = gst_lame_default_settings.vbr_min_bitrate;
+  lame->vbr_max_bitrate = gst_lame_default_settings.vbr_max_bitrate;
+  lame->vbr_hard_min = gst_lame_default_settings.vbr_hard_min;
+  lame->lowpass_freq = gst_lame_default_settings.lowpass_freq;
+  lame->lowpass_width = gst_lame_default_settings.lowpass_width;
+  lame->highpass_freq = gst_lame_default_settings.highpass_freq;
+  lame->highpass_width = gst_lame_default_settings.highpass_width;
+  lame->ath_only = gst_lame_default_settings.ath_only;
+  lame->ath_short = gst_lame_default_settings.ath_short;
+  lame->no_ath = gst_lame_default_settings.no_ath;
+  lame->ath_lower = gst_lame_default_settings.ath_lower;
+  lame->allow_diff_short = gst_lame_default_settings.allow_diff_short;
+  lame->no_short_blocks = gst_lame_default_settings.no_short_blocks;
+  lame->emphasis = gst_lame_default_settings.emphasis;
+  lame->preset = gst_lame_default_settings.preset;
 
   GST_DEBUG_OBJECT (lame, "done initializing");
-  lame->init_error = FALSE;
-  return;
+}
 
-/* ERRORS */
-init_error:
-  {
-    GST_ERROR_OBJECT (lame, "error initializing");
-    lame->init_error = TRUE;
-    if (lame->lgf) {
-      lame_close (lame->lgf);
-      lame->lgf = NULL;
-    }
+static gboolean
+gst_lame_start (GstAudioEncoder * enc)
+{
+  GstLame *lame = GST_LAME (enc);
+
+  if (!lame->adapter)
+    lame->adapter = gst_adapter_new ();
+  gst_adapter_clear (lame->adapter);
+
+  GST_DEBUG_OBJECT (lame, "start");
+  return TRUE;
+}
+
+static gboolean
+gst_lame_stop (GstAudioEncoder * enc)
+{
+  GstLame *lame = GST_LAME (enc);
+
+  GST_DEBUG_OBJECT (lame, "stop");
+
+  if (lame->adapter) {
+    g_object_unref (lame->adapter);
+    lame->adapter = NULL;
   }
+
+  gst_lame_release_memory (lame);
+  return TRUE;
 }
 
+
 /* <php-emulation-mode>three underscores for ___rate is really really really
  * private as opposed to one underscore<php-emulation-mode> */
 /* call this MACRO outside of the NULL state so that we have a higher chance
@@ -690,7 +700,9 @@ G_STMT_START {                                                            \
   gint maxrate = 320;                                                    \
   gint multiplier = 64;                                                          \
   if (!free_format) {                                                     \
-    if (rate <= 64) {                                                    \
+    if (rate == 0) {                                                      \
+      ___rate = rate;                                                     \
+    } else if (rate <= 64) {                                             \
       maxrate = 64; multiplier = 8;                                       \
       if ((rate % 8) != 0) ___rate = GST_ROUND_UP_8 (rate);              \
     } else if (rate <= 128) {                                            \
@@ -942,108 +954,267 @@ gst_lame_get_property (GObject * object, guint prop_id, GValue * value,
   }
 }
 
-static gboolean
-gst_lame_sink_event (GstPad * pad, GstEvent * event)
-{
-  gboolean ret;
-  GstLame *lame;
+/* **** credits go to mpegaudioparse **** */
 
-  lame = GST_LAME (gst_pad_get_parent (pad));
+static const guint mp3types_bitrates[2][3][16] = {
+  {
+        {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},
+        {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},
+        {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}
+      },
+  {
+        {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},
+        {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},
+        {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}
+      },
+};
 
-  switch (GST_EVENT_TYPE (event)) {
-    case GST_EVENT_EOS:{
-      GST_DEBUG_OBJECT (lame, "handling EOS event");
+static const guint mp3types_freqs[3][3] = { {44100, 48000, 32000},
+{22050, 24000, 16000},
+{11025, 12000, 8000}
+};
 
-      if (lame->lgf != NULL) {
-        GstBuffer *buf;
-        gint size;
+static inline guint
+mp3_type_frame_length_from_header (GstLame * lame, guint32 header,
+    guint * put_version, guint * put_layer, guint * put_channels,
+    guint * put_bitrate, guint * put_samplerate, guint * put_mode,
+    guint * put_crc)
+{
+  guint length;
+  gulong mode, samplerate, bitrate, layer, channels, padding, crc;
+  gulong version;
+  gint lsf, mpg25;
+
+  if (header & (1 << 20)) {
+    lsf = (header & (1 << 19)) ? 0 : 1;
+    mpg25 = 0;
+  } else {
+    lsf = 1;
+    mpg25 = 1;
+  }
+
+  version = 1 + lsf + mpg25;
+
+  layer = 4 - ((header >> 17) & 0x3);
 
-        buf = gst_buffer_new_and_alloc (7200);
-        size = lame_encode_flush (lame->lgf, GST_BUFFER_DATA (buf), 7200);
+  crc = (header >> 16) & 0x1;
 
-        if (size > 0 && lame->last_flow == GST_FLOW_OK) {
-          gint64 duration;
+  bitrate = (header >> 12) & 0xF;
+  bitrate = mp3types_bitrates[lsf][layer - 1][bitrate] * 1000;
+  /* The caller has ensured we have a valid header, so bitrate can't be
+     zero here. */
+  g_assert (bitrate != 0);
 
-          duration = gst_util_uint64_scale (size, 8 * GST_SECOND,
-              1000 * lame->bitrate);
+  samplerate = (header >> 10) & 0x3;
+  samplerate = mp3types_freqs[lsf + mpg25][samplerate];
 
-          if (lame->last_ts == GST_CLOCK_TIME_NONE) {
-            lame->last_ts = lame->eos_ts;
-            lame->last_duration = duration;
-          } else {
-            lame->last_duration += duration;
-          }
+  padding = (header >> 9) & 0x1;
 
-          GST_BUFFER_TIMESTAMP (buf) = lame->last_ts;
-          GST_BUFFER_DURATION (buf) = lame->last_duration;
-          lame->last_ts = GST_CLOCK_TIME_NONE;
-          GST_BUFFER_SIZE (buf) = size;
-          GST_DEBUG_OBJECT (lame, "pushing final packet of %u bytes", size);
-          gst_buffer_set_caps (buf, GST_PAD_CAPS (lame->srcpad));
-          gst_pad_push (lame->srcpad, buf);
-        } else {
-          GST_DEBUG_OBJECT (lame, "no final packet (size=%d, last_flow=%s)",
-              size, gst_flow_get_name (lame->last_flow));
-          gst_buffer_unref (buf);
-        }
-      }
+  mode = (header >> 6) & 0x3;
+  channels = (mode == 3) ? 1 : 2;
 
-      ret = gst_pad_event_default (pad, event);
+  switch (layer) {
+    case 1:
+      length = 4 * ((bitrate * 12) / samplerate + padding);
       break;
-    }
-    case GST_EVENT_FLUSH_START:
-      GST_DEBUG_OBJECT (lame, "handling FLUSH start event");
-      /* forward event */
-      ret = gst_pad_push_event (lame->srcpad, event);
+    case 2:
+      length = (bitrate * 144) / samplerate + padding;
+      break;
+    default:
+    case 3:
+      length = (bitrate * 144) / (samplerate << lsf) + padding;
       break;
-    case GST_EVENT_FLUSH_STOP:
-    {
-      guchar *mp3_data = NULL;
-      gint mp3_buffer_size, mp3_size = 0;
+  }
 
-      GST_DEBUG_OBJECT (lame, "handling FLUSH stop event");
+  GST_DEBUG_OBJECT (lame, "Calculated mp3 frame length of %u bytes", length);
+  GST_DEBUG_OBJECT (lame, "samplerate = %lu, bitrate = %lu, version = %lu, "
+      "layer = %lu, channels = %lu", samplerate, bitrate, version,
+      layer, channels);
+
+  if (put_version)
+    *put_version = version;
+  if (put_layer)
+    *put_layer = layer;
+  if (put_channels)
+    *put_channels = channels;
+  if (put_bitrate)
+    *put_bitrate = bitrate;
+  if (put_samplerate)
+    *put_samplerate = samplerate;
+  if (put_mode)
+    *put_mode = mode;
+  if (put_crc)
+    *put_crc = crc;
+
+  return length;
+}
 
-      /* clear buffers */
-      mp3_buffer_size = 7200;
-      mp3_data = g_malloc (mp3_buffer_size);
-      mp3_size = lame_encode_flush (lame->lgf, mp3_data, mp3_buffer_size);
+static gboolean
+mp3_sync_check (GstLame * lame, unsigned long head)
+{
+  GST_DEBUG_OBJECT (lame, "checking mp3 header 0x%08lx", head);
+  /* if it's not a valid sync */
+  if ((head & 0xffe00000) != 0xffe00000) {
+    GST_WARNING_OBJECT (lame, "invalid sync");
+    return FALSE;
+  }
+  /* if it's an invalid MPEG version */
+  if (((head >> 19) & 3) == 0x1) {
+    GST_WARNING_OBJECT (lame, "invalid MPEG version: 0x%lx", (head >> 19) & 3);
+    return FALSE;
+  }
+  /* if it's an invalid layer */
+  if (!((head >> 17) & 3)) {
+    GST_WARNING_OBJECT (lame, "invalid layer: 0x%lx", (head >> 17) & 3);
+    return FALSE;
+  }
+  /* if it's an invalid bitrate */
+  if (((head >> 12) & 0xf) == 0x0) {
+    GST_WARNING_OBJECT (lame, "invalid bitrate: 0x%lx."
+        "Free format files are not supported yet", (head >> 12) & 0xf);
+    return FALSE;
+  }
+  if (((head >> 12) & 0xf) == 0xf) {
+    GST_WARNING_OBJECT (lame, "invalid bitrate: 0x%lx", (head >> 12) & 0xf);
+    return FALSE;
+  }
+  /* if it's an invalid samplerate */
+  if (((head >> 10) & 0x3) == 0x3) {
+    GST_WARNING_OBJECT (lame, "invalid samplerate: 0x%lx", (head >> 10) & 0x3);
+    return FALSE;
+  }
 
-      ret = gst_pad_push_event (lame->srcpad, event);
-      break;
+  if ((head & 0x3) == 0x2) {
+    /* Ignore this as there are some files with emphasis 0x2 that can
+     * be played fine. See BGO #537235 */
+    GST_WARNING_OBJECT (lame, "invalid emphasis: 0x%lx", head & 0x3);
+  }
+
+  return TRUE;
+}
+
+/* **** end mpegaudioparse **** */
+
+static GstFlowReturn
+gst_lame_finish_frames (GstLame * lame)
+{
+  gint av;
+  guint header;
+  GstFlowReturn result = GST_FLOW_OK;
+
+  /* limited parsing, we don't expect to lose sync here */
+  while ((result == GST_FLOW_OK) &&
+      ((av = gst_adapter_available (lame->adapter)) > 4)) {
+    guint rate, version, layer, size;
+    GstBuffer *mp3_buf;
+    const guint8 *data;
+
+    data = gst_adapter_peek (lame->adapter, 4);
+    header = GST_READ_UINT32_BE (data);
+    if (!mp3_sync_check (lame, header))
+      goto invalid_header;
+
+    size = mp3_type_frame_length_from_header (lame, header, &version, &layer,
+        NULL, NULL, &rate, NULL, NULL);
+
+    if (G_UNLIKELY (layer != 3 || rate != lame->out_samplerate)) {
+      GST_DEBUG_OBJECT (lame,
+          "unexpected mp3 header with rate %u, version %u, layer %u",
+          rate, version, layer);
+      goto invalid_header;
     }
-    case GST_EVENT_TAG:
-      GST_DEBUG_OBJECT (lame, "ignoring TAG event, passing it on");
-      ret = gst_pad_push_event (lame->srcpad, event);
-      break;
-    default:
-      ret = gst_pad_event_default (pad, event);
+
+    if (size > av) {
+      /* pretty likely to occur when lame is holding back on us */
+      GST_LOG_OBJECT (lame, "frame size %u (> %d)", size, av);
       break;
+    }
+
+    /* should be ok now */
+    mp3_buf = gst_adapter_take_buffer (lame->adapter, size);
+    /* number of samples for MPEG-1, layer 3 */
+    result = gst_audio_encoder_finish_frame (GST_AUDIO_ENCODER (lame),
+        mp3_buf, version == 1 ? 1152 : 576);
   }
-  gst_object_unref (lame);
-  return ret;
+
+exit:
+  return result;
+
+  /* ERRORS */
+invalid_header:
+  {
+    GST_ELEMENT_ERROR (lame, STREAM, ENCODE,
+        ("invalid lame mp3 sync header %08X", header), (NULL));
+    result = GST_FLOW_ERROR;
+    goto exit;
+  }
+}
+
+static GstFlowReturn
+gst_lame_flush_full (GstLame * lame, gboolean push)
+{
+  GstBuffer *buf;
+  gint size;
+  GstFlowReturn result = GST_FLOW_OK;
+  gint av;
+
+  if (!lame->lgf)
+    return GST_FLOW_OK;
+
+  buf = gst_buffer_new_and_alloc (7200);
+  size = lame_encode_flush (lame->lgf, GST_BUFFER_DATA (buf), 7200);
+
+  if (size > 0) {
+    GST_BUFFER_SIZE (buf) = size;
+    GST_DEBUG_OBJECT (lame, "collecting final %d bytes", size);
+    gst_adapter_push (lame->adapter, buf);
+  } else {
+    GST_DEBUG_OBJECT (lame, "no final packet (size=%d, push=%d)", size, push);
+    gst_buffer_unref (buf);
+    result = GST_FLOW_OK;
+  }
+
+  if (push) {
+    result = gst_lame_finish_frames (lame);
+  } else {
+    /* never mind */
+    gst_adapter_clear (lame->adapter);
+  }
+
+  /* either way, we expect nothing left */
+  if ((av = gst_adapter_available (lame->adapter))) {
+    /* should this be more fatal ?? */
+    GST_WARNING_OBJECT (lame, "unparsed %d bytes left after flushing", av);
+    /* clean up anyway */
+    gst_adapter_clear (lame->adapter);
+  }
+
+  return result;
+}
+
+static void
+gst_lame_flush (GstAudioEncoder * enc)
+{
+  gst_lame_flush_full (GST_LAME (enc), FALSE);
 }
 
 static GstFlowReturn
-gst_lame_chain (GstPad * pad, GstBuffer * buf)
+gst_lame_handle_frame (GstAudioEncoder * enc, GstBuffer * buf)
 {
   GstLame *lame;
   guchar *mp3_data;
+  GstBuffer *mp3_buf;
   gint mp3_buffer_size, mp3_size;
-  gint64 duration;
   GstFlowReturn result;
   gint num_samples;
   guint8 *data;
   guint size;
 
-  lame = GST_LAME (GST_PAD_PARENT (pad));
+  lame = GST_LAME (enc);
 
-  GST_LOG_OBJECT (lame, "entered chain");
-
-  if (lame->init_error)
-    goto init_error;
-
-  if (!lame->setup)
-    goto not_setup;
+  /* squeeze remaining and push */
+  if (G_UNLIKELY (buf == NULL))
+    return gst_lame_flush_full (lame, TRUE);
 
   data = GST_BUFFER_DATA (buf);
   size = GST_BUFFER_SIZE (buf);
@@ -1052,7 +1223,8 @@ gst_lame_chain (GstPad * pad, GstBuffer * buf)
 
   /* allocate space for output */
   mp3_buffer_size = 1.25 * num_samples + 7200;
-  mp3_data = g_malloc (mp3_buffer_size);
+  mp3_buf = gst_buffer_new_and_alloc (mp3_buffer_size);
+  mp3_data = GST_BUFFER_DATA (mp3_buf);
 
   /* lame seems to be too stupid to get mono interleaved going */
   if (lame->num_channels == 1) {
@@ -1068,75 +1240,26 @@ gst_lame_chain (GstPad * pad, GstBuffer * buf)
   GST_LOG_OBJECT (lame, "encoded %d bytes of audio to %d bytes of mp3",
       size, mp3_size);
 
-  duration = gst_util_uint64_scale_int (size, GST_SECOND,
-      2 * lame->samplerate * lame->num_channels);
-
-  if (GST_BUFFER_DURATION (buf) != GST_CLOCK_TIME_NONE &&
-      GST_BUFFER_DURATION (buf) != duration) {
-    GST_DEBUG_OBJECT (lame, "incoming buffer had incorrect duration %"
-        GST_TIME_FORMAT ", outgoing buffer will have correct duration %"
-        GST_TIME_FORMAT,
-        GST_TIME_ARGS (GST_BUFFER_DURATION (buf)), GST_TIME_ARGS (duration));
-  }
-
-  if (lame->last_ts == GST_CLOCK_TIME_NONE) {
-    lame->last_ts = GST_BUFFER_TIMESTAMP (buf);
-    lame->last_offs = GST_BUFFER_OFFSET (buf);
-    lame->last_duration = duration;
-  } else {
-    lame->last_duration += duration;
-  }
-
-  gst_buffer_unref (buf);
-
   if (mp3_size < 0) {
     g_warning ("error %d", mp3_size);
   }
 
-  if (mp3_size > 0) {
-    GstBuffer *outbuf;
-
-    outbuf = gst_buffer_new ();
-    GST_BUFFER_DATA (outbuf) = mp3_data;
-    GST_BUFFER_MALLOCDATA (outbuf) = mp3_data;
-    GST_BUFFER_SIZE (outbuf) = mp3_size;
-    GST_BUFFER_TIMESTAMP (outbuf) = lame->last_ts;
-    GST_BUFFER_OFFSET (outbuf) = lame->last_offs;
-    GST_BUFFER_DURATION (outbuf) = lame->last_duration;
-    gst_buffer_set_caps (outbuf, GST_PAD_CAPS (lame->srcpad));
-
-    result = gst_pad_push (lame->srcpad, outbuf);
-    lame->last_flow = result;
-    if (result != GST_FLOW_OK) {
-      GST_DEBUG_OBJECT (lame, "flow return: %s", gst_flow_get_name (result));
-    }
-
-    if (GST_CLOCK_TIME_IS_VALID (lame->last_ts))
-      lame->eos_ts = lame->last_ts + lame->last_duration;
-    else
-      lame->eos_ts = GST_CLOCK_TIME_NONE;
-    lame->last_ts = GST_CLOCK_TIME_NONE;
+  if (G_LIKELY (mp3_size > 0)) {
+    GST_BUFFER_SIZE (mp3_buf) = mp3_size;
+    /* unfortunately lame does not provide frame delineated output,
+     * so collect output and parse into frames ... */
+    gst_adapter_push (lame->adapter, mp3_buf);
+    result = gst_lame_finish_frames (lame);
   } else {
-    g_free (mp3_data);
+    if (mp3_size < 0) {
+      /* eat error ? */
+      g_warning ("error %d", mp3_size);
+    }
     result = GST_FLOW_OK;
+    gst_buffer_unref (mp3_buf);
   }
 
   return result;
-
-  /* ERRORS */
-not_setup:
-  {
-    gst_buffer_unref (buf);
-    GST_ELEMENT_ERROR (lame, CORE, NEGOTIATION, (NULL),
-        ("encoder not initialized (input is not audio?)"));
-    return GST_FLOW_ERROR;
-  }
-init_error:
-  {
-    gst_buffer_unref (buf);
-    GST_ELEMENT_ERROR (lame, LIBRARY, INIT, (NULL), (NULL));
-    return GST_FLOW_ERROR;
-  }
 }
 
 /* set up the encoder state */
@@ -1173,7 +1296,7 @@ gst_lame_setup (GstLame * lame)
   lame_set_in_samplerate (lame->lgf, lame->samplerate);
 
   /* let lame choose default samplerate unless outgoing sample rate is fixed */
-  allowed_caps = gst_pad_get_allowed_caps (lame->srcpad);
+  allowed_caps = gst_pad_get_allowed_caps (GST_AUDIO_ENCODER_SRC_PAD (lame));
 
   if (allowed_caps != NULL) {
     GstStructure *structure;
@@ -1263,56 +1386,73 @@ gst_lame_setup (GstLame * lame)
 #undef CHECK_ERROR
 }
 
-static GstStateChangeReturn
-gst_lame_change_state (GstElement * element, GstStateChange transition)
+static gboolean
+gst_lame_get_default_settings (void)
 {
-  GstLame *lame;
-  GstStateChangeReturn result;
-
-  lame = GST_LAME (element);
+  lame_global_flags *lgf = NULL;
 
-  switch (transition) {
-    case GST_STATE_CHANGE_READY_TO_PAUSED:
-      lame->last_flow = GST_FLOW_OK;
-      lame->last_ts = GST_CLOCK_TIME_NONE;
-      lame->eos_ts = GST_CLOCK_TIME_NONE;
-      break;
-    default:
-      break;
+  lgf = lame_init ();
+  if (lgf == NULL) {
+    GST_ERROR ("Error initializing LAME");
+    return FALSE;
   }
 
-  result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
-
-  switch (transition) {
-    case GST_STATE_CHANGE_READY_TO_NULL:
-      gst_lame_release_memory (lame);
-      break;
-    default:
-      break;
+  if (lame_init_params (lgf) < 0) {
+    GST_ERROR ("Error getting default settings");
+    return FALSE;
   }
 
-  return result;
+  gst_lame_default_settings.bitrate = lame_get_brate (lgf);
+  gst_lame_default_settings.compression_ratio = 0.0;    /* lame_get_compression_ratio (lgf); */
+  gst_lame_default_settings.quality = lame_get_quality (lgf);
+  gst_lame_default_settings.mode = lame_get_mode (lgf);
+  gst_lame_default_settings.force_ms = lame_get_force_ms (lgf);
+  gst_lame_default_settings.free_format = lame_get_free_format (lgf);
+  gst_lame_default_settings.copyright = lame_get_copyright (lgf);
+  gst_lame_default_settings.original = lame_get_original (lgf);
+  gst_lame_default_settings.error_protection = lame_get_error_protection (lgf);
+  gst_lame_default_settings.extension = lame_get_extension (lgf);
+  gst_lame_default_settings.strict_iso = lame_get_strict_ISO (lgf);
+  gst_lame_default_settings.disable_reservoir =
+      lame_get_disable_reservoir (lgf);
+  gst_lame_default_settings.vbr = lame_get_VBR (lgf);
+  gst_lame_default_settings.vbr_quality = lame_get_VBR_q (lgf);
+  gst_lame_default_settings.vbr_mean_bitrate =
+      lame_get_VBR_mean_bitrate_kbps (lgf);
+  gst_lame_default_settings.vbr_min_bitrate =
+      lame_get_VBR_min_bitrate_kbps (lgf);
+  gst_lame_default_settings.vbr_max_bitrate =
+      lame_get_VBR_max_bitrate_kbps (lgf);
+  gst_lame_default_settings.vbr_hard_min = lame_get_VBR_hard_min (lgf);
+  gst_lame_default_settings.lowpass_freq = lame_get_lowpassfreq (lgf);
+  gst_lame_default_settings.lowpass_width = lame_get_lowpasswidth (lgf);
+  gst_lame_default_settings.highpass_freq = lame_get_highpassfreq (lgf);
+  gst_lame_default_settings.highpass_width = lame_get_highpasswidth (lgf);
+  gst_lame_default_settings.ath_only = lame_get_ATHonly (lgf);
+  gst_lame_default_settings.ath_short = lame_get_ATHshort (lgf);
+  gst_lame_default_settings.no_ath = lame_get_noATH (lgf);
+  gst_lame_default_settings.ath_type = lame_get_ATHtype (lgf);
+  gst_lame_default_settings.ath_lower = lame_get_ATHlower (lgf);
+  gst_lame_default_settings.allow_diff_short = lame_get_allow_diff_short (lgf);
+  gst_lame_default_settings.no_short_blocks = lame_get_no_short_blocks (lgf);
+  gst_lame_default_settings.emphasis = lame_get_emphasis (lgf);
+  gst_lame_default_settings.preset = 0;
+
+  lame_close (lgf);
+
+  return TRUE;
 }
 
-static gboolean
-plugin_init (GstPlugin * plugin)
+gboolean
+gst_lame_register (GstPlugin * plugin)
 {
   GST_DEBUG_CATEGORY_INIT (debug, "lame", 0, "lame mp3 encoder");
 
-#ifdef ENABLE_NLS
-  GST_DEBUG ("binding text domain %s to locale dir %s", GETTEXT_PACKAGE,
-      LOCALEDIR);
-  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
-#endif /* ENABLE_NLS */
+  if (!gst_lame_get_default_settings ())
+    return FALSE;
 
-  if (!gst_element_register (plugin, "lame", GST_RANK_NONE, GST_TYPE_LAME))
+  if (!gst_element_register (plugin, "lame", GST_RANK_MARGINAL, GST_TYPE_LAME))
     return FALSE;
 
   return TRUE;
 }
-
-GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
-    GST_VERSION_MINOR,
-    "lame",
-    "Encode MP3s with LAME",
-    plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);