From 27c557c9885903b72e454dd72458dcffe680575f Mon Sep 17 00:00:00 2001 From: =?utf8?q?Sebastian=20Dr=C3=B6ge?= Date: Wed, 29 Apr 2009 19:01:44 +0200 Subject: [PATCH] lame: Add lamemp3enc element with much simplified interface This deprecates the lame element and fixes bug #494528. --- ext/lame/Makefile.am | 4 +- ext/lame/gstlame.c | 25 +- ext/lame/gstlamemp3enc.c | 856 +++++++++++++++++++++++++++++++++++++++++++++++ ext/lame/gstlamemp3enc.h | 91 +++++ ext/lame/plugin.c | 48 +++ 5 files changed, 1006 insertions(+), 18 deletions(-) create mode 100644 ext/lame/gstlamemp3enc.c create mode 100644 ext/lame/gstlamemp3enc.h create mode 100644 ext/lame/plugin.c diff --git a/ext/lame/Makefile.am b/ext/lame/Makefile.am index cf0a4e7..c74bff1 100644 --- a/ext/lame/Makefile.am +++ b/ext/lame/Makefile.am @@ -1,9 +1,9 @@ plugin_LTLIBRARIES = libgstlame.la -libgstlame_la_SOURCES = gstlame.c +libgstlame_la_SOURCES = gstlame.c gstlamemp3enc.c plugin.c libgstlame_la_CFLAGS = $(GST_CFLAGS) $(LAME_CFLAGS) libgstlame_la_LIBADD = $(LAME_LIBS) $(GST_LIBS) libgstlame_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) libgstlame_la_LIBTOOLFLAGS = --tag=disable-static -noinst_HEADERS = gstlame.h +noinst_HEADERS = gstlame.h gstlamemp3enc.h diff --git a/ext/lame/gstlame.c b/ext/lame/gstlame.c index d83bbcf..7bb1f5c 100644 --- a/ext/lame/gstlame.c +++ b/ext/lame/gstlame.c @@ -21,7 +21,7 @@ /** * SECTION:element-lame - * @see_also: mad, vorbisenc + * @see_also: lamemp3enc, mad, vorbisenc * * This element encodes raw integer audio into an MPEG-1 layer 3 (MP3) stream. * Note that MP3 is not @@ -30,6 +30,12 @@ * for a royalty free (and often higher quality) alternative. * * + * Note + * This element is deprecated, use the lamemp3enc element instead + * which provides a much simpler interface and results in better MP3 files. + * + * + * * Output sample rate * 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. @@ -1352,29 +1358,16 @@ gst_lame_get_default_settings (void) return TRUE; } -static gboolean -plugin_init (GstPlugin * plugin) +gboolean +gst_lame_register (GstPlugin * plugin) { GST_DEBUG_CATEGORY_INIT (debug, "lame", 0, "lame mp3 encoder"); if (!gst_lame_get_default_settings ()) return FALSE; -#ifdef ENABLE_NLS - GST_DEBUG ("binding text domain %s to locale dir %s", GETTEXT_PACKAGE, - LOCALEDIR); - bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); - bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); -#endif /* ENABLE_NLS */ - if (!gst_element_register (plugin, "lame", GST_RANK_NONE, 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); diff --git a/ext/lame/gstlamemp3enc.c b/ext/lame/gstlamemp3enc.c new file mode 100644 index 0000000..f1ddc87 --- /dev/null +++ b/ext/lame/gstlamemp3enc.c @@ -0,0 +1,856 @@ +/* GStreamer + * Copyright (C) <1999> Erik Walthinsen + * Copyright (C) <2004> Wim Taymans + * Copyright (C) <2005> Thomas Vander Stichele + * Copyright (C) <2009> Sebastian Dröge + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +/** + * SECTION:element-lamemp3enc + * @see_also: lame, mad, vorbisenc + * + * This element encodes raw integer audio into an MPEG-1 layer 3 (MP3) stream. + * Note that MP3 is not + * a free format, there are licensing and patent issues to take into + * consideration. See Ogg/Vorbis + * for a royalty free (and often higher quality) alternative. + * + * + * Output sample rate + * 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. + * For example, a 16-bit 44.1 KHz mono audio stream encoded at 48 kbit will + * get resampled to 32 KHz. Use filter caps on the src pad to force a + * particular sample rate. + * + * + * Example pipelines + * |[ + * gst-launch -v audiotestsrc wave=sine num-buffers=100 ! audioconvert ! lamemp3enc ! filesink location=sine.mp3 + * ]| Encode a test sine signal to MP3. + * |[ + * gst-launch -v alsasrc ! audioconvert ! lamemp3enc bitrate=192 ! filesink location=alsasrc.mp3 + * ]| Record from a sound card using ALSA and encode to MP3 + * |[ + * gst-launch -v filesrc location=music.wav ! decodebin ! audioconvert ! audioresample ! lamemp3enc bitrate=192 ! id3v2mux ! filesink location=music.mp3 + * ]| Transcode from a .wav file to MP3 (the id3v2mux element is optional) + * |[ + * gst-launch -v cdda://5 ! audioconvert ! lamemp3enc bitrate=192 ! filesink location=track5.mp3 + * ]| Encode Audio CD track 5 to MP3 + * |[ + * gst-launch -v audiotestsrc num-buffers=10 ! audio/x-raw-int,rate=44100,channels=1 ! lamemp3enc bitrate=48 ! filesink location=test.mp3 + * ]| Encode to a fixed sample rate + * + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include "gstlamemp3enc.h" +#include + +GST_DEBUG_CATEGORY_STATIC (debug); +#define GST_CAT_DEFAULT debug + +/* elementfactory information */ + +/* LAMEMP3ENC can do MPEG-1, MPEG-2, and MPEG-2.5, so it has 9 possible + * sample rates it supports */ +static GstStaticPadTemplate gst_lamemp3enc_sink_template = +GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("audio/x-raw-int, " + "endianness = (int) " G_STRINGIFY (G_BYTE_ORDER) ", " + "signed = (boolean) true, " + "width = (int) 16, " + "depth = (int) 16, " + "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, " + "channels = (int) [ 1, 2 ]") + ); + +static GstStaticPadTemplate gst_lamemp3enc_src_template = +GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("audio/mpeg, " + "mpegversion = (int) 1, " + "layer = (int) 3, " + "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, " + "channels = (int) [ 1, 2 ]") + ); + +/********** Define useful types for non-programmatic interfaces **********/ +enum +{ + LAMEMP3ENC_TARGET_QUALITY = 0, + LAMEMP3ENC_TARGET_BITRATE +}; + +#define GST_TYPE_LAMEMP3ENC_TARGET (gst_lamemp3enc_target_get_type()) +static GType +gst_lamemp3enc_target_get_type (void) +{ + static GType lame_target_type = 0; + static GEnumValue lame_targets[] = { + {LAMEMP3ENC_TARGET_QUALITY, "Quality", "quality"}, + {LAMEMP3ENC_TARGET_BITRATE, "Bitrate", "bitrate"}, + {0, NULL, NULL} + }; + + if (!lame_target_type) { + lame_target_type = + g_enum_register_static ("GstLameMP3EncTarget", lame_targets); + } + return lame_target_type; +} + +enum +{ + LAMEMP3ENC_ENCODING_ENGINE_QUALITY_FAST = 0, + LAMEMP3ENC_ENCODING_ENGINE_QUALITY_STANDARD, + LAMEMP3ENC_ENCODING_ENGINE_QUALITY_HIGH +}; + +#define GST_TYPE_LAMEMP3ENC_ENCODING_ENGINE_QUALITY (gst_lamemp3enc_encoding_engine_quality_get_type()) +static GType +gst_lamemp3enc_encoding_engine_quality_get_type (void) +{ + static GType lame_encoding_engine_quality_type = 0; + static GEnumValue lame_encoding_engine_quality[] = { + {0, "Fast", "fast"}, + {1, "Standard", "standard"}, + {2, "High", "high"}, + {0, NULL, NULL} + }; + + if (!lame_encoding_engine_quality_type) { + lame_encoding_engine_quality_type = + g_enum_register_static ("GstLameMP3EncEncodingEngineQuality", + lame_encoding_engine_quality); + } + return lame_encoding_engine_quality_type; +} + +/********** Standard stuff for signals and arguments **********/ + +enum +{ + ARG_0, + ARG_TARGET, + ARG_BITRATE, + ARG_CBR, + ARG_VBR_QUALITY, + ARG_FAST_VBR, + ARG_ENCODING_ENGINE_QUALITY, + ARG_MONO +}; + +#define DEFAULT_TARGET LAMEMP3ENC_TARGET_QUALITY +#define DEFAULT_BITRATE 128 +#define DEFAULT_CBR FALSE +#define DEFAULT_VBR_QUALITY 4 +#define DEFAULT_FAST_VBR FALSE +#define DEFAULT_ENCODING_ENGINE_QUALITY LAMEMP3ENC_ENCODING_ENGINE_QUALITY_STANDARD +#define DEFAULT_MONO FALSE + +static void gst_lamemp3enc_base_init (gpointer g_class); +static void gst_lamemp3enc_class_init (GstLameMP3EncClass * klass); +static void gst_lamemp3enc_init (GstLameMP3Enc * gst_lame); + +static void gst_lamemp3enc_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_lamemp3enc_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); +static gboolean gst_lamemp3enc_sink_event (GstPad * pad, GstEvent * event); +static GstFlowReturn gst_lamemp3enc_chain (GstPad * pad, GstBuffer * buf); +static gboolean gst_lamemp3enc_setup (GstLameMP3Enc * lame); +static GstStateChangeReturn gst_lamemp3enc_change_state (GstElement * element, + GstStateChange transition); + +static GstElementClass *parent_class = NULL; + +GType +gst_lamemp3enc_get_type (void) +{ + static GType gst_lamemp3enc_type = 0; + + if (!gst_lamemp3enc_type) { + static const GTypeInfo gst_lamemp3enc_info = { + sizeof (GstLameMP3EncClass), + gst_lamemp3enc_base_init, + NULL, + (GClassInitFunc) gst_lamemp3enc_class_init, + NULL, + NULL, + sizeof (GstLameMP3Enc), + 0, + (GInstanceInitFunc) gst_lamemp3enc_init, + }; + + gst_lamemp3enc_type = + g_type_register_static (GST_TYPE_ELEMENT, "GstLameMP3Enc", + &gst_lamemp3enc_info, 0); + } + return gst_lamemp3enc_type; +} + +static void +gst_lamemp3enc_release_memory (GstLameMP3Enc * lame) +{ + if (lame->lgf) { + lame_close (lame->lgf); + lame->lgf = NULL; + } +} + +static void +gst_lamemp3enc_finalize (GObject * obj) +{ + gst_lamemp3enc_release_memory (GST_LAMEMP3ENC (obj)); + + G_OBJECT_CLASS (parent_class)->finalize (obj); +} + +static void +gst_lamemp3enc_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_lamemp3enc_src_template)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&gst_lamemp3enc_sink_template)); + gst_element_class_set_details_simple (element_class, "L.A.M.E. mp3 encoder", + "Codec/Encoder/Audio", + "High-quality free MP3 encoder", + "Sebastian Dröge "); +} + +static void +gst_lamemp3enc_class_init (GstLameMP3EncClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *gstelement_class; + + gobject_class = (GObjectClass *) klass; + gstelement_class = (GstElementClass *) klass; + + parent_class = g_type_class_peek_parent (klass); + + gobject_class->set_property = gst_lamemp3enc_set_property; + gobject_class->get_property = gst_lamemp3enc_get_property; + gobject_class->finalize = gst_lamemp3enc_finalize; + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TARGET, + g_param_spec_enum ("target", "Target", + "Optimize for quality or bitrate", GST_TYPE_LAMEMP3ENC_TARGET, + DEFAULT_TARGET, G_PARAM_READWRITE)); + 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, DEFAULT_BITRATE, G_PARAM_READWRITE)); + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_CBR, + g_param_spec_boolean ("cbr", "CBR", "Enforce constant bitrate encoding", + DEFAULT_CBR, G_PARAM_READWRITE)); + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VBR_QUALITY, + g_param_spec_float ("vbr-quality", "VBR Quality", + "VBR Quality from 0 to 10, 0 being the best", 0.0, 9.999, + DEFAULT_VBR_QUALITY, G_PARAM_READWRITE)); + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FAST_VBR, + g_param_spec_boolean ("fast-vbr", "Fast VBR", "Use fast VBR encoding", + DEFAULT_FAST_VBR, G_PARAM_READWRITE)); + g_object_class_install_property (G_OBJECT_CLASS (klass), + ARG_ENCODING_ENGINE_QUALITY, g_param_spec_enum ("encoding-engine-quality", + "Encoding Engine Quality", "Quality/speed of the encoding engine", + GST_TYPE_LAMEMP3ENC_ENCODING_ENGINE_QUALITY, + DEFAULT_ENCODING_ENGINE_QUALITY, G_PARAM_READWRITE)); + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MONO, + g_param_spec_boolean ("mono", "Mono", "Enforce mono encoding", + DEFAULT_MONO, G_PARAM_READWRITE)); + + gstelement_class->change_state = + GST_DEBUG_FUNCPTR (gst_lamemp3enc_change_state); +} + +static gboolean +gst_lamemp3enc_src_setcaps (GstPad * pad, GstCaps * caps) +{ + GST_DEBUG_OBJECT (pad, "caps: %" GST_PTR_FORMAT, caps); + return TRUE; +} + +static gboolean +gst_lamemp3enc_sink_setcaps (GstPad * pad, GstCaps * caps) +{ + GstLameMP3Enc *lame; + gint out_samplerate; + gint version; + GstStructure *structure; + GstCaps *othercaps; + + lame = GST_LAMEMP3ENC (GST_PAD_PARENT (pad)); + structure = gst_caps_get_structure (caps, 0); + + 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; + + GST_DEBUG_OBJECT (lame, "setting up lame"); + if (!gst_lamemp3enc_setup (lame)) + goto setup_failed; + + + out_samplerate = lame_get_out_samplerate (lame->lgf); + if (out_samplerate == 0) + goto zero_output_rate; + if (out_samplerate != lame->samplerate) { + GST_WARNING_OBJECT (lame, + "output samplerate %d is different from incoming samplerate %d", + out_samplerate, lame->samplerate); + } + + version = lame_get_version (lame->lgf); + if (version == 0) + version = 2; + else if (version == 1) + version = 1; + else if (version == 2) + version = 3; + + othercaps = + gst_caps_new_simple ("audio/mpeg", + "mpegversion", G_TYPE_INT, 1, + "mpegaudioversion", G_TYPE_INT, version, + "layer", G_TYPE_INT, 3, + "channels", G_TYPE_INT, lame->mono ? 1 : lame->num_channels, + "rate", G_TYPE_INT, out_samplerate, NULL); + + /* and use these caps */ + gst_pad_set_caps (lame->srcpad, othercaps); + gst_caps_unref (othercaps); + + 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), + ("LAMEMP3ENC decided on a zero sample rate")); + return FALSE; + } +setup_failed: + { + GST_ELEMENT_ERROR (lame, LIBRARY, SETTINGS, + (_("Failed to configure LAMEMP3ENC encoder. Check your encoding parameters.")), (NULL)); + return FALSE; + } +} + +static void +gst_lamemp3enc_init (GstLameMP3Enc * lame) +{ + GST_DEBUG_OBJECT (lame, "starting initialization"); + + lame->sinkpad = + gst_pad_new_from_static_template (&gst_lamemp3enc_sink_template, "sink"); + gst_pad_set_event_function (lame->sinkpad, + GST_DEBUG_FUNCPTR (gst_lamemp3enc_sink_event)); + gst_pad_set_chain_function (lame->sinkpad, + GST_DEBUG_FUNCPTR (gst_lamemp3enc_chain)); + gst_pad_set_setcaps_function (lame->sinkpad, + GST_DEBUG_FUNCPTR (gst_lamemp3enc_sink_setcaps)); + gst_element_add_pad (GST_ELEMENT (lame), lame->sinkpad); + + lame->srcpad = + gst_pad_new_from_static_template (&gst_lamemp3enc_src_template, "src"); + gst_pad_set_setcaps_function (lame->srcpad, + GST_DEBUG_FUNCPTR (gst_lamemp3enc_src_setcaps)); + gst_element_add_pad (GST_ELEMENT (lame), lame->srcpad); + + lame->samplerate = 44100; + lame->num_channels = 2; + lame->setup = FALSE; + + /* Set default settings */ + lame->target = DEFAULT_TARGET; + lame->bitrate = DEFAULT_BITRATE; + lame->cbr = DEFAULT_CBR; + lame->vbr_quality = DEFAULT_VBR_QUALITY; + lame->fast_vbr = DEFAULT_FAST_VBR; + lame->encoding_engine_quality = DEFAULT_ENCODING_ENGINE_QUALITY; + lame->mono = DEFAULT_MONO; + + GST_DEBUG_OBJECT (lame, "done initializing"); +} + +/* three underscores for ___rate is really really really + * private as opposed to one underscore */ +/* call this MACRO outside of the NULL state so that we have a higher chance + * of actually having a pipeline and bus to get the message through */ + +#define CHECK_AND_FIXUP_BITRATE(obj,param,rate) \ +G_STMT_START { \ + gint ___rate = rate; \ + gint maxrate = 320; \ + gint multiplier = 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) { \ + maxrate = 128; multiplier = 16; \ + if ((rate % 16) != 0) ___rate = GST_ROUND_UP_16 (rate); \ + } else if (rate <= 256) { \ + maxrate = 256; multiplier = 32; \ + if ((rate % 32) != 0) ___rate = GST_ROUND_UP_32 (rate); \ + } else if (rate <= 320) { \ + maxrate = 320; multiplier = 64; \ + if ((rate % 64) != 0) ___rate = GST_ROUND_UP_64 (rate); \ + } \ + if (___rate != rate) { \ + GST_ELEMENT_WARNING (obj, LIBRARY, SETTINGS, \ + (_("The requested bitrate %d kbit/s for property '%s' " \ + "is not allowed. " \ + "The bitrate was changed to %d kbit/s."), rate, \ + param, ___rate), \ + ("A bitrate below %d should be a multiple of %d.", \ + maxrate, multiplier)); \ + rate = ___rate; \ + } \ +} G_STMT_END + +static void +gst_lamemp3enc_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstLameMP3Enc *lame; + + lame = GST_LAMEMP3ENC (object); + + switch (prop_id) { + case ARG_TARGET: + lame->target = g_value_get_enum (value); + break; + case ARG_BITRATE: + lame->bitrate = g_value_get_int (value); + break; + case ARG_CBR: + lame->cbr = g_value_get_boolean (value); + break; + case ARG_VBR_QUALITY: + lame->vbr_quality = g_value_get_float (value); + break; + case ARG_FAST_VBR: + lame->fast_vbr = g_value_get_boolean (value); + break; + case ARG_ENCODING_ENGINE_QUALITY: + lame->encoding_engine_quality = g_value_get_enum (value); + break; + case ARG_MONO: + lame->mono = g_value_get_boolean (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_lamemp3enc_get_property (GObject * object, guint prop_id, GValue * value, + GParamSpec * pspec) +{ + GstLameMP3Enc *lame; + + lame = GST_LAMEMP3ENC (object); + + switch (prop_id) { + case ARG_TARGET: + g_value_set_enum (value, lame->target); + break; + case ARG_BITRATE: + g_value_set_int (value, lame->bitrate); + break; + case ARG_CBR: + g_value_set_boolean (value, lame->cbr); + break; + case ARG_VBR_QUALITY: + g_value_set_float (value, lame->vbr_quality); + break; + case ARG_FAST_VBR: + g_value_set_boolean (value, lame->fast_vbr); + break; + case ARG_ENCODING_ENGINE_QUALITY: + g_value_set_enum (value, lame->encoding_engine_quality); + break; + case ARG_MONO: + g_value_set_boolean (value, lame->mono); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static gboolean +gst_lamemp3enc_sink_event (GstPad * pad, GstEvent * event) +{ + gboolean ret; + GstLameMP3Enc *lame; + + lame = GST_LAMEMP3ENC (gst_pad_get_parent (pad)); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_EOS:{ + GST_DEBUG_OBJECT (lame, "handling EOS event"); + + if (lame->lgf != NULL) { + GstBuffer *buf; + gint size; + + buf = gst_buffer_new_and_alloc (7200); + size = lame_encode_flush (lame->lgf, GST_BUFFER_DATA (buf), 7200); + + if (size > 0 && lame->last_flow == GST_FLOW_OK) { + gint64 duration; + + duration = gst_util_uint64_scale (size, 8 * GST_SECOND, + 1000 * lame->bitrate); + + if (lame->last_ts == GST_CLOCK_TIME_NONE) { + lame->last_ts = lame->eos_ts; + lame->last_duration = duration; + } else { + lame->last_duration += duration; + } + + 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); + } + } + + ret = gst_pad_event_default (pad, event); + break; + } + case GST_EVENT_FLUSH_START: + GST_DEBUG_OBJECT (lame, "handling FLUSH start event"); + /* forward event */ + ret = gst_pad_push_event (lame->srcpad, event); + break; + case GST_EVENT_FLUSH_STOP: + { + guchar *mp3_data = NULL; + gint mp3_buffer_size; + + GST_DEBUG_OBJECT (lame, "handling FLUSH stop event"); + + /* clear buffers */ + mp3_buffer_size = 7200; + mp3_data = g_malloc (mp3_buffer_size); + lame_encode_flush (lame->lgf, mp3_data, mp3_buffer_size); + + ret = gst_pad_push_event (lame->srcpad, event); + break; + } + 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); + break; + } + gst_object_unref (lame); + return ret; +} + +static GstFlowReturn +gst_lamemp3enc_chain (GstPad * pad, GstBuffer * buf) +{ + GstLameMP3Enc *lame; + guchar *mp3_data; + gint mp3_buffer_size, mp3_size; + gint64 duration; + GstFlowReturn result; + gint num_samples; + guint8 *data; + guint size; + + lame = GST_LAMEMP3ENC (GST_PAD_PARENT (pad)); + + GST_LOG_OBJECT (lame, "entered chain"); + + if (!lame->setup) + goto not_setup; + + data = GST_BUFFER_DATA (buf); + size = GST_BUFFER_SIZE (buf); + + num_samples = size / 2; + + /* allocate space for output */ + mp3_buffer_size = 1.25 * num_samples + 7200; + mp3_data = g_malloc (mp3_buffer_size); + + /* lame seems to be too stupid to get mono interleaved going */ + if (lame->num_channels == 1) { + mp3_size = lame_encode_buffer (lame->lgf, + (short int *) data, + (short int *) data, num_samples, mp3_data, mp3_buffer_size); + } else { + mp3_size = lame_encode_buffer_interleaved (lame->lgf, + (short int *) data, + num_samples / lame->num_channels, mp3_data, mp3_buffer_size); + } + + 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; + } else { + g_free (mp3_data); + result = GST_FLOW_OK; + } + + 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; + } +} + +/* set up the encoder state */ +static gboolean +gst_lamemp3enc_setup (GstLameMP3Enc * lame) +{ + +#define CHECK_ERROR(command) G_STMT_START {\ + if ((command) < 0) { \ + GST_ERROR_OBJECT (lame, "setup failed: " G_STRINGIFY (command)); \ + return FALSE; \ + } \ +}G_STMT_END + + int retval; + GstCaps *allowed_caps; + + GST_DEBUG_OBJECT (lame, "starting setup"); + + /* check if we're already setup; if we are, we might want to check + * if this initialization is compatible with the previous one */ + /* FIXME: do this */ + if (lame->setup) { + GST_WARNING_OBJECT (lame, "already setup"); + lame->setup = FALSE; + } + + lame->lgf = lame_init (); + + if (lame->lgf == NULL) + return FALSE; + + /* copy the parameters over */ + 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); + + if (allowed_caps != NULL) { + GstStructure *structure; + gint samplerate; + + structure = gst_caps_get_structure (allowed_caps, 0); + + if (gst_structure_get_int (structure, "rate", &samplerate)) { + GST_DEBUG_OBJECT (lame, "Setting sample rate to %d as fixed in src caps", + samplerate); + lame_set_out_samplerate (lame->lgf, samplerate); + } else { + GST_DEBUG_OBJECT (lame, "Letting lame choose sample rate"); + lame_set_out_samplerate (lame->lgf, 0); + } + gst_caps_unref (allowed_caps); + allowed_caps = NULL; + } else { + GST_DEBUG_OBJECT (lame, "No peer yet, letting lame choose sample rate"); + lame_set_out_samplerate (lame->lgf, 0); + } + + CHECK_ERROR (lame_set_num_channels (lame->lgf, lame->num_channels)); + + if (lame->target == LAMEMP3ENC_TARGET_QUALITY) { + if (lame->fast_vbr) + CHECK_ERROR (lame_set_VBR (lame->lgf, vbr_rh)); + else + CHECK_ERROR (lame_set_VBR (lame->lgf, vbr_mtrh)); + CHECK_ERROR (lame_set_VBR_quality (lame->lgf, lame->vbr_quality)); + } else { + CHECK_AND_FIXUP_BITRATE (lame, "bitrate", lame->bitrate); + if (lame->cbr) { + CHECK_ERROR (lame_set_VBR (lame->lgf, vbr_off)); + CHECK_ERROR (lame_set_brate (lame->lgf, lame->bitrate)); + } else { + CHECK_ERROR (lame_set_VBR (lame->lgf, vbr_abr)); + CHECK_ERROR (lame_set_VBR_mean_bitrate_kbps (lame->lgf, lame->bitrate)); + } + } + + if (lame->encoding_engine_quality == LAMEMP3ENC_ENCODING_ENGINE_QUALITY_FAST) + CHECK_ERROR (lame_set_quality (lame->lgf, 7)); + else if (lame->encoding_engine_quality == + LAMEMP3ENC_ENCODING_ENGINE_QUALITY_HIGH) + CHECK_ERROR (lame_set_quality (lame->lgf, 2)); + /* else default */ + + if (lame->mono) + CHECK_ERROR (lame_set_mode (lame->lgf, MONO)); + + /* initialize the lame encoder */ + if ((retval = lame_init_params (lame->lgf)) >= 0) { + lame->setup = TRUE; + /* FIXME: it would be nice to print out the mode here */ + GST_INFO ("lame encoder setup (%d Hz, %d channels)", + lame->bitrate, lame->samplerate, lame->num_channels); + } else { + GST_ERROR_OBJECT (lame, "lame_init_params returned %d", retval); + } + + GST_DEBUG_OBJECT (lame, "done with setup"); + + return lame->setup; +#undef CHECK_ERROR +} + +static GstStateChangeReturn +gst_lamemp3enc_change_state (GstElement * element, GstStateChange transition) +{ + GstLameMP3Enc *lame; + GstStateChangeReturn result; + + lame = GST_LAMEMP3ENC (element); + + 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; + } + + result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + + switch (transition) { + case GST_STATE_CHANGE_READY_TO_NULL: + gst_lamemp3enc_release_memory (lame); + break; + default: + break; + } + + return result; +} + +gboolean +gst_lamemp3enc_register (GstPlugin * plugin) +{ + GST_DEBUG_CATEGORY_INIT (debug, "lamemp3enc", 0, "lame mp3 encoder"); + + if (!gst_element_register (plugin, "lamemp3enc", GST_RANK_NONE, + GST_TYPE_LAMEMP3ENC)) + return FALSE; + + return TRUE; +} diff --git a/ext/lame/gstlamemp3enc.h b/ext/lame/gstlamemp3enc.h new file mode 100644 index 0000000..53362aa --- /dev/null +++ b/ext/lame/gstlamemp3enc.h @@ -0,0 +1,91 @@ +/* GStreamer + * Copyright (C) <1999> Erik Walthinsen + * Copyright (C) <2009> Sebastian Dröge + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + + +#ifndef __GST_LAMEMP3ENC_H__ +#define __GST_LAMEMP3ENC_H__ + + +#include + +G_BEGIN_DECLS + +#include + +#define GST_TYPE_LAMEMP3ENC \ + (gst_lamemp3enc_get_type()) +#define GST_LAMEMP3ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_LAMEMP3ENC,GstLameMP3Enc)) +#define GST_LAMEMP3ENC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_LAMEMP3ENC,GstLameMP3EncClass)) +#define GST_IS_LAMEMP3ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_LAMEMP3ENC)) +#define GST_IS_LAMEMP3ENC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_LAMEMP3ENC)) + +typedef struct _GstLameMP3Enc GstLameMP3Enc; +typedef struct _GstLameMP3EncClass GstLameMP3EncClass; + +/** + * GstLameMP3Enc: + * + * Opaque data structure. + */ +struct _GstLameMP3Enc { + GstElement element; + + /*< private >*/ + GstPad *srcpad, *sinkpad; + + gint samplerate; + gint num_channels; + gboolean setup; + + gint target; + + gint bitrate; + gboolean cbr; + + gfloat vbr_quality; + gboolean fast_vbr; + + gint encoding_engine_quality; + + gboolean mono; + + /* track this so we don't send a last buffer in eos handler after error */ + GstFlowReturn last_flow; + + lame_global_flags *lgf; + + /* time tracker */ + guint64 last_ts, last_offs, last_duration, eos_ts; +}; + +struct _GstLameMP3EncClass { + GstElementClass parent_class; +}; + +GType gst_lamemp3enc_get_type(void); + +G_END_DECLS + + +#endif /* __GST_LAMEMP3ENC_H__ */ diff --git a/ext/lame/plugin.c b/ext/lame/plugin.c new file mode 100644 index 0000000..a931228 --- /dev/null +++ b/ext/lame/plugin.c @@ -0,0 +1,48 @@ +/* GStreamer + * Copyright (C) <2009> Sebastian Dröge + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include + +gboolean gst_lamemp3enc_register (GstPlugin * plugin); +gboolean gst_lame_register (GstPlugin * plugin); + +static gboolean +plugin_init (GstPlugin * plugin) +{ +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +#endif /* ENABLE_NLS */ + + if (!gst_lamemp3enc_register (plugin) || !gst_lame_register (plugin)) + 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); -- 2.7.4