From bf7ccbe0f8fd834ef186e5c266e40acaadf5536d Mon Sep 17 00:00:00 2001 From: Hans de Goede Date: Sat, 24 Jan 2009 18:13:39 +0100 Subject: Build the modplug plugin against the modplug library and remove our copy Always build the modplug plugin against the system modplug library and remove our own copy. Using the system version has advantages if security issues or other critical bugs are found in libmodplug and our own copy wasn't really maintained anyway. Also our copy only contained some patches to use GLib types and functions. Fixes bug #568837. --- ext/modplug/Makefile.am | 9 + ext/modplug/gstmodplug.cc | 855 ++++++++++++++++++++++++++++++++++++++++++++++ ext/modplug/gstmodplug.h | 89 +++++ 3 files changed, 953 insertions(+) create mode 100644 ext/modplug/Makefile.am create mode 100644 ext/modplug/gstmodplug.cc create mode 100644 ext/modplug/gstmodplug.h (limited to 'ext/modplug') diff --git a/ext/modplug/Makefile.am b/ext/modplug/Makefile.am new file mode 100644 index 00000000..e9525627 --- /dev/null +++ b/ext/modplug/Makefile.am @@ -0,0 +1,9 @@ +plugin_LTLIBRARIES = libgstmodplug.la + +libgstmodplug_la_SOURCES = gstmodplug.cc +libgstmodplug_la_CXXFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_CXXFLAGS) $(MODPLUG_CFLAGS) +libgstmodplug_la_LIBADD = $(GST_PLUGINS_BASE_LIBS) -lstdc++ $(LIBM) $(MODPLUG_LIBS) +libgstmodplug_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) +libgstmodplug_la_LIBTOOLFLAGS = --tag=disable-static + +noinst_HEADERS = gstmodplug.h diff --git a/ext/modplug/gstmodplug.cc b/ext/modplug/gstmodplug.cc new file mode 100644 index 00000000..822285f5 --- /dev/null +++ b/ext/modplug/gstmodplug.cc @@ -0,0 +1,855 @@ +/* GStreamer + * Copyright (C) <1999> Erik Walthinsen + * + * 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. + */ + +/* + Code based on modplugxmms + XMMS plugin: + Kenton Varda + Sound Engine: + Olivier Lapicque +*/ + +/** + * SECTION:element-modplug + * + * Modplug uses the modplug + * library to decode tracked music in the MOD/S3M/XM/IT and related formats. + * + * + * Example pipeline + * |[ + * gst-launch -v filesrc location=1990s-nostalgia.xm ! modplug ! audioconvert ! alsasink + * ]| Play a FastTracker xm file. + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include + +#include "gstmodplug.h" + +#include +#include +#include + +GST_DEBUG_CATEGORY_STATIC (modplug_debug); +#define GST_CAT_DEFAULT modplug_debug + +enum +{ + ARG_0, + ARG_SONGNAME, + ARG_REVERB, + ARG_REVERB_DEPTH, + ARG_REVERB_DELAY, + ARG_MEGABASS, + ARG_MEGABASS_AMOUNT, + ARG_MEGABASS_RANGE, + ARG_NOISE_REDUCTION, + ARG_SURROUND, + ARG_SURROUND_DEPTH, + ARG_SURROUND_DELAY, + ARG_OVERSAMP +}; + +#define DEFAULT_REVERB FALSE +#define DEFAULT_REVERB_DEPTH 30 +#define DEFAULT_REVERB_DELAY 100 +#define DEFAULT_MEGABASS FALSE +#define DEFAULT_MEGABASS_AMOUNT 40 +#define DEFAULT_MEGABASS_RANGE 30 +#define DEFAULT_SURROUND TRUE +#define DEFAULT_SURROUND_DEPTH 20 +#define DEFAULT_SURROUND_DELAY 20 +#define DEFAULT_OVERSAMP TRUE +#define DEFAULT_NOISE_REDUCTION TRUE + +static GstStaticPadTemplate modplug_src_template_factory = + GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("audio/x-raw-int," + " endianness = (int) BYTE_ORDER," + " signed = (boolean) true," + " width = (int) 16," + " depth = (int) 16," + " rate = (int) { 8000, 11025, 22050, 44100 }," + " channels = (int) 2; " + "audio/x-raw-int," + " endianness = (int) BYTE_ORDER," + " signed = (boolean) false," + " width = (int) 8," + " depth = (int) 8," + " rate = (int) { 8000, 11025, 22050, 44100 }, " + " channels = (int) [ 1, 2 ]")); + +static GstStaticPadTemplate modplug_sink_template_factory = + GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("audio/x-mod; audio/x-xm; audio/x-it; audio/x-s3m; " + "audio/x-stm")); + +static void gst_modplug_dispose (GObject * object); +static void gst_modplug_set_property (GObject * object, + guint id, const GValue * value, GParamSpec * pspec); +static void gst_modplug_get_property (GObject * object, + guint id, GValue * value, GParamSpec * pspec); + +static void gst_modplug_fixate (GstPad * pad, GstCaps * caps); +static const GstQueryType *gst_modplug_get_query_types (GstPad * pad); +static gboolean gst_modplug_src_event (GstPad * pad, GstEvent * event); +static gboolean gst_modplug_src_query (GstPad * pad, GstQuery * query); +static GstStateChangeReturn gst_modplug_change_state (GstElement * element, + GstStateChange transition); + +static gboolean gst_modplug_sinkpad_activate (GstPad * pad); +static gboolean gst_modplug_sinkpad_activate_pull (GstPad * pad, + gboolean active); +static void gst_modplug_loop (GstModPlug * element); + +GST_BOILERPLATE (GstModPlug, gst_modplug, GstElement, GST_TYPE_ELEMENT); + +static void +gst_modplug_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 (&modplug_sink_template_factory)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&modplug_src_template_factory)); + + gst_element_class_set_details_simple (element_class, "ModPlug", + "Codec/Decoder/Audio", "Module decoder based on modplug engine", + "Jeremy SIMON "); + + GST_DEBUG_CATEGORY_INIT (modplug_debug, "modplug", 0, "ModPlug element"); +} + +static void +gst_modplug_class_init (GstModPlugClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *gstelement_class; + + gobject_class = (GObjectClass *) klass; + gstelement_class = (GstElementClass *) klass; + + gobject_class->set_property = gst_modplug_set_property; + gobject_class->get_property = gst_modplug_get_property; + gobject_class->dispose = gst_modplug_dispose; + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SONGNAME, + g_param_spec_string ("songname", "Songname", "The song name", + NULL, G_PARAM_READABLE)); + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_REVERB, + g_param_spec_boolean ("reverb", "reverb", "Reverb", + DEFAULT_REVERB, (GParamFlags) G_PARAM_READWRITE)); + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_REVERB_DEPTH, + g_param_spec_int ("reverb-depth", "reverb depth", "Reverb depth", + 0, 100, DEFAULT_REVERB_DEPTH, (GParamFlags) G_PARAM_READWRITE)); + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_REVERB_DELAY, + g_param_spec_int ("reverb-delay", "reverb delay", "Reverb delay", + 0, 200, DEFAULT_REVERB_DELAY, (GParamFlags) G_PARAM_READWRITE)); + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MEGABASS, + g_param_spec_boolean ("megabass", "megabass", "Megabass", + DEFAULT_MEGABASS, (GParamFlags) G_PARAM_READWRITE)); + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MEGABASS_AMOUNT, + g_param_spec_int ("megabass-amount", "megabass amount", "Megabass amount", + 0, 100, DEFAULT_MEGABASS_AMOUNT, (GParamFlags) G_PARAM_READWRITE)); + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MEGABASS_RANGE, + g_param_spec_int ("megabass-range", "megabass range", "Megabass range", + 0, 100, DEFAULT_MEGABASS_RANGE, (GParamFlags) G_PARAM_READWRITE)); + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SURROUND, + g_param_spec_boolean ("surround", "surround", "Surround", + DEFAULT_SURROUND, (GParamFlags) G_PARAM_READWRITE)); + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SURROUND_DEPTH, + g_param_spec_int ("surround-depth", "surround depth", "Surround depth", + 0, 100, DEFAULT_SURROUND_DEPTH, (GParamFlags) G_PARAM_READWRITE)); + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SURROUND_DELAY, + g_param_spec_int ("surround-delay", "surround delay", "Surround delay", + 0, 40, DEFAULT_SURROUND_DELAY, (GParamFlags) G_PARAM_READWRITE)); + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_OVERSAMP, + g_param_spec_boolean ("oversamp", "oversamp", "oversamp", + DEFAULT_OVERSAMP, (GParamFlags) G_PARAM_READWRITE)); + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NOISE_REDUCTION, + g_param_spec_boolean ("noise-reduction", "noise reduction", + "noise reduction", DEFAULT_NOISE_REDUCTION, + (GParamFlags) G_PARAM_READWRITE)); + + gstelement_class->change_state = gst_modplug_change_state; +} + +static void +gst_modplug_init (GstModPlug * modplug, GstModPlugClass * klass) +{ + /* create the sink and src pads */ + modplug->sinkpad = + gst_pad_new_from_static_template (&modplug_sink_template_factory, "sink"); + gst_pad_set_activate_function (modplug->sinkpad, + GST_DEBUG_FUNCPTR (gst_modplug_sinkpad_activate)); + gst_pad_set_activatepull_function (modplug->sinkpad, + GST_DEBUG_FUNCPTR (gst_modplug_sinkpad_activate_pull)); + gst_element_add_pad (GST_ELEMENT (modplug), modplug->sinkpad); + + modplug->srcpad = + gst_pad_new_from_static_template (&modplug_src_template_factory, "src"); + gst_pad_set_fixatecaps_function (modplug->srcpad, + GST_DEBUG_FUNCPTR (gst_modplug_fixate)); + gst_pad_set_event_function (modplug->srcpad, + GST_DEBUG_FUNCPTR (gst_modplug_src_event)); + gst_pad_set_query_function (modplug->srcpad, + GST_DEBUG_FUNCPTR (gst_modplug_src_query)); + gst_pad_set_query_type_function (modplug->srcpad, + GST_DEBUG_FUNCPTR (gst_modplug_get_query_types)); + gst_element_add_pad (GST_ELEMENT (modplug), modplug->srcpad); + + modplug->reverb = DEFAULT_REVERB; + modplug->reverb_depth = DEFAULT_REVERB_DEPTH; + modplug->reverb_delay = DEFAULT_REVERB_DELAY; + modplug->megabass = DEFAULT_MEGABASS; + modplug->megabass_amount = DEFAULT_MEGABASS_AMOUNT; + modplug->megabass_range = DEFAULT_MEGABASS_RANGE; + modplug->surround = DEFAULT_SURROUND; + modplug->surround_depth = DEFAULT_SURROUND_DEPTH; + modplug->surround_delay = DEFAULT_SURROUND_DELAY; + modplug->oversamp = DEFAULT_OVERSAMP; + modplug->noise_reduction = DEFAULT_NOISE_REDUCTION; + + modplug->_16bit = TRUE; + modplug->channel = 2; + modplug->frequency = 44100; +} + + +static void +gst_modplug_dispose (GObject * object) +{ + GstModPlug *modplug = GST_MODPLUG (object); + + G_OBJECT_CLASS (parent_class)->dispose (object); + + if (modplug->buffer) { + gst_buffer_unref (modplug->buffer); + modplug->buffer = NULL; + } +} + +static const GstQueryType * +gst_modplug_get_query_types (GstPad * pad) +{ + static const GstQueryType gst_modplug_src_query_types[] = { + GST_QUERY_DURATION, + GST_QUERY_POSITION, + (GstQueryType) 0 + }; + + return gst_modplug_src_query_types; +} + + +static gboolean +gst_modplug_src_query (GstPad * pad, GstQuery * query) +{ + GstModPlug *modplug; + gboolean res = FALSE; + + modplug = GST_MODPLUG (gst_pad_get_parent (pad)); + + if (!modplug->mSoundFile) + goto done; + + switch (GST_QUERY_TYPE (query)) { + case GST_QUERY_DURATION: + { + GstFormat format; + + gst_query_parse_duration (query, &format, NULL); + if (format == GST_FORMAT_TIME) { + gst_query_set_duration (query, format, modplug->song_length); + res = TRUE; + } + } + break; + case GST_QUERY_POSITION: + { + GstFormat format; + + gst_query_parse_position (query, &format, NULL); + if (format == GST_FORMAT_TIME) { + gint64 pos; + + pos = (modplug->song_length * modplug->mSoundFile->GetCurrentPos ()); + pos /= modplug->mSoundFile->GetMaxPosition (); + gst_query_set_position (query, format, pos); + res = TRUE; + } + } + break; + default: + res = gst_pad_query_default (pad, query); + break; + } + +done: + gst_object_unref (modplug); + + return res; +} + +static gboolean +gst_modplug_src_event (GstPad * pad, GstEvent * event) +{ + GstModPlug *modplug; + gboolean res = FALSE; + + modplug = GST_MODPLUG (gst_pad_get_parent (pad)); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_SEEK: + { + gdouble rate; + GstFormat format; + GstSeekFlags flags; + GstSeekType cur_type, stop_type; + gboolean flush; + gint64 cur, stop; + guint64 timestamp; + + if (modplug->frequency == 0) { + GST_DEBUG_OBJECT (modplug, "no song loaded yet"); + break; + } + + timestamp = gst_util_uint64_scale_int (modplug->offset, GST_SECOND, + modplug->frequency); + + gst_event_parse_seek (event, &rate, &format, &flags, + &cur_type, &cur, &stop_type, &stop); + + if (format != GST_FORMAT_TIME) { + GST_DEBUG_OBJECT (modplug, "seeking is only supported in TIME format"); + gst_event_unref (event); + break; + } + + /* FIXME: we should be using GstSegment for all this */ + if (cur_type != GST_SEEK_TYPE_SET || stop_type != GST_SEEK_TYPE_NONE) { + GST_DEBUG_OBJECT (modplug, "unsupported seek type"); + gst_event_unref (event); + break; + } + + if (stop_type == GST_SEEK_TYPE_NONE) + stop = GST_CLOCK_TIME_NONE; + + cur = CLAMP (cur, 0, modplug->song_length); + + GST_DEBUG_OBJECT (modplug, "seek to %" GST_TIME_FORMAT, + GST_TIME_ARGS ((guint64) cur)); + + modplug->seek_at = cur; + + flush = ((flags & GST_SEEK_FLAG_FLUSH) == GST_SEEK_FLAG_FLUSH); + + if (flush) { + gst_pad_push_event (modplug->srcpad, gst_event_new_flush_start ()); + } else { + gst_pad_stop_task (modplug->sinkpad); + } + + GST_PAD_STREAM_LOCK (modplug->sinkpad); + + if (flags & GST_SEEK_FLAG_SEGMENT) { + gst_element_post_message (GST_ELEMENT (modplug), + gst_message_new_segment_start (GST_OBJECT (modplug), format, cur)); + } + if (stop == -1 && modplug->song_length > 0) + stop = modplug->song_length; + + if (flush) { + gst_pad_push_event (modplug->srcpad, gst_event_new_flush_stop ()); + } + + GST_LOG_OBJECT (modplug, "sending newsegment from %" GST_TIME_FORMAT "-%" + GST_TIME_FORMAT ", pos=%" GST_TIME_FORMAT, + GST_TIME_ARGS ((guint64) cur), GST_TIME_ARGS ((guint64) stop), + GST_TIME_ARGS ((guint64) cur)); + + gst_pad_push_event (modplug->srcpad, + gst_event_new_new_segment (FALSE, rate, + GST_FORMAT_TIME, cur, stop, cur)); + + modplug->offset = + gst_util_uint64_scale_int (cur, modplug->frequency, GST_SECOND); + + gst_pad_start_task (modplug->sinkpad, + (GstTaskFunction) gst_modplug_loop, modplug); + + GST_PAD_STREAM_UNLOCK (modplug->sinkpad); + res = TRUE; + break; + } + default: + res = gst_pad_event_default (pad, event); + break; + } + + gst_object_unref (modplug); + return res; +} + +static void +gst_modplug_fixate (GstPad * pad, GstCaps * caps) +{ + GstStructure *structure; + + structure = gst_caps_get_structure (caps, 0); + if (gst_structure_fixate_field_nearest_int (structure, "rate", 44100)) + return; + if (gst_structure_fixate_field_nearest_int (structure, "channels", 2)) + return; +} + +static gboolean +gst_modplug_load_song (GstModPlug * modplug) +{ + GstCaps *newcaps, *othercaps; + GstStructure *structure; + gint depth; + + GST_DEBUG_OBJECT (modplug, "Setting caps"); + + /* negotiate srcpad caps */ + if ((othercaps = gst_pad_get_allowed_caps (modplug->srcpad))) { + newcaps = gst_caps_copy_nth (othercaps, 0); + gst_caps_unref (othercaps); + } else { + GST_WARNING ("no allowed caps on srcpad, no peer linked"); + /* FIXME: this can be done in a better way */ + newcaps = + gst_caps_copy_nth (gst_pad_get_pad_template_caps (modplug->srcpad), 0); + } + gst_pad_fixate_caps (modplug->srcpad, newcaps); + gst_pad_set_caps (modplug->srcpad, newcaps); + + /* set up modplug to output the negotiated format */ + structure = gst_caps_get_structure (newcaps, 0); + gst_structure_get_int (structure, "depth", &depth); + modplug->_16bit = (depth == 16); + gst_structure_get_int (structure, "channels", &modplug->channel); + gst_structure_get_int (structure, "rate", &modplug->frequency); + + modplug->read_samples = 1152; + modplug->read_bytes = modplug->read_samples * modplug->channel * depth / 8; + + GST_DEBUG_OBJECT (modplug, "Loading song"); + + modplug->mSoundFile = new CSoundFile; + + if (modplug->_16bit) + modplug->mSoundFile->SetWaveConfig (modplug->frequency, 16, + modplug->channel); + else + modplug->mSoundFile->SetWaveConfig (modplug->frequency, 8, + modplug->channel); + + modplug->mSoundFile->SetWaveConfigEx (modplug->surround, !modplug->oversamp, + modplug->reverb, true, modplug->megabass, modplug->noise_reduction, true); + modplug->mSoundFile->SetResamplingMode (SRCMODE_POLYPHASE); + + if (modplug->surround) + modplug->mSoundFile->SetSurroundParameters (modplug->surround_depth, + modplug->surround_delay); + + if (modplug->megabass) + modplug->mSoundFile->SetXBassParameters (modplug->megabass_amount, + modplug->megabass_range); + + if (modplug->reverb) + modplug->mSoundFile->SetReverbParameters (modplug->reverb_depth, + modplug->reverb_delay); + + if (!modplug->mSoundFile->Create (GST_BUFFER_DATA (modplug->buffer), + modplug->song_size)) { + GST_ELEMENT_ERROR (modplug, STREAM, DECODE, (NULL), + ("Unable to load song")); + return FALSE; + } + + modplug->song_length = modplug->mSoundFile->GetSongTime () * GST_SECOND; + modplug->seek_at = -1; + + GST_INFO_OBJECT (modplug, "Song length: %" GST_TIME_FORMAT, + GST_TIME_ARGS ((guint64) modplug->song_length)); + + return TRUE; +} + +static gboolean +gst_modplug_sinkpad_activate (GstPad * pad) +{ + if (!gst_pad_check_pull_range (pad)) + return FALSE; + + return gst_pad_activate_pull (pad, TRUE); +} + +static gboolean +gst_modplug_sinkpad_activate_pull (GstPad * pad, gboolean active) +{ + GstModPlug *modplug = GST_MODPLUG (GST_OBJECT_PARENT (pad)); + + if (active) { + return gst_pad_start_task (pad, (GstTaskFunction) gst_modplug_loop, + modplug); + } else { + return gst_pad_stop_task (pad); + } +} + +static gboolean +gst_modplug_get_upstream_size (GstModPlug * modplug, gint64 * length) +{ + GstFormat format = GST_FORMAT_BYTES; + gboolean res = FALSE; + GstPad *peer; + + peer = gst_pad_get_peer (modplug->sinkpad); + if (peer == NULL) + return FALSE; + + if (gst_pad_query_duration (peer, &format, length) && *length >= 0) { + res = TRUE; + } + + gst_object_unref (peer); + return res; +} + +static void +gst_modplug_loop (GstModPlug * modplug) +{ + GstFlowReturn flow; + GstBuffer *out = NULL; + + g_assert (GST_IS_MODPLUG (modplug)); + + /* first, get the size of the song */ + if (!modplug->song_size) { + if (!gst_modplug_get_upstream_size (modplug, &modplug->song_size)) { + GST_ELEMENT_ERROR (modplug, STREAM, DECODE, (NULL), + ("Unable to load song")); + goto pause; + } + + if (modplug->buffer) { + gst_buffer_unref (modplug->buffer); + } + modplug->buffer = gst_buffer_new_and_alloc (modplug->song_size); + modplug->offset = 0; + } + + /* read in the song data */ + if (!modplug->mSoundFile) { + GstBuffer *buffer = NULL; + guint64 read_size = modplug->song_size - modplug->offset; + + if (read_size > 4096) + read_size = 4096; + + flow = + gst_pad_pull_range (modplug->sinkpad, modplug->offset, read_size, + &buffer); + if (flow != GST_FLOW_OK) { + GST_ELEMENT_ERROR (modplug, STREAM, DECODE, (NULL), + ("Unable to load song")); + goto pause; + } + + /* GST_LOG_OBJECT (modplug, "Read %u bytes", GST_BUFFER_SIZE (buffer)); */ + g_memmove (GST_BUFFER_DATA (modplug->buffer) + modplug->offset, + GST_BUFFER_DATA (buffer), GST_BUFFER_SIZE (buffer)); + gst_buffer_unref (buffer); + + modplug->offset += read_size; + + /* actually load it */ + if (modplug->offset == modplug->song_size) { + GstEvent *newsegment; + GstTagList *tags; + gboolean ok; + gchar comment[16384]; + + ok = gst_modplug_load_song (modplug); + gst_buffer_unref (modplug->buffer); + modplug->buffer = NULL; + modplug->offset = 0; + + if (!ok) { + goto pause; + } + + newsegment = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, + 0, modplug->song_length, 0); + gst_pad_push_event (modplug->srcpad, newsegment); + + /* get and send metadata */ + tags = gst_tag_list_new (); + gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, + GST_TAG_TITLE, modplug->mSoundFile->GetTitle (), + GST_TAG_BEATS_PER_MINUTE, + (gdouble) modplug->mSoundFile->GetMusicTempo (), NULL); + + if (modplug->mSoundFile->GetSongComments ((gchar *) & comment, 16384, 32)) { + gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, + GST_TAG_COMMENT, comment, NULL); + } + + + gst_element_found_tags (GST_ELEMENT (modplug), tags); + } else { + /* not fully loaded yet */ + return; + } + } + + /* could move this to gst_modplug_src_event + * if libmodplug was definitely thread safe.. */ + if (modplug->seek_at != -1) { + gint seek_to_pos; + gfloat temp; + + temp = (gfloat) modplug->song_length / modplug->seek_at; + seek_to_pos = (int) (modplug->mSoundFile->GetMaxPosition () / temp); + + GST_DEBUG_OBJECT (modplug, "Seeking to row %d", seek_to_pos); + + modplug->mSoundFile->SetCurrentPos (seek_to_pos); + modplug->seek_at = -1; + } + + /* read and output a buffer */ + flow = gst_pad_alloc_buffer_and_set_caps (modplug->srcpad, + GST_BUFFER_OFFSET_NONE, modplug->read_bytes, + GST_PAD_CAPS (modplug->srcpad), &out); + + if (flow != GST_FLOW_OK) { + GST_LOG_OBJECT (modplug, "pad alloc flow: %s", gst_flow_get_name (flow)); + goto pause; + } + + if (!modplug->mSoundFile->Read (GST_BUFFER_DATA (out), modplug->read_bytes)) + goto eos; + + GST_BUFFER_SIZE (out) = modplug->read_bytes; + GST_BUFFER_DURATION (out) = + gst_util_uint64_scale_int (modplug->read_samples, GST_SECOND, + modplug->frequency); + GST_BUFFER_OFFSET (out) = modplug->offset; + GST_BUFFER_TIMESTAMP (out) = + gst_util_uint64_scale_int (modplug->offset, GST_SECOND, + modplug->frequency); + + modplug->offset += modplug->read_samples; + + flow = gst_pad_push (modplug->srcpad, out); + + if (flow != GST_FLOW_OK) { + GST_LOG_OBJECT (modplug, "pad push flow: %s", gst_flow_get_name (flow)); + goto pause; + } + + return; + +eos: + { + gst_buffer_unref (out); + GST_INFO_OBJECT (modplug, "EOS"); + gst_pad_push_event (modplug->srcpad, gst_event_new_eos ()); + goto pause; + } + +pause: + { + GST_INFO_OBJECT (modplug, "Pausing"); + gst_pad_pause_task (modplug->sinkpad); + } +} + + +static GstStateChangeReturn +gst_modplug_change_state (GstElement * element, GstStateChange transition) +{ + GstModPlug *modplug; + GstStateChangeReturn ret; + + modplug = GST_MODPLUG (element); + + switch (transition) { + case GST_STATE_CHANGE_READY_TO_PAUSED: + modplug->buffer = NULL; + modplug->offset = 0; + modplug->song_size = 0; + break; + default: + break; + } + + ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + if (ret == GST_STATE_CHANGE_FAILURE) + return ret; + + switch (transition) { + case GST_STATE_CHANGE_PAUSED_TO_READY: + if (modplug->buffer) { + gst_buffer_unref (modplug->buffer); + modplug->buffer = NULL; + } + if (modplug->mSoundFile) { + modplug->mSoundFile->Destroy (); + modplug->mSoundFile = NULL; + } + break; + default: + break; + } + + return GST_STATE_CHANGE_SUCCESS; +} + + +static void +gst_modplug_set_property (GObject * object, guint id, const GValue * value, + GParamSpec * pspec) +{ + GstModPlug *modplug; + + g_return_if_fail (GST_IS_MODPLUG (object)); + modplug = GST_MODPLUG (object); + + switch (id) { + case ARG_REVERB: + modplug->reverb = g_value_get_boolean (value); + break; + case ARG_REVERB_DEPTH: + modplug->reverb_depth = g_value_get_int (value); + break; + case ARG_REVERB_DELAY: + modplug->reverb_delay = g_value_get_int (value); + break; + case ARG_MEGABASS: + modplug->megabass = g_value_get_boolean (value); + break; + case ARG_MEGABASS_AMOUNT: + modplug->megabass_amount = g_value_get_int (value); + break; + case ARG_MEGABASS_RANGE: + modplug->megabass_range = g_value_get_int (value); + break; + case ARG_NOISE_REDUCTION: + modplug->noise_reduction = g_value_get_boolean (value); + break; + case ARG_SURROUND: + modplug->surround = g_value_get_boolean (value); + break; + case ARG_SURROUND_DEPTH: + modplug->surround_depth = g_value_get_int (value); + break; + case ARG_SURROUND_DELAY: + modplug->surround_delay = g_value_get_int (value); + break; + default: + break; + } +} + +static void +gst_modplug_get_property (GObject * object, guint id, GValue * value, + GParamSpec * pspec) +{ + GstModPlug *modplug; + + g_return_if_fail (GST_IS_MODPLUG (object)); + modplug = GST_MODPLUG (object); + + switch (id) { + case ARG_REVERB: + g_value_set_boolean (value, modplug->reverb); + break; + case ARG_REVERB_DEPTH: + g_value_set_int (value, modplug->reverb_depth); + break; + case ARG_REVERB_DELAY: + g_value_set_int (value, modplug->reverb_delay); + break; + case ARG_MEGABASS: + g_value_set_boolean (value, modplug->megabass); + break; + case ARG_MEGABASS_AMOUNT: + g_value_set_int (value, modplug->megabass_amount); + break; + case ARG_MEGABASS_RANGE: + g_value_set_int (value, modplug->megabass_range); + break; + case ARG_SURROUND: + g_value_set_boolean (value, modplug->surround); + break; + case ARG_SURROUND_DEPTH: + g_value_set_int (value, modplug->surround_depth); + break; + case ARG_SURROUND_DELAY: + g_value_set_int (value, modplug->surround_delay); + break; + case ARG_NOISE_REDUCTION: + g_value_set_boolean (value, modplug->noise_reduction); + break; + default: + break; + } +} + +static gboolean +plugin_init (GstPlugin * plugin) +{ + return gst_element_register (plugin, "modplug", + GST_RANK_PRIMARY, GST_TYPE_MODPLUG); +} + +GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, + GST_VERSION_MINOR, + "modplug", + ".MOD audio decoding", + plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) diff --git a/ext/modplug/gstmodplug.h b/ext/modplug/gstmodplug.h new file mode 100644 index 00000000..b08af240 --- /dev/null +++ b/ext/modplug/gstmodplug.h @@ -0,0 +1,89 @@ +/* GStreamer + * Copyright (C) <1999> Erik Walthinsen + * + * 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_MODPLUG_H__ +#define __GST_MODPLUG_H__ + +#include + +G_BEGIN_DECLS + +#define GST_TYPE_MODPLUG \ + (gst_modplug_get_type()) + +#define GST_MODPLUG(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MODPLUG,GstModPlug)) +#define GST_MODPLUG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MODPLUG,GstModPlugClass)) +#define GST_IS_MODPLUG(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MODPLUG)) +#define GST_IS_MODPLUG_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MODPLUG)) + +struct _GstModPlug { + GstElement element; + + GstPad *sinkpad; + GstPad *srcpad; + + /* properties */ + const gchar *songname; + gboolean reverb; + gint reverb_depth; + gint reverb_delay; + gboolean megabass; + gint megabass_amount; + gint megabass_range; + gboolean surround; + gint surround_depth; + gint surround_delay; + gboolean noise_reduction; + gboolean _16bit; + gboolean oversamp; + gint channel; + gint frequency; + + /* state */ + GstBuffer *buffer; + + gint32 read_bytes; + gint32 read_samples; + + gint64 seek_at; /* pending seek, or -1 */ + gint64 song_size; /* size of the raw song data in bytes */ + gint64 song_length; /* duration of the song in nanoseconds */ + gint64 offset; /* current position in samples */ + gint64 timestamp; + + CSoundFile *mSoundFile; +}; + +struct _GstModPlugClass { + GstElementClass parent_class; +}; + +typedef struct _GstModPlug GstModPlug; +typedef struct _GstModPlugClass GstModPlugClass; + +GType gst_modplug_get_type (void); + +G_END_DECLS + +#endif /* __GST_MODPLUG_H__ */ -- cgit v1.2.1