/* GStreamer * Copyright (C) 2008 Pioneers of the Inevitable <songbird@songbirdnest.com> * * Authors: Michael Smith <msmith@songbirdnest.com> * * 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 <windows.h> #include <mmreg.h> #include <msacm.h> #include <gst/gst.h> #include <gst/riff/riff-media.h> #define ACM_BUFFER_SIZE (64 * 1024) #define GST_TYPE_ACM_MP3_DEC \ (acmmp3dec_get_type()) #define GST_ACM_MP3_DEC(obj) \ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ACM_MP3_DEC,ACMMP3Dec)) #define GST_CAT_DEFAULT acmmp3dec_debug GST_DEBUG_CATEGORY_STATIC (acmmp3dec_debug); static GstStaticPadTemplate acmmp3dec_src_template = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/x-raw-int, " "depth = (int)16, " "width = (int)16, " "endianness = (int)" G_STRINGIFY (G_BYTE_ORDER) ", " "signed = (boolean)TRUE, " "channels = (int) [1,2], " "rate = (int)[1, MAX]") ); static GstStaticPadTemplate acmmp3dec_sink_template = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, 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], " "parsed = (boolean) true") ); typedef struct _ACMMP3DecClass { GstElementClass parent_class; } ACMMP3DecClass; typedef struct _ACMMP3Dec { GstElement parent; GstPad *sinkpad; GstPad *srcpad; gboolean is_setup; MPEGLAYER3WAVEFORMAT infmt; WAVEFORMATEX outfmt; HACMSTREAM stream; ACMSTREAMHEADER header; /* Next timestamp to push */ GstClockTime timestamp; /* From received caps */ int rate; int channels; GstCaps *output_caps; } ACMMP3Dec; GType acmmp3dec_get_type (void); GST_BOILERPLATE (ACMMP3Dec, acmmp3dec, GstElement, GST_TYPE_ELEMENT); static GstCaps * acmmp3dec_caps_from_format (WAVEFORMATEX * fmt) { return gst_riff_create_audio_caps (fmt->wFormatTag, NULL, (gst_riff_strf_auds *) fmt, NULL, NULL, NULL); } static gboolean acmmp3dec_set_input_format (ACMMP3Dec * dec) { dec->infmt.wfx.wFormatTag = WAVE_FORMAT_MPEGLAYER3; dec->infmt.wfx.nChannels = dec->channels; dec->infmt.wfx.nSamplesPerSec = dec->rate; dec->infmt.wfx.nAvgBytesPerSec = 8000; /* Has to be set, but actual value doesn't matter */ dec->infmt.wfx.nBlockAlign = 1; dec->infmt.wfx.wBitsPerSample = 0; dec->infmt.wfx.cbSize = MPEGLAYER3_WFX_EXTRA_BYTES; dec->infmt.wID = MPEGLAYER3_ID_MPEG; dec->infmt.fdwFlags = MPEGLAYER3_FLAG_PADDING_OFF; dec->infmt.nBlockSize = 1; /* Needs to be non-zero, actual value doesn't matter */ dec->infmt.nFramesPerBlock = 1; dec->infmt.nCodecDelay = 0; return TRUE; } static gboolean acmmp3dec_set_output_format (ACMMP3Dec * dec) { dec->outfmt.wFormatTag = WAVE_FORMAT_PCM; dec->outfmt.nChannels = dec->channels; dec->outfmt.nSamplesPerSec = dec->rate; dec->outfmt.nAvgBytesPerSec = 2 * dec->channels * dec->rate; dec->outfmt.nBlockAlign = 2 * dec->channels; dec->outfmt.wBitsPerSample = 16; dec->outfmt.cbSize = 0; return TRUE; } static gboolean acmmp3dec_setup (ACMMP3Dec * dec) { MMRESULT res; int destBufferSize; acmmp3dec_set_input_format (dec); acmmp3dec_set_output_format (dec); res = acmStreamOpen (&dec->stream, NULL, (LPWAVEFORMATEX) & dec->infmt, &dec->outfmt, 0, 0, 0, 0); if (res) { GST_WARNING_OBJECT (dec, "Failed to open ACM stream: %d", res); return FALSE; } dec->header.cbStruct = sizeof (ACMSTREAMHEADER); dec->header.fdwStatus = 0; dec->header.dwUser = 0; dec->header.pbSrc = (BYTE *) g_malloc (ACM_BUFFER_SIZE); dec->header.cbSrcLength = ACM_BUFFER_SIZE; dec->header.cbSrcLengthUsed = 0; dec->header.dwSrcUser = 0; /* Ask what buffer size we need to use for our output */ acmStreamSize (dec->stream, ACM_BUFFER_SIZE, (LPDWORD) & destBufferSize, ACM_STREAMSIZEF_SOURCE); dec->header.pbDst = (BYTE *) g_malloc (destBufferSize); dec->header.cbDstLength = destBufferSize; dec->header.cbDstLengthUsed = 0; dec->header.dwDstUser = 0; res = acmStreamPrepareHeader (dec->stream, &dec->header, 0); if (res) { GST_WARNING_OBJECT (dec, "Failed to prepare ACM stream: %x", res); return FALSE; } dec->output_caps = acmmp3dec_caps_from_format (&dec->outfmt); if (dec->output_caps) { gst_pad_set_caps (dec->srcpad, dec->output_caps); } dec->timestamp = GST_CLOCK_TIME_NONE; dec->is_setup = TRUE; return TRUE; } static void acmmp3dec_teardown (ACMMP3Dec * dec) { if (dec->output_caps) { gst_caps_unref (dec->output_caps); dec->output_caps = NULL; } if (dec->header.fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED) acmStreamUnprepareHeader (dec->stream, &dec->header, 0); if (dec->header.pbSrc) g_free (dec->header.pbSrc); if (dec->header.pbDst) g_free (dec->header.pbDst); memset (&dec->header, 0, sizeof (dec->header)); if (dec->stream) { acmStreamClose (dec->stream, 0); dec->stream = 0; } dec->timestamp = GST_CLOCK_TIME_NONE; dec->is_setup = FALSE; } static gboolean acmmp3dec_sink_setcaps (GstPad * pad, GstCaps * caps) { ACMMP3Dec *dec = (ACMMP3Dec *) GST_PAD_PARENT (pad); GstStructure *structure; gboolean ret; structure = gst_caps_get_structure (caps, 0); gst_structure_get_int (structure, "channels", &dec->channels); gst_structure_get_int (structure, "rate", &dec->rate); if (dec->is_setup) acmmp3dec_teardown (dec); ret = acmmp3dec_setup (dec); return ret; } static GstFlowReturn acmmp3dec_push_output (ACMMP3Dec * dec) { GstFlowReturn ret = GST_FLOW_OK; if (dec->header.cbDstLengthUsed > 0) { GstBuffer *outbuf = gst_buffer_new_and_alloc (dec->header.cbDstLengthUsed); memcpy (GST_BUFFER_DATA (outbuf), dec->header.pbDst, dec->header.cbDstLengthUsed); if (dec->timestamp != GST_CLOCK_TIME_NONE) GST_BUFFER_TIMESTAMP (outbuf) = dec->timestamp; GST_BUFFER_DURATION (outbuf) = gst_util_uint64_scale_int (GST_BUFFER_SIZE (outbuf), GST_SECOND, dec->rate * dec->channels * 2); GST_DEBUG_OBJECT (dec, "decoded buffer has ts %d, duration %d", (int) (GST_BUFFER_TIMESTAMP (outbuf)), (int) (GST_BUFFER_DURATION (outbuf))); gst_buffer_set_caps (outbuf, dec->output_caps); if (dec->timestamp != GST_CLOCK_TIME_NONE) dec->timestamp += GST_BUFFER_DURATION (outbuf); GST_DEBUG_OBJECT (dec, "Pushing %lu byte decoded buffer", dec->header.cbDstLengthUsed); ret = gst_pad_push (dec->srcpad, outbuf); } else GST_DEBUG_OBJECT (dec, "Not pushing decoded buffer, no output"); return ret; } static GstFlowReturn acmmp3dec_chain (GstPad * pad, GstBuffer * buf) { MMRESULT res; ACMMP3Dec *dec = (ACMMP3Dec *) GST_PAD_PARENT (pad); guchar *data = GST_BUFFER_DATA (buf); gint len = GST_BUFFER_SIZE (buf); GstFlowReturn ret = GST_FLOW_OK; if (len > ACM_BUFFER_SIZE) { GST_WARNING_OBJECT (dec, "Impossibly large mp3 frame!"); ret = GST_FLOW_ERROR; goto done; } if (GST_BUFFER_TIMESTAMP (buf) != GST_CLOCK_TIME_NONE && (dec->timestamp == GST_CLOCK_TIME_NONE || GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DISCONT))) { dec->timestamp = GST_BUFFER_TIMESTAMP (buf); } memcpy (dec->header.pbSrc, data, len); dec->header.cbSrcLength = len; /* Now we have a buffer ready to go */ res = acmStreamConvert (dec->stream, &dec->header, ACM_STREAMCONVERTF_BLOCKALIGN); if (res) { GST_WARNING_OBJECT (dec, "Failed to decode data"); ret = GST_FLOW_OK; /* Maybe it was just a corrupt frame */ goto done; } if (dec->header.cbSrcLengthUsed > 0) { if (dec->header.cbSrcLengthUsed != dec->header.cbSrcLength) { GST_WARNING_OBJECT (dec, "ACM decoder didn't consume all data!"); /* We could handle this, but it shouldn't be possible, so don't try * for now */ ret = GST_FLOW_ERROR; goto done; } /* Write out any data produced */ acmmp3dec_push_output (dec); } done: gst_buffer_unref (buf); return ret; } static GstFlowReturn acmmp3dec_finish_stream (ACMMP3Dec * dec) { MMRESULT res; GstFlowReturn ret = GST_FLOW_OK; dec->header.cbSrcLength = 0; /* Flush out any remaining data internal to the decoder */ res = acmStreamConvert (dec->stream, &dec->header, ACM_STREAMCONVERTF_BLOCKALIGN | ACM_STREAMCONVERTF_END); if (res) { GST_WARNING_OBJECT (dec, "Failed to decode data"); return ret; } ret = acmmp3dec_push_output (dec); return ret; } static gboolean acmmp3dec_sink_event (GstPad * pad, GstEvent * event) { ACMMP3Dec *dec = (ACMMP3Dec *) GST_PAD_PARENT (pad); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: acmmp3dec_finish_stream (dec); break; case GST_EVENT_FLUSH_STOP: if (dec->stream) acmStreamReset (dec->stream, 0); dec->timestamp = GST_CLOCK_TIME_NONE; break; default: break; } return gst_pad_push_event (dec->srcpad, event); } static void acmmp3dec_dispose (GObject * obj) { ACMMP3Dec *dec = (ACMMP3Dec *) obj; if (dec->is_setup) acmmp3dec_teardown (dec); G_OBJECT_CLASS (parent_class)->dispose (obj); } static void acmmp3dec_init (ACMMP3Dec * dec, ACMMP3DecClass * decclass) { dec->sinkpad = gst_pad_new_from_static_template (&acmmp3dec_sink_template, "sink"); gst_pad_set_setcaps_function (dec->sinkpad, GST_DEBUG_FUNCPTR (acmmp3dec_sink_setcaps)); gst_pad_set_chain_function (dec->sinkpad, GST_DEBUG_FUNCPTR (acmmp3dec_chain)); gst_pad_set_event_function (dec->sinkpad, GST_DEBUG_FUNCPTR (acmmp3dec_sink_event)); gst_element_add_pad (GST_ELEMENT (dec), dec->sinkpad); dec->srcpad = gst_pad_new_from_static_template (&acmmp3dec_src_template, "src"); gst_element_add_pad (GST_ELEMENT (dec), dec->srcpad); } static void acmmp3dec_class_init (ACMMP3DecClass * klass) { GObjectClass *gobjectclass = (GObjectClass *) klass; gobjectclass->dispose = acmmp3dec_dispose; } static void acmmp3dec_base_init (gpointer klass) { GstElementClass *element_class = GST_ELEMENT_CLASS (klass); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&acmmp3dec_sink_template)); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&acmmp3dec_src_template)); gst_element_class_set_metadata (element_class, "ACM MP3 decoder", "Codec/Decoder/Audio", "Decode MP3 using ACM decoder", "Pioneers of the Inevitable <songbird@songbirdnest.com"); } static gboolean plugin_init (GstPlugin * plugin) { GST_DEBUG_CATEGORY_INIT (acmmp3dec_debug, "acmmp3dec", 0, "ACM Decoders"); GST_INFO ("Registering ACM MP3 decoder"); if (!gst_element_register (plugin, "acmmp3dec", GST_RANK_PRIMARY, GST_TYPE_ACM_MP3_DEC)) { return FALSE; } return TRUE; } GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, acmmp3dec, "ACM MP3 Decoder", plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)