From: Mark Nauwelaerts Date: Thu, 26 Nov 2009 17:15:21 +0000 (+0100) Subject: audioparsers: move 'amrparse' into it X-Git-Tag: 1.19.3~509^2~7136^2~1008 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=3279f55a7765f2e8a49e056ce24b93aa3ae59cd8;p=platform%2Fupstream%2Fgstreamer.git audioparsers: move 'amrparse' into it --- diff --git a/gst/audioparsers/Makefile.am b/gst/audioparsers/Makefile.am index 3851af3..a13afaa 100644 --- a/gst/audioparsers/Makefile.am +++ b/gst/audioparsers/Makefile.am @@ -1,11 +1,11 @@ plugin_LTLIBRARIES = libgstaudioparsersbad.la libgstaudioparsersbad_la_SOURCES = \ - gstaacparse.c gstbaseparse.c plugin.c + gstaacparse.c gstamrparse.c gstbaseparse.c plugin.c libgstaudioparsersbad_la_CFLAGS = $(GST_CFLAGS) $(GST_PLUGINS_BASE_CFLAGS) libgstaudioparsersbad_la_LIBADD = $(GST_BASE_LIBS) libgstaudioparsersbad_la_LDFLAGS = $(PACKAGE_LIBS) $(GST_PLUGIN_LDFLAGS) libgstaudioparsersbad_la_LIBTOOLFLAGS = --tag=disable-static -noinst_HEADERS = gstaacparse.h gstbaseparse.h +noinst_HEADERS = gstaacparse.h gstamrparse.h gstbaseparse.h diff --git a/gst/audioparsers/gstamrparse.c b/gst/audioparsers/gstamrparse.c new file mode 100644 index 0000000..819aa44 --- /dev/null +++ b/gst/audioparsers/gstamrparse.c @@ -0,0 +1,578 @@ +/* GStreamer Adaptive Multi-Rate parser plugin + * Copyright (C) 2006 Edgard Lima + * Copyright (C) 2008 Nokia Corporation. All rights reserved. + * + * Contact: Stefan Kost + * + * 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:gstamrparse + * @short_description: AMR parser + * @see_also: #GstAmrnbDec, #GstAmrnbEnc + * + * + * + * This is an AMR parser capable of handling both narrow-band and wideband + * formats. + * + * Example launch line + * + * + * gst-launch filesrc location=abc.amr ! amrparse ! amrdec ! audioresample ! audioconvert ! alsasink + * + * + * + */ + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstamrparse.h" + + +static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("audio/AMR, " "rate = (int) 8000, " "channels = (int) 1;" + "audio/AMR-WB, " "rate = (int) 16000, " "channels = (int) 1;") + ); + +static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("audio/x-amr-nb-sh; audio/x-amr-wb-sh")); + +GST_DEBUG_CATEGORY_STATIC (gst_amrparse_debug); +#define GST_CAT_DEFAULT gst_amrparse_debug + +static const gint block_size_nb[16] = + { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 }; + +static const gint block_size_wb[16] = + { 17, 23, 32, 36, 40, 46, 50, 58, 60, 5, 5, 0, 0, 0, 0, 0 }; + +/* AMR has a "hardcoded" framerate of 50fps */ +#define AMR_FRAMES_PER_SECOND 50 +#define AMR_FRAME_DURATION (GST_SECOND/AMR_FRAMES_PER_SECOND) +#define AMR_MIME_HEADER_SIZE 9 + +static void gst_amrparse_finalize (GObject * object); + +gboolean gst_amrparse_start (GstBaseParse * parse); +gboolean gst_amrparse_stop (GstBaseParse * parse); + +static gboolean gst_amrparse_sink_setcaps (GstBaseParse * parse, + GstCaps * caps); + +gboolean gst_amrparse_check_valid_frame (GstBaseParse * parse, + GstBuffer * buffer, guint * framesize, gint * skipsize); + +GstFlowReturn gst_amrparse_parse_frame (GstBaseParse * parse, + GstBuffer * buffer); + +gboolean gst_amrparse_convert (GstBaseParse * parse, + GstFormat src_format, + gint64 src_value, GstFormat dest_format, gint64 * dest_value); + +gboolean gst_amrparse_event (GstBaseParse * parse, GstEvent * event); + +#define _do_init(bla) \ + GST_DEBUG_CATEGORY_INIT (gst_amrparse_debug, "amrparse", 0, \ + "AMR-NB audio stream parser"); + +GST_BOILERPLATE_FULL (GstAmrParse, gst_amrparse, GstBaseParse, + GST_TYPE_BASE_PARSE, _do_init); + + +/** + * gst_amrparse_base_init: + * @klass: #GstElementClass. + * + */ +static void +gst_amrparse_base_init (gpointer klass) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + GstElementDetails details = GST_ELEMENT_DETAILS ("AMR audio stream parser", + "Codec/Parser/Audio", + "Adaptive Multi-Rate audio parser", + "Ronald Bultje "); + + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&sink_template)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&src_template)); + + gst_element_class_set_details (element_class, &details); +} + + +/** + * gst_amrparse_class_init: + * @klass: GstAmrParseClass. + * + */ +static void +gst_amrparse_class_init (GstAmrParseClass * klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass); + + object_class->finalize = gst_amrparse_finalize; + + parse_class->start = GST_DEBUG_FUNCPTR (gst_amrparse_start); + parse_class->stop = GST_DEBUG_FUNCPTR (gst_amrparse_stop); + parse_class->event = GST_DEBUG_FUNCPTR (gst_amrparse_event); + parse_class->convert = GST_DEBUG_FUNCPTR (gst_amrparse_convert); + parse_class->set_sink_caps = GST_DEBUG_FUNCPTR (gst_amrparse_sink_setcaps); + parse_class->parse_frame = GST_DEBUG_FUNCPTR (gst_amrparse_parse_frame); + parse_class->check_valid_frame = + GST_DEBUG_FUNCPTR (gst_amrparse_check_valid_frame); +} + + +/** + * gst_amrparse_init: + * @amrparse: #GstAmrParse + * @klass: #GstAmrParseClass. + * + */ +static void +gst_amrparse_init (GstAmrParse * amrparse, GstAmrParseClass * klass) +{ + /* init rest */ + gst_base_parse_set_min_frame_size (GST_BASE_PARSE (amrparse), 62); + amrparse->ts = 0; + GST_DEBUG ("initialized"); + +} + + +/** + * gst_amrparse_finalize: + * @object: + * + */ +static void +gst_amrparse_finalize (GObject * object) +{ + GstAmrParse *amrparse; + + amrparse = GST_AMRPARSE (object); + G_OBJECT_CLASS (parent_class)->finalize (object); +} + + +/** + * gst_amrparse_set_src_caps: + * @amrparse: #GstAmrParse. + * + * Set source pad caps according to current knowledge about the + * audio stream. + * + * Returns: TRUE if caps were successfully set. + */ +static gboolean +gst_amrparse_set_src_caps (GstAmrParse * amrparse) +{ + GstCaps *src_caps = NULL; + gboolean res = FALSE; + + if (amrparse->wide) { + GST_DEBUG_OBJECT (amrparse, "setting srcpad caps to AMR-WB"); + src_caps = gst_caps_new_simple ("audio/AMR-WB", + "channels", G_TYPE_INT, 1, "rate", G_TYPE_INT, 16000, NULL); + } else { + GST_DEBUG_OBJECT (amrparse, "setting srcpad caps to AMR-NB"); + /* Max. size of NB frame is 31 bytes, so we can set the min. frame + size to 32 (+1 for next frame header) */ + gst_base_parse_set_min_frame_size (GST_BASE_PARSE (amrparse), 32); + src_caps = gst_caps_new_simple ("audio/AMR", + "channels", G_TYPE_INT, 1, "rate", G_TYPE_INT, 8000, NULL); + } + gst_pad_use_fixed_caps (GST_BASE_PARSE (amrparse)->srcpad); + res = gst_pad_set_caps (GST_BASE_PARSE (amrparse)->srcpad, src_caps); + gst_caps_unref (src_caps); + return res; +} + + +/** + * gst_amrparse_sink_setcaps: + * @sinkpad: GstPad + * @caps: GstCaps + * + * Returns: TRUE on success. + */ +static gboolean +gst_amrparse_sink_setcaps (GstBaseParse * parse, GstCaps * caps) +{ + GstAmrParse *amrparse; + GstStructure *structure; + const gchar *name; + + amrparse = GST_AMRPARSE (parse); + structure = gst_caps_get_structure (caps, 0); + name = gst_structure_get_name (structure); + + GST_DEBUG_OBJECT (amrparse, "setcaps: %s", name); + + if (!strncmp (name, "audio/x-amr-wb-sh", 17)) { + amrparse->block_size = block_size_wb; + amrparse->wide = 1; + } else if (!strncmp (name, "audio/x-amr-nb-sh", 17)) { + amrparse->block_size = block_size_nb; + amrparse->wide = 0; + } else { + GST_WARNING ("Unknown caps"); + return FALSE; + } + + amrparse->need_header = FALSE; + gst_amrparse_set_src_caps (amrparse); + return TRUE; +} + + +/** + * gst_amrparse_update_duration: + * @amrparse: #GstAmrParse. + * + * Send duration information to base class. + */ +static void +gst_amrparse_update_duration (GstAmrParse * amrparse) +{ + GstPad *peer; + GstBaseParse *parse; + + parse = GST_BASE_PARSE (amrparse); + + /* Cannot estimate duration. No data has been passed to us yet */ + if (!amrparse->framecount) { + return; + } + + peer = gst_pad_get_peer (parse->sinkpad); + if (peer) { + GstFormat pformat = GST_FORMAT_BYTES; + guint64 bpf = amrparse->bytecount / amrparse->framecount; + gboolean qres = FALSE; + gint64 ptot; + + qres = gst_pad_query_duration (peer, &pformat, &ptot); + gst_object_unref (GST_OBJECT (peer)); + if (qres && bpf) { + gst_base_parse_set_duration (parse, GST_FORMAT_TIME, + AMR_FRAME_DURATION * ptot / bpf); + } + } +} + + +/** + * gst_amrparse_parse_header: + * @amrparse: #GstAmrParse + * @data: Header data to be parsed. + * @skipsize: Output argument where the frame size will be stored. + * + * Check if the given data contains an AMR mime header. + * + * Returns: TRUE on success. + */ +static gboolean +gst_amrparse_parse_header (GstAmrParse * amrparse, + const guint8 * data, gint * skipsize) +{ + GST_DEBUG_OBJECT (amrparse, "Parsing header data"); + + if (!memcmp (data, "#!AMR-WB\n", 9)) { + GST_DEBUG_OBJECT (amrparse, "AMR-WB detected"); + amrparse->block_size = block_size_wb; + amrparse->wide = TRUE; + *skipsize = amrparse->header = 9; + } else if (!memcmp (data, "#!AMR\n", 6)) { + GST_DEBUG_OBJECT (amrparse, "AMR-NB detected"); + amrparse->block_size = block_size_nb; + amrparse->wide = FALSE; + *skipsize = amrparse->header = 6; + } else + return FALSE; + + gst_amrparse_set_src_caps (amrparse); + return TRUE; +} + + +/** + * gst_amrparse_check_valid_frame: + * @parse: #GstBaseParse. + * @buffer: #GstBuffer. + * @framesize: Output variable where the found frame size is put. + * @skipsize: Output variable which tells how much data needs to be skipped + * until a frame header is found. + * + * Implementation of "check_valid_frame" vmethod in #GstBaseParse class. + * + * Returns: TRUE if the given data contains valid frame. + */ +gboolean +gst_amrparse_check_valid_frame (GstBaseParse * parse, + GstBuffer * buffer, guint * framesize, gint * skipsize) +{ + const guint8 *data; + gint fsize, mode, dsize; + GstAmrParse *amrparse; + + amrparse = GST_AMRPARSE (parse); + data = GST_BUFFER_DATA (buffer); + dsize = GST_BUFFER_SIZE (buffer); + + GST_LOG ("buffer: %d bytes", dsize); + + if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT)) { + /* Discontinuous stream -> drop the sync */ + amrparse->sync = FALSE; + } + + if (amrparse->need_header) { + if (dsize >= AMR_MIME_HEADER_SIZE && + gst_amrparse_parse_header (amrparse, data, skipsize)) { + amrparse->need_header = FALSE; + } else { + GST_WARNING ("media doesn't look like a AMR format"); + } + /* We return FALSE, so this frame won't get pushed forward. Instead, + the "skip" value is set, so next time we will receive a valid frame. */ + return FALSE; + } + + /* Does this look like a possible frame header candidate? */ + if ((data[0] & 0x83) == 0) { + /* Yep. Retrieve the frame size */ + mode = (data[0] >> 3) & 0x0F; + fsize = amrparse->block_size[mode] + 1; /* +1 for the header byte */ + + /* We recognize this data as a valid frame when: + * - We are in sync. There is no need for extra checks then + * - We are in EOS. There might not be enough data to check next frame + * - Sync is lost, but the following data after this frame seem + * to contain a valid header as well (and there is enough data to + * perform this check) + */ + if (amrparse->sync || amrparse->eos || + (dsize >= fsize && (data[fsize] & 0x83) == 0)) { + amrparse->sync = TRUE; + *framesize = fsize; + return TRUE; + } + } + + GST_LOG ("sync lost"); + amrparse->sync = FALSE; + return FALSE; +} + + +/** + * gst_amrparse_parse_frame: + * @parse: #GstBaseParse. + * @buffer: #GstBuffer. + * + * Implementation of "parse" vmethod in #GstBaseParse class. + * + * Returns: #GstFlowReturn defining the parsing status. + */ +GstFlowReturn +gst_amrparse_parse_frame (GstBaseParse * parse, GstBuffer * buffer) +{ + GstAmrParse *amrparse; + + amrparse = GST_AMRPARSE (parse); + + if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT)) { + gint64 btime; + gboolean r = gst_amrparse_convert (parse, GST_FORMAT_BYTES, + GST_BUFFER_OFFSET (buffer), + GST_FORMAT_TIME, &btime); + if (r) { + /* FIXME: What to do if the conversion fails? */ + amrparse->ts = btime; + } + } + + GST_BUFFER_DURATION (buffer) = AMR_FRAME_DURATION; + GST_BUFFER_TIMESTAMP (buffer) = amrparse->ts; + + if (GST_CLOCK_TIME_IS_VALID (amrparse->ts)) { + amrparse->ts += AMR_FRAME_DURATION; + } + + if (!(++amrparse->framecount % 50)) { + gst_amrparse_update_duration (amrparse); + } + amrparse->bytecount += GST_BUFFER_SIZE (buffer); + + gst_buffer_set_caps (buffer, GST_PAD_CAPS (parse->srcpad)); + return GST_FLOW_OK; +} + + +/** + * gst_amrparse_start: + * @parse: #GstBaseParse. + * + * Implementation of "start" vmethod in #GstBaseParse class. + * + * Returns: TRUE on success. + */ +gboolean +gst_amrparse_start (GstBaseParse * parse) +{ + GstAmrParse *amrparse; + + amrparse = GST_AMRPARSE (parse); + GST_DEBUG ("start"); + amrparse->need_header = TRUE; + amrparse->header = 0; + amrparse->sync = TRUE; + amrparse->eos = FALSE; + amrparse->framecount = 0; + amrparse->bytecount = 0; + amrparse->ts = 0; + return TRUE; +} + + +/** + * gst_amrparse_stop: + * @parse: #GstBaseParse. + * + * Implementation of "stop" vmethod in #GstBaseParse class. + * + * Returns: TRUE on success. + */ +gboolean +gst_amrparse_stop (GstBaseParse * parse) +{ + GstAmrParse *amrparse; + + amrparse = GST_AMRPARSE (parse); + GST_DEBUG ("stop"); + amrparse->need_header = TRUE; + amrparse->header = 0; + amrparse->ts = -1; + return TRUE; +} + + +/** + * gst_amrparse_event: + * @parse: #GstBaseParse. + * @event: #GstEvent. + * + * Implementation of "event" vmethod in #GstBaseParse class. + * + * Returns: TRUE if the event was handled and can be dropped. + */ +gboolean +gst_amrparse_event (GstBaseParse * parse, GstEvent * event) +{ + GstAmrParse *amrparse; + + amrparse = GST_AMRPARSE (parse); + GST_DEBUG ("event"); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_EOS: + amrparse->eos = TRUE; + GST_DEBUG ("EOS event"); + break; + default: + break; + } + + return parent_class->event (parse, event); +} + + +/** + * gst_amrparse_convert: + * @parse: #GstBaseParse. + * @src_format: #GstFormat describing the source format. + * @src_value: Source value to be converted. + * @dest_format: #GstFormat defining the converted format. + * @dest_value: Pointer where the conversion result will be put. + * + * Implementation of "convert" vmethod in #GstBaseParse class. + * + * Returns: TRUE if conversion was successful. + */ +gboolean +gst_amrparse_convert (GstBaseParse * parse, + GstFormat src_format, + gint64 src_value, GstFormat dest_format, gint64 * dest_value) +{ + gboolean ret = FALSE; + GstAmrParse *amrparse; + gfloat bpf; + + amrparse = GST_AMRPARSE (parse); + + /* We are not able to do any estimations until some data has been passed */ + if (!amrparse->framecount) + return FALSE; + + bpf = (gfloat) amrparse->bytecount / amrparse->framecount; + + if (src_format == GST_FORMAT_BYTES) { + if (dest_format == GST_FORMAT_TIME) { + /* BYTES -> TIME conversion */ + GST_DEBUG ("converting bytes -> time"); + + if (amrparse->framecount) { + *dest_value = AMR_FRAME_DURATION * (src_value - amrparse->header) / bpf; + GST_DEBUG ("conversion result: %" G_GINT64_FORMAT " ms", + *dest_value / GST_MSECOND); + ret = TRUE; + } + } + } else if (src_format == GST_FORMAT_TIME) { + GST_DEBUG ("converting time -> bytes"); + if (dest_format == GST_FORMAT_BYTES) { + if (amrparse->framecount) { + *dest_value = bpf * src_value / AMR_FRAME_DURATION + amrparse->header; + GST_DEBUG ("time %" G_GINT64_FORMAT " ms in bytes = %" G_GINT64_FORMAT, + src_value / GST_MSECOND, *dest_value); + ret = TRUE; + } + } + } else if (src_format == GST_FORMAT_DEFAULT) { + /* DEFAULT == frame-based */ + if (dest_format == GST_FORMAT_TIME) { + *dest_value = src_value * AMR_FRAME_DURATION; + ret = TRUE; + } else if (dest_format == GST_FORMAT_BYTES) { + } + } + + return ret; +} diff --git a/gst/audioparsers/gstamrparse.h b/gst/audioparsers/gstamrparse.h new file mode 100644 index 0000000..4cd432e --- /dev/null +++ b/gst/audioparsers/gstamrparse.h @@ -0,0 +1,87 @@ +/* GStreamer Adaptive Multi-Rate parser + * Copyright (C) 2004 Ronald Bultje + * Copyright (C) 2008 Nokia Corporation. All rights reserved. + * + * Contact: Stefan Kost + * + * 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_AMRPARSE_H__ +#define __GST_AMRPARSE_H__ + +#include +#include "gstbaseparse.h" + +G_BEGIN_DECLS + +#define GST_TYPE_AMRPARSE \ + (gst_amrparse_get_type()) +#define GST_AMRPARSE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_AMRPARSE, GstAmrParse)) +#define GST_AMRPARSE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_AMRPARSE, GstAmrParseClass)) +#define GST_IS_AMRPARSE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_AMRPARSE)) +#define GST_IS_AMRPARSE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_AMRPARSE)) + + +typedef struct _GstAmrParse GstAmrParse; +typedef struct _GstAmrParseClass GstAmrParseClass; + +/** + * GstAmrParse: + * @element: the parent element. + * @block_size: Pointer to frame size lookup table. + * @need_header: Tells whether the MIME header should be read in the beginning. + * @wide: Wideband mode. + * @eos: Indicates the EOS situation. Set when EOS event is received. + * @sync: Tells whether the parser is in sync. + * @framecount: Total amount of frames handled. + * @bytecount: Total amount of bytes handled. + * @ts: Timestamp of the current media. + * + * The opaque GstAacParse data structure. + */ +struct _GstAmrParse { + GstBaseParse element; + const gint *block_size; + gboolean need_header; + gint header; + gboolean wide; + gboolean eos; + gboolean sync; + guint64 framecount; + guint64 bytecount; + GstClockTime ts; +}; + +/** + * GstAmrParseClass: + * @parent_class: Element parent class. + * + * The opaque GstAmrParseClass data structure. + */ +struct _GstAmrParseClass { + GstBaseParseClass parent_class; +}; + +GType gst_amrparse_get_type (void); + +G_END_DECLS + +#endif /* __GST_AMRPARSE_H__ */ diff --git a/gst/audioparsers/plugin.c b/gst/audioparsers/plugin.c index caab51c..fdc0ec6 100644 --- a/gst/audioparsers/plugin.c +++ b/gst/audioparsers/plugin.c @@ -22,6 +22,7 @@ #endif #include "gstaacparse.h" +#include "gstamrparse.h" static gboolean plugin_init (GstPlugin * plugin) @@ -30,6 +31,8 @@ plugin_init (GstPlugin * plugin) ret = gst_element_register (plugin, "aacparse", GST_RANK_NONE, GST_TYPE_AACPARSE); + ret &= gst_element_register (plugin, "amrparse", + GST_RANK_PRIMARY + 1, GST_TYPE_AMRPARSE); return ret; }