From 73ce8c5b9e9a9cb27c1307dbfee300939265650c Mon Sep 17 00:00:00 2001 From: Michael Smith Date: Fri, 24 Feb 2006 19:07:10 +0000 Subject: [PATCH] Add Annodex elements from Alessendro Decina: skeleton and CMML. Original commit message from CVS: * configure.ac: * docs/plugins/gst-plugins-good-plugins-sections.txt: * ext/Makefile.am: * ext/annodex/Makefile.am: * ext/annodex/gstannodex.c: * ext/annodex/gstannodex.h: * ext/annodex/gstcmmldec.c: * ext/annodex/gstcmmldec.h: * ext/annodex/gstcmmlenc.c: * ext/annodex/gstcmmlenc.h: * ext/annodex/gstcmmlparser.c: * ext/annodex/gstcmmlparser.h: * ext/annodex/gstcmmltag.c: * ext/annodex/gstcmmltag.h: * ext/annodex/gstcmmlutils.c: * ext/annodex/gstcmmlutils.h: * ext/annodex/gstskeldec.c: * ext/annodex/gstskeldec.h: * ext/annodex/gstskeltag.c: * ext/annodex/gstskeltag.h: * tests/check/Makefile.am: * tests/check/elements/cmmldec.c: * tests/check/elements/cmmlenc.c: * tests/check/elements/skeldec.c: Add Annodex elements from Alessendro Decina: skeleton and CMML. Includes tests & docs, oh my! Passes Thomas's -good checklist entirely. Wow. --- ChangeLog | 30 + configure.ac | 15 + docs/plugins/gst-plugins-good-plugins-sections.txt | 8 + ext/Makefile.am | 7 + ext/annodex/Makefile.am | 27 + ext/annodex/gstannodex.c | 164 +++++ ext/annodex/gstannodex.h | 34 ++ ext/annodex/gstcmmldec.c | 677 +++++++++++++++++++++ ext/annodex/gstcmmldec.h | 96 +++ ext/annodex/gstcmmlenc.c | 624 +++++++++++++++++++ ext/annodex/gstcmmlenc.h | 77 +++ ext/annodex/gstcmmlparser.c | 617 +++++++++++++++++++ ext/annodex/gstcmmlparser.h | 90 +++ ext/annodex/gstcmmltag.c | 565 +++++++++++++++++ ext/annodex/gstcmmltag.h | 131 ++++ ext/annodex/gstcmmlutils.c | 376 ++++++++++++ ext/annodex/gstcmmlutils.h | 53 ++ ext/annodex/gstskeldec.c | 380 ++++++++++++ ext/annodex/gstskeldec.h | 62 ++ ext/annodex/gstskeltag.c | 371 +++++++++++ ext/annodex/gstskeltag.h | 101 +++ tests/check/Makefile.am | 5 +- tests/check/elements/cmmldec.c | 409 +++++++++++++ tests/check/elements/cmmlenc.c | 361 +++++++++++ tests/check/elements/skeldec.c | 258 ++++++++ 25 files changed, 5537 insertions(+), 1 deletion(-) create mode 100644 ext/annodex/Makefile.am create mode 100644 ext/annodex/gstannodex.c create mode 100644 ext/annodex/gstannodex.h create mode 100644 ext/annodex/gstcmmldec.c create mode 100644 ext/annodex/gstcmmldec.h create mode 100644 ext/annodex/gstcmmlenc.c create mode 100644 ext/annodex/gstcmmlenc.h create mode 100644 ext/annodex/gstcmmlparser.c create mode 100644 ext/annodex/gstcmmlparser.h create mode 100644 ext/annodex/gstcmmltag.c create mode 100644 ext/annodex/gstcmmltag.h create mode 100644 ext/annodex/gstcmmlutils.c create mode 100644 ext/annodex/gstcmmlutils.h create mode 100644 ext/annodex/gstskeldec.c create mode 100644 ext/annodex/gstskeldec.h create mode 100644 ext/annodex/gstskeltag.c create mode 100644 ext/annodex/gstskeltag.h create mode 100644 tests/check/elements/cmmldec.c create mode 100644 tests/check/elements/cmmlenc.c create mode 100644 tests/check/elements/skeldec.c diff --git a/ChangeLog b/ChangeLog index 38f1b7c..de476b1 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,35 @@ 2006-02-24 Michael Smith + * configure.ac: + * docs/plugins/gst-plugins-good-plugins-sections.txt: + * ext/Makefile.am: + * ext/annodex/Makefile.am: + * ext/annodex/gstannodex.c: + * ext/annodex/gstannodex.h: + * ext/annodex/gstcmmldec.c: + * ext/annodex/gstcmmldec.h: + * ext/annodex/gstcmmlenc.c: + * ext/annodex/gstcmmlenc.h: + * ext/annodex/gstcmmlparser.c: + * ext/annodex/gstcmmlparser.h: + * ext/annodex/gstcmmltag.c: + * ext/annodex/gstcmmltag.h: + * ext/annodex/gstcmmlutils.c: + * ext/annodex/gstcmmlutils.h: + * ext/annodex/gstskeldec.c: + * ext/annodex/gstskeldec.h: + * ext/annodex/gstskeltag.c: + * ext/annodex/gstskeltag.h: + * tests/check/Makefile.am: + * tests/check/elements/cmmldec.c: + * tests/check/elements/cmmlenc.c: + * tests/check/elements/skeldec.c: + Add Annodex elements from Alessendro Decina: skeleton and CMML. + Includes tests & docs, oh my! Passes Thomas's -good checklist + entirely. Wow. + +2006-02-24 Michael Smith + * autogen.sh: Check for automake 1.9 as well. diff --git a/configure.ac b/configure.ac index d540e4d..87b8d69 100644 --- a/configure.ac +++ b/configure.ac @@ -133,6 +133,8 @@ dnl common/m4/gst-arch.m4 dnl check CPU type GST_ARCH +AC_SUBST(GST_CTRL_LIBS) + dnl Determine endianness AC_C_BIGENDIAN @@ -326,6 +328,18 @@ GST_CHECK_FEATURE(AALIB, [aasink plug-in], aasink, [ AS_SCRUB_INCLUDE(AALIB_CFLAGS) ]) +dnl *** annodex *** +translit(dnm, m, l) AM_CONDITIONAL(USE_ANNODEX, true) +GST_CHECK_FEATURE(ANNODEX, [annodex plug-in], skeldec cmmlenc cmmldec, [ + PKG_CHECK_MODULES(XML, libxml-2.0 >= 2.4.9, [ + HAVE_ANNODEX=yes + AC_SUBST(XML_CFLAGS) + AC_SUBST(XML_LIBS) + ], [ + HAVE_ANNODEX=no + ]) +]) + dnl *** cairo *** translit(dnm, m, l) AM_CONDITIONAL(USE_CAIRO, true) GST_CHECK_FEATURE(CAIRO, [cairo plug-in], cairo, [ @@ -618,6 +632,7 @@ gst/flx/Makefile ext/jpeg/Makefile ext/Makefile ext/aalib/Makefile +ext/annodex/Makefile ext/cairo/Makefile ext/cdio/Makefile ext/dv/Makefile diff --git a/docs/plugins/gst-plugins-good-plugins-sections.txt b/docs/plugins/gst-plugins-good-plugins-sections.txt index 73c8980..1a41527 100644 --- a/docs/plugins/gst-plugins-good-plugins-sections.txt +++ b/docs/plugins/gst-plugins-good-plugins-sections.txt @@ -31,6 +31,14 @@ GstCairoTimeOverlayClass
+element-cmmldec +GstCmmlDec +cmmldec + +GstCmmlDecClass +
+ +
element-cdiocddasrc GstCdioCddaSrc cdiocddasrc diff --git a/ext/Makefile.am b/ext/Makefile.am index 438c8d7..e8bdd8c 100644 --- a/ext/Makefile.am +++ b/ext/Makefile.am @@ -4,6 +4,12 @@ else AALIB_DIR = endif +if USE_ANNODEX +ANNODEX_DIR = annodex +else +ANNODEX_DIR = +endif + if USE_CAIRO CAIRO_DIR = cairo else @@ -108,6 +114,7 @@ endif SUBDIRS = \ $(AALIB_DIR) \ + $(ANNODEX_DIR) \ $(CAIRO_DIR) \ $(CDIO_DIR) \ $(DV1394_DIR) \ diff --git a/ext/annodex/Makefile.am b/ext/annodex/Makefile.am new file mode 100644 index 0000000..f4e0388 --- /dev/null +++ b/ext/annodex/Makefile.am @@ -0,0 +1,27 @@ +# plugindir is set in configure + +# change libgstplugin.la to something more suitable +plugin_LTLIBRARIES = libgstannodex.la + +# for the next set of variables, rename the prefix if you renamed the .la + +# sources used to compile this plug-in +libgstannodex_la_SOURCES = \ + gstannodex.c \ + gstcmmlutils.c \ + gstcmmldec.c \ + gstcmmlenc.c \ + gstcmmltag.c \ + gstcmmlparser.c \ + gstskeldec.c \ + gstskeltag.c + +# flags used to compile this plugin +# we use the GST_LIBS flags because we might be using plug-in libs +libgstannodex_la_CFLAGS = $(GST_CFLAGS) $(XML_CFLAGS) +libgstannodex_la_LIBADD = $(GST_BASE_LIBS) $(GST_LIBS) $(XML_LIBS) +libgstannodex_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) + +# headers we need but don't want installed +noinst_HEADERS = gstannodex.h gstcmmlutils.h gstcmmltag.h gstcmmlparser.h \ + gstcmmldec.h gstskeldec.h gstcmmlenc.h diff --git a/ext/annodex/gstannodex.c b/ext/annodex/gstannodex.c new file mode 100644 index 0000000..4c32552 --- /dev/null +++ b/ext/annodex/gstannodex.c @@ -0,0 +1,164 @@ +/* + * gstannodex.c - GStreamer annodex plugin + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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 "gstcmmlenc.h" +#include "gstcmmldec.h" +#include "gstskeldec.h" + +GstClockTime +gst_annodex_granule_to_time (gint64 granulepos, gint64 granulerate_n, + gint64 granulerate_d, guint8 granuleshift) +{ + gint64 keyindex, keyoffset; + gint64 granulerate; + GstClockTime res; + + if (granulepos == -1) + return GST_CLOCK_TIME_NONE; + + if (granulepos == 0 || granulerate_n == 0 || granulerate_d == 0) + return 0; + + if (granuleshift != 0) { + keyindex = granulepos >> granuleshift; + keyoffset = granulepos - (keyindex << granuleshift); + granulepos = keyindex + keyoffset; + } + + /* GST_SECOND / granulerate_n / granulerate_d */ + granulerate = gst_util_uint64_scale (GST_SECOND, + granulerate_n, granulerate_d); + + /* granulepos * granulerate */ + res = gst_util_uint64_scale (granulepos, granulerate, 1); + + return res; +} + +GValueArray * +gst_annodex_parse_headers (const gchar * headers) +{ + GValueArray *array; + GValue val = { 0 }; + gchar *header_name = NULL; + gchar *header_value = NULL; + gchar *line, *column, *space, *tmp; + gchar **lines; + gint i = 0; + + array = g_value_array_new (0); + g_value_init (&val, G_TYPE_STRING); + + lines = g_strsplit (headers, "\r\n", 0); + line = lines[i]; + while (line != NULL && *line != '\0') { + if (line[0] == '\t' || line[0] == ' ') { + /* WSP: continuation line */ + if (header_value == NULL) + /* continuation line without a previous value */ + goto fail; + + tmp = g_strjoin (" ", header_value, g_strstrip (line), NULL); + g_free (header_value); + header_value = tmp; + } else { + if (header_name) { + g_value_take_string (&val, header_name); + g_value_array_append (array, &val); + g_value_take_string (&val, header_value); + g_value_array_append (array, &val); + } + /* search the column starting from line[1] as an header name can't be + * empty */ + column = g_strstr_len (line + 1, strlen (line) - 1, ":"); + if (column == NULL) + /* bad syntax */ + goto fail; + + if (*(space = column + 1) != ' ') + /* bad syntax */ + goto fail; + + header_name = g_strndup (line, column - line); + header_value = g_strdup (space + 1); + } + + line = lines[++i]; + } + + if (header_name) { + g_value_take_string (&val, header_name); + g_value_array_append (array, &val); + g_value_take_string (&val, header_value); + g_value_array_append (array, &val); + } + + g_value_unset (&val); + g_strfreev (lines); + + return array; + +fail: + GST_WARNING ("could not parse annodex headers"); + g_free (header_name); + g_free (header_value); + g_strfreev (lines); + g_value_array_free (array); + g_value_unset (&val); + return NULL; +} + +static gboolean +plugin_init (GstPlugin * plugin) +{ + + gst_tag_register (GST_TAG_CMML_STREAM, GST_TAG_FLAG_META, + GST_TYPE_CMML_TAG_STREAM, "cmml-stream", "annodex CMML stream tag", NULL); + + gst_tag_register (GST_TAG_CMML_HEAD, GST_TAG_FLAG_META, + GST_TYPE_CMML_TAG_HEAD, "cmml-head", "annodex CMML head tag", NULL); + + gst_tag_register (GST_TAG_CMML_CLIP, GST_TAG_FLAG_META, + GST_TYPE_CMML_TAG_CLIP, "cmml-clip", "annodex CMML clip tag", NULL); + + if (!gst_cmml_enc_plugin_init (plugin)) + return FALSE; + + if (!gst_cmml_dec_plugin_init (plugin)) + return FALSE; + + if (!gst_skel_dec_plugin_init (plugin)) + return FALSE; + + return TRUE; +} + +GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, + GST_VERSION_MINOR, + "annodex", + "annodex stream manipulation (info about annodex: http://www.annodex.net)", + plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) diff --git a/ext/annodex/gstannodex.h b/ext/annodex/gstannodex.h new file mode 100644 index 0000000..ca35e36 --- /dev/null +++ b/ext/annodex/gstannodex.h @@ -0,0 +1,34 @@ +/* + * gstannodex.h - GStreamer annodex utility functions + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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_ANNODEX_H__ +#define __GST_ANNODEX_H__ + +#include + +GstClockTime gst_annodex_granule_to_time (gint64 granulepos, + gint64 granulerate_n, gint64 granulerate_d, guint8 granuleshift); +gchar *gst_annodex_time_to_npt (GstClockTime time); +GValueArray *gst_annodex_parse_headers (const gchar * headers); + +#endif /* __GST_ANNODEX_H__ */ diff --git a/ext/annodex/gstcmmldec.c b/ext/annodex/gstcmmldec.c new file mode 100644 index 0000000..028d4e4 --- /dev/null +++ b/ext/annodex/gstcmmldec.c @@ -0,0 +1,677 @@ +/* + * gstcmmldec.c - GStreamer annodex CMML decoder + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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-cmmldec + * @see_also: cmmlenc, oggdemux + * + * + * + * Cmmldec extracts a CMML document from a CMML bitstream.CMML is + * an XML markup language for time-continuous data maintained by the Annodex Foundation. + * + * Example pipeline + * + * gst-launch -v filesrc location=annotated.ogg ! oggdemux ! cmmldec ! filesink location=annotations.cmml + * + * + */ + + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include + +#include "gstannodex.h" +#include "gstcmmltag.h" +#include "gstcmmldec.h" +#include "gstcmmlutils.h" + +GST_DEBUG_CATEGORY (cmmldec); +#define GST_CAT_DEFAULT cmmldec + +#define CMML_IDENT_HEADER_SIZE 29 + +enum +{ + ARG_0, + GST_CMML_DEC_WAIT_CLIP_END +}; + +enum +{ + LAST_SIGNAL +}; + +static GstElementDetails gst_cmml_dec_details = { + "cmmldec: Decodes CMML streams", "Codec/Decoder", + "Decodes CMML streams", + "Alessandro Decina ", +}; + +static GstStaticPadTemplate gst_cmml_dec_src_factory = +GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("text/xml") + ); + +static GstStaticPadTemplate gst_cmml_dec_sink_factory = +GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("text/x-cmml") + ); + +/* GstCmmlDec */ +GST_BOILERPLATE (GstCmmlDec, gst_cmml_dec, GstElement, GST_TYPE_ELEMENT); +static void gst_cmml_dec_get_property (GObject * dec, guint property_id, + GValue * value, GParamSpec * pspec); +static void gst_cmml_dec_set_property (GObject * dec, guint property_id, + const GValue * value, GParamSpec * pspec); +static const GstQueryType *gst_cmml_dec_query_types (GstPad * pad); +static gboolean gst_cmml_dec_sink_query (GstPad * pad, GstQuery * query); +static gboolean gst_cmml_dec_sink_event (GstPad * pad, GstEvent * event); +static gboolean gst_cmml_dec_convert (GstPad * pad, GstFormat src_fmt, + gint64 src_val, GstFormat * dest_fmt, gint64 * dest_val); +static GstStateChangeReturn gst_cmml_dec_change_state (GstElement * element, + GstStateChange transition); +static GstFlowReturn gst_cmml_dec_chain (GstPad * pad, GstBuffer * buffer); + +static GstCmmlPacketType gst_cmml_dec_parse_packet_type (GstCmmlDec * dec, + GstBuffer * buffer); +static void gst_cmml_dec_parse_ident_header (GstCmmlDec * dec, GstBuffer * buf); +static void gst_cmml_dec_parse_first_header (GstCmmlDec * dec, GstBuffer * buf); +static void gst_cmml_dec_parse_preamble (GstCmmlDec * dec, + guchar * preamble, guchar * cmml_root_element); +static void gst_cmml_dec_parse_xml (GstCmmlDec * dec, + guchar * data, guint size); +static void gst_cmml_dec_parse_head (GstCmmlDec * dec, GstCmmlTagHead * head); +static void gst_cmml_dec_parse_clip (GstCmmlDec * dec, GstCmmlTagClip * clip); + +static GstFlowReturn gst_cmml_dec_new_buffer (GstCmmlDec * dec, + guchar * data, gint size, GstBuffer ** buffer); +static void gst_cmml_dec_push_clip (GstCmmlDec * dec, GstCmmlTagClip * clip); +static void gst_cmml_dec_send_clip_tag (GstCmmlDec * dec, + GstCmmlTagClip * clip); + +static void +gst_cmml_dec_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_cmml_dec_sink_factory)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&gst_cmml_dec_src_factory)); + gst_element_class_set_details (element_class, &gst_cmml_dec_details); +} + +static void +gst_cmml_dec_class_init (GstCmmlDecClass * dec_class) +{ + GObjectClass *klass = G_OBJECT_CLASS (dec_class); + + GST_ELEMENT_CLASS (klass)->change_state = gst_cmml_dec_change_state; + + klass->set_property = gst_cmml_dec_set_property; + klass->get_property = gst_cmml_dec_get_property; + + g_object_class_install_property (klass, GST_CMML_DEC_WAIT_CLIP_END, + g_param_spec_boolean ("wait-clip-end-time", + "Wait clip end time", + "Send a tag for a clip when the clip ends, setting its end-time. " + "Use when you need to know both clip's start-time and end-time.", + FALSE, G_PARAM_READWRITE)); +} + +static void +gst_cmml_dec_init (GstCmmlDec * dec, GstCmmlDecClass * klass) +{ + dec->sinkpad = + gst_pad_new_from_static_template (&gst_cmml_dec_sink_factory, "sink"); + gst_pad_set_chain_function (dec->sinkpad, gst_cmml_dec_chain); + gst_pad_set_query_type_function (dec->sinkpad, gst_cmml_dec_query_types); + gst_pad_set_query_function (dec->sinkpad, gst_cmml_dec_sink_query); + gst_pad_set_event_function (dec->sinkpad, gst_cmml_dec_sink_event); + gst_element_add_pad (GST_ELEMENT (dec), dec->sinkpad); + + dec->srcpad = + gst_pad_new_from_static_template (&gst_cmml_dec_src_factory, "src"); + gst_element_add_pad (GST_ELEMENT (dec), dec->srcpad); + + dec->wait_clip_end = FALSE; +} + +static void +gst_cmml_dec_get_property (GObject * object, guint property_id, + GValue * value, GParamSpec * pspec) +{ + GstCmmlDec *dec = GST_CMML_DEC (object); + + switch (property_id) { + case GST_CMML_DEC_WAIT_CLIP_END: + g_value_set_boolean (value, dec->wait_clip_end); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +gst_cmml_dec_set_property (GObject * object, guint property_id, + const GValue * value, GParamSpec * pspec) +{ + GstCmmlDec *dec = GST_CMML_DEC (object); + + switch (property_id) { + case GST_CMML_DEC_WAIT_CLIP_END: + dec->wait_clip_end = g_value_get_boolean (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (dec, property_id, pspec); + } +} + +static GstStateChangeReturn +gst_cmml_dec_change_state (GstElement * element, GstStateChange transition) +{ + GstCmmlDec *dec = GST_CMML_DEC (element); + GstStateChangeReturn res; + + switch (transition) { + case GST_STATE_CHANGE_READY_TO_PAUSED: + dec->parser = gst_cmml_parser_new (GST_CMML_PARSER_DECODE); + dec->parser->user_data = dec; + dec->parser->preamble_callback = + (GstCmmlParserPreambleCallback) gst_cmml_dec_parse_preamble; + dec->parser->head_callback = + (GstCmmlParserHeadCallback) gst_cmml_dec_parse_head; + dec->parser->clip_callback = + (GstCmmlParserClipCallback) gst_cmml_dec_parse_clip; + dec->major = -1; + dec->minor = -1; + dec->granulerate_n = -1; + dec->granulerate_d = -1; + dec->granuleshift = 0; + dec->granulepos = 0; + dec->flow_return = GST_FLOW_OK; + dec->sent_root = FALSE; + dec->tracks = gst_cmml_track_list_new (); + break; + default: + break; + } + + res = parent_class->change_state (element, transition); + + switch (transition) { + case GST_STATE_CHANGE_PAUSED_TO_READY: + gst_cmml_parser_free (dec->parser); + gst_cmml_track_list_destroy (dec->tracks); + break; + default: + break; + } + + return res; +} + +static const GstQueryType * +gst_cmml_dec_query_types (GstPad * pad) +{ + static const GstQueryType query_types[] = { + GST_QUERY_CONVERT, + 0 + }; + + return query_types; +} + +static gboolean +gst_cmml_dec_sink_query (GstPad * pad, GstQuery * query) +{ + gboolean res = FALSE; + + switch (GST_QUERY_TYPE (query)) { + case GST_QUERY_CONVERT: + { + GstFormat src_fmt, dest_fmt; + gint64 src_val, dest_val; + + gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val); + res = gst_cmml_dec_convert (pad, src_fmt, src_val, &dest_fmt, &dest_val); + if (res) + gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val); + break; + } + default: + break; + } + + return res; +} + +static gboolean +gst_cmml_dec_convert (GstPad * pad, + GstFormat src_fmt, gint64 src_val, GstFormat * dest_fmt, gint64 * dest_val) +{ + GstCmmlDec *dec = GST_CMML_DEC (GST_PAD_PARENT (pad)); + gboolean res = FALSE; + + switch (src_fmt) { + case GST_FORMAT_DEFAULT: + switch (*dest_fmt) { + case GST_FORMAT_TIME: + { + *dest_val = gst_annodex_granule_to_time (src_val, dec->granulerate_n, + dec->granulerate_d, dec->granuleshift); + res = TRUE; + break; + } + default: + break; + } + break; + default: + break; + } + + return res; +} + +static gboolean +gst_cmml_dec_sink_event (GstPad * pad, GstEvent * event) +{ + GstCmmlDec *dec = GST_CMML_DEC (GST_PAD_PARENT (pad)); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_EOS: + { + GstBuffer *buffer; + GstCmmlTagClip *clip; + GList *clips, *walk; + + GST_INFO_OBJECT (dec, "got EOS, flushing clips"); + + /* since we output a clip when the next one in the same track is found, on + * EOS we need to output the last clip (if any) of every track + */ + clips = gst_cmml_track_list_get_clips (dec->tracks); + for (walk = clips; walk; walk = g_list_next (walk)) { + clip = GST_CMML_TAG_CLIP (walk->data); + gst_cmml_dec_push_clip (dec, clip); + if (dec->wait_clip_end) { + clip->end_time = dec->timestamp; + gst_cmml_dec_send_clip_tag (dec, clip); + } + } + g_list_free (clips); + + /* send the cmml end tag */ + dec->flow_return = gst_cmml_dec_new_buffer (dec, + (guchar *) "", strlen (""), &buffer); + + if (dec->flow_return == GST_FLOW_OK) + dec->flow_return = gst_pad_push (dec->srcpad, buffer); + + break; + } + default: + break; + } + + return gst_pad_event_default (pad, event); +} + +static GstFlowReturn +gst_cmml_dec_chain (GstPad * pad, GstBuffer * buffer) +{ + GstCmmlDec *dec = GST_CMML_DEC (GST_PAD_PARENT (pad)); + GstCmmlPacketType packet; + + if (GST_BUFFER_SIZE (buffer) == 0) { + /* the EOS page could be empty */ + dec->flow_return = GST_FLOW_OK; + goto done; + } + + dec->granulepos = GST_BUFFER_OFFSET_END (buffer); + dec->timestamp = gst_annodex_granule_to_time (dec->granulepos, + dec->granulerate_n, dec->granulerate_d, dec->granuleshift); + + /* identify the packet type */ + packet = gst_cmml_dec_parse_packet_type (dec, buffer); + + /* handle the packet. the handler will set dec->flow_return */ + switch (packet) { + case GST_CMML_PACKET_IDENT_HEADER: + gst_cmml_dec_parse_ident_header (dec, buffer); + break; + case GST_CMML_PACKET_FIRST_HEADER: + gst_cmml_dec_parse_first_header (dec, buffer); + break; + case GST_CMML_PACKET_SECOND_HEADER: + case GST_CMML_PACKET_CLIP: + gst_cmml_dec_parse_xml (dec, + GST_BUFFER_DATA (buffer), GST_BUFFER_SIZE (buffer)); + break; + case GST_CMML_PACKET_UNKNOWN: + default: + GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL), ("unknown packet type")); + dec->flow_return = GST_FLOW_ERROR; + } + +done: + gst_buffer_unref (buffer); + return dec->flow_return; +} + +/* finds the packet type of the buffer + */ +static GstCmmlPacketType +gst_cmml_dec_parse_packet_type (GstCmmlDec * dec, GstBuffer * buffer) +{ + GstCmmlPacketType packet_type = GST_CMML_PACKET_UNKNOWN; + gchar *data = (gchar *) GST_BUFFER_DATA (buffer); + guint size = GST_BUFFER_SIZE (buffer); + + if (size >= 8 && !memcmp (data, "CMML\0\0\0\0", 8)) { + packet_type = GST_CMML_PACKET_IDENT_HEADER; + } else if (size >= 5) { + if (!strncmp (data, "srcpad, GST_BUFFER_OFFSET_NONE, + size, gst_static_pad_template_get_caps (&gst_cmml_dec_src_factory), + buffer); + + if (res == GST_FLOW_OK) { + if (data) + memcpy (GST_BUFFER_DATA (*buffer), data, size); + GST_BUFFER_TIMESTAMP (*buffer) = dec->timestamp; + } + + return res; +} + +/* parses the first CMML packet (the ident header) + */ +static void +gst_cmml_dec_parse_ident_header (GstCmmlDec * dec, GstBuffer * buffer) +{ + guint8 *data = GST_BUFFER_DATA (buffer); + + /* the ident header has a fixed length */ + if (GST_BUFFER_SIZE (buffer) != CMML_IDENT_HEADER_SIZE) { + GST_ELEMENT_ERROR (dec, STREAM, DECODE, + (NULL), ("wrong ident header size: %d", GST_BUFFER_SIZE (buffer))); + dec->flow_return = GST_FLOW_ERROR; + + return; + } + + data += 8; + dec->major = GST_READ_UINT16_LE (data); + data += 2; + dec->minor = GST_READ_UINT16_LE (data); + data += 2; + dec->granulerate_n = GST_READ_UINT64_LE (data); + data += 8; + dec->granulerate_d = GST_READ_UINT64_LE (data); + data += 8; + dec->granuleshift = GST_READ_UINT8 (data); + + GST_INFO_OBJECT (dec, "bitstream initialized " + "(major: %" G_GINT16_FORMAT " minor: %" G_GINT16_FORMAT + " granulerate_n: %" G_GINT64_FORMAT " granulerate_d: %" G_GINT64_FORMAT + " granuleshift: %d)", + dec->major, dec->minor, + dec->granulerate_n, dec->granulerate_d, dec->granuleshift); + + dec->flow_return = GST_FLOW_OK; +} + +/* parses the first secondary header. + * the first secondary header contains the xml version, the doctype and the + * optional "cmml" processing instruction. + */ +static void +gst_cmml_dec_parse_first_header (GstCmmlDec * dec, GstBuffer * buffer) +{ + gst_cmml_dec_parse_xml (dec, + GST_BUFFER_DATA (buffer), GST_BUFFER_SIZE (buffer)); + + /* if there is a processing instruction, gst_cmml_dec_parse_preamble + * will be triggered. Otherwise we need to call it manually. + */ + if (!GST_FLOW_IS_FATAL (dec->flow_return) && !dec->sent_root) { + gst_cmml_dec_parse_preamble (dec, GST_BUFFER_DATA (buffer), + (guchar *) ""); + } +} + +/* feeds data into the cmml parser. + */ +static void +gst_cmml_dec_parse_xml (GstCmmlDec * dec, guchar * data, guint size) +{ + GError *err = NULL; + + if (!gst_cmml_parser_parse_chunk (dec->parser, (gchar *) data, size, &err)) { + GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL), (err->message)); + g_error_free (err); + dec->flow_return = GST_FLOW_ERROR; + } +} + +static void +gst_cmml_dec_parse_preamble (GstCmmlDec * dec, guchar * preamble, + guchar * root_element) +{ + GstBuffer *buffer; + guchar *encoded_preamble; + + encoded_preamble = (guchar *) g_strconcat ((gchar *) preamble, + (gchar *) root_element, NULL); + + /* send the root element to the internal parser */ + gst_cmml_dec_parse_xml (dec, root_element, strlen ((gchar *) root_element)); + + /* push the root element */ + dec->flow_return = gst_cmml_dec_new_buffer (dec, + encoded_preamble, strlen ((gchar *) encoded_preamble), &buffer); + if (dec->flow_return != GST_FLOW_OK) + goto done; + + dec->flow_return = gst_pad_push (dec->srcpad, buffer); + if (!GST_FLOW_IS_FATAL (dec->flow_return)) { + GST_INFO_OBJECT (dec, "preamble parsed"); + dec->sent_root = TRUE; + } + +done: + g_free (encoded_preamble); + return; +} + +/* outputs the cmml head element and send TITLE and CMML_HEAD tags. + * This callback is registered with dec->parser. It is called when the + * head element is parsed. + */ +static void +gst_cmml_dec_parse_head (GstCmmlDec * dec, GstCmmlTagHead * head) +{ + GstTagList *tags; + GValue str_val = { 0 }, title_val = { + 0}; + guchar *head_str; + GstBuffer *buffer; + + GST_DEBUG_OBJECT (dec, "found CMML head (title: %s base: %s)", + head->title, head->base); + + /* create the GST_TAG_TITLE tag */ + g_value_init (&str_val, G_TYPE_STRING); + g_value_init (&title_val, gst_tag_get_type (GST_TAG_TITLE)); + g_value_set_string (&str_val, (gchar *) head->title); + g_value_transform (&str_val, &title_val); + + tags = gst_tag_list_new (); + gst_tag_list_add_values (tags, GST_TAG_MERGE_APPEND, + GST_TAG_TITLE, &title_val, NULL); + gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, GST_TAG_CMML_HEAD, head, NULL); + gst_element_found_tags_for_pad (GST_ELEMENT (dec), dec->srcpad, tags); + + g_value_unset (&str_val); + g_value_unset (&title_val); + + head_str = gst_cmml_parser_tag_head_to_string (dec->parser, head); + + dec->flow_return = gst_cmml_dec_new_buffer (dec, + head_str, strlen ((gchar *) head_str), &buffer); + g_free (head_str); + if (dec->flow_return == GST_FLOW_OK) + dec->flow_return = gst_pad_push (dec->srcpad, buffer); +} + +/* send a TAG_MESSAGE event for a clip */ +static void +gst_cmml_dec_send_clip_tag (GstCmmlDec * dec, GstCmmlTagClip * clip) +{ + GstTagList *tags; + + GST_DEBUG_OBJECT (dec, "sending clip tag %s", clip->id); + + tags = gst_tag_list_new (); + gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, GST_TAG_CMML_CLIP, clip, NULL); + gst_element_found_tags_for_pad (GST_ELEMENT (dec), dec->srcpad, tags); +} + +/* push the string representation of a clip */ +static void +gst_cmml_dec_push_clip (GstCmmlDec * dec, GstCmmlTagClip * clip) +{ + GstBuffer *buffer; + guchar *clip_str; + + GST_DEBUG_OBJECT (dec, "pushing clip %s", clip->id); + + clip_str = gst_cmml_parser_tag_clip_to_string (dec->parser, clip); + dec->flow_return = gst_cmml_dec_new_buffer (dec, + clip_str, strlen ((gchar *) clip_str), &buffer); + if (dec->flow_return == GST_FLOW_OK) + dec->flow_return = gst_pad_push (dec->srcpad, buffer); + + g_free (clip_str); +} + +/* decode a clip tag + * this callback is registered with dec->parser. It is called whenever a + * clip is parsed. + */ +static void +gst_cmml_dec_parse_clip (GstCmmlDec * dec, GstCmmlTagClip * clip) +{ + GstCmmlTagClip *prev_clip; + + dec->flow_return = GST_FLOW_OK; + + if (clip->empty) + GST_INFO_OBJECT (dec, "parsing empty clip"); + else + GST_INFO_OBJECT (dec, "parsing clip (id: %s)", clip->id); + + clip->start_time = dec->timestamp; + if (clip->start_time == GST_CLOCK_TIME_NONE) { + GST_ELEMENT_ERROR (dec, STREAM, DECODE, + (NULL), ("invalid clip start time")); + + dec->flow_return = GST_FLOW_ERROR; + return; + } + + /* get the last clip in the current track */ + prev_clip = gst_cmml_track_list_get_track_last_clip (dec->tracks, + (gchar *) clip->track); + if (prev_clip) { + /* output the previous clip */ + if (clip->empty) + /* the current clip marks the end of the previous one */ + prev_clip->end_time = clip->start_time; + + gst_cmml_dec_push_clip (dec, prev_clip); + } + + if (dec->wait_clip_end) { + /* now it's time to send the tag for the previous clip */ + if (prev_clip) { + prev_clip->end_time = clip->start_time; + gst_cmml_dec_send_clip_tag (dec, prev_clip); + } + } else if (!clip->empty) { + /* send the tag for the current clip */ + gst_cmml_dec_send_clip_tag (dec, clip); + } + + if (prev_clip) + gst_cmml_track_list_del_clip (dec->tracks, prev_clip); + + if (!clip->empty) + if (!gst_cmml_track_list_has_clip (dec->tracks, clip)) + gst_cmml_track_list_add_clip (dec->tracks, clip); +} + +gboolean +gst_cmml_dec_plugin_init (GstPlugin * plugin) +{ + if (!gst_element_register (plugin, "cmmldec", GST_RANK_PRIMARY, + GST_TYPE_CMML_DEC)) + return FALSE; + + GST_DEBUG_CATEGORY_INIT (cmmldec, "cmmldec", 0, + "annodex CMML decoding element"); + + return TRUE; +} diff --git a/ext/annodex/gstcmmldec.h b/ext/annodex/gstcmmldec.h new file mode 100644 index 0000000..089f912 --- /dev/null +++ b/ext/annodex/gstcmmldec.h @@ -0,0 +1,96 @@ +/* + * gstcmmldec.h - GStreamer annodex CMML decoder + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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_CMML_DEC_H__ +#define __GST_CMML_DEC_H__ + +#include +#include +#include + +#include "gstcmmlparser.h" + +/* GstCmmlDec */ +#define GST_TYPE_CMML_DEC (gst_cmml_dec_get_type()) +#define GST_CMML_DEC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_CMML_DEC, GstCmmlDec)) +#define GST_CMML_DEC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_CMML_DEC, GstCmmlDec)) +#define GST_IS_CMML_DEC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_CMML_DEC)) +#define GST_IS_CMML_DEC_CLASS(obj) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_CMML_DEC)) +#define GST_CMML_DEC_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_CMML_DEC, GstCmmlDecClass)) + +typedef struct _GstCmmlDec GstCmmlDec; +typedef struct _GstCmmlDecClass GstCmmlDecClass; +typedef enum _GstCmmlPacketType GstCmmlPacketType; + +enum _GstCmmlPacketType +{ + GST_CMML_PACKET_UNKNOWN, + GST_CMML_PACKET_IDENT_HEADER, + GST_CMML_PACKET_FIRST_HEADER, + GST_CMML_PACKET_SECOND_HEADER, + GST_CMML_PACKET_CLIP +}; + +struct _GstCmmlDec +{ + GstElement element; + + /* element part */ + GstPad *sinkpad; + GstPad *srcpad; + + /* bitstream part */ + gint16 major; /* bitstream version major */ + gint16 minor; /* bitstream version minor */ + gint64 granulerate_n; /* bitrstream granulerate numerator */ + gint64 granulerate_d; /* bitstream granulerate denominator */ + gint8 granuleshift; /* bitstreamgranuleshift */ + gint64 granulepos; /* bitstream granule position */ + GstClockTime timestamp; /* timestamp of the last buffer */ + + /* decoder part */ + GstCmmlParser *parser; /* cmml parser */ + gboolean sent_root; + GstFlowReturn flow_return; /* _chain return value */ + gboolean wait_clip_end; /* when TRUE, the GST_TAG_MESSAGE for a + * clip is sent when the next clip (or EOS) + * is found, so that the clip end-time is + * known. This is useful for pre-extracting + * the clips. + */ + GHashTable *tracks; +}; + +struct _GstCmmlDecClass +{ + GstElementClass parent_class; +}; + +gboolean gst_cmml_dec_plugin_init (GstPlugin * plugin); + +#endif /* __GST_CMML_DEC_H__ */ diff --git a/ext/annodex/gstcmmlenc.c b/ext/annodex/gstcmmlenc.c new file mode 100644 index 0000000..7bc98bc --- /dev/null +++ b/ext/annodex/gstcmmlenc.c @@ -0,0 +1,624 @@ +/* + * gstcmmlenc.c - GStreamer CMML encoder + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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-cmmlenc + * @see_also: cmmldec, oggmux + * + * + * Cmmlenc encodes a CMML document into a CMML stream. CMML is + * an XML markup language for time-continuous data maintained by the Annodex Foundation. + * + * Example pipeline + * + * gst-launch -v filesrc location=annotations.cmml ! cmmlenc ! oggmux name=mux ! filesink location=annotated.ogg + * + * + */ + + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include "gstcmmlenc.h" +#include "gstannodex.h" + +GST_DEBUG_CATEGORY (cmmlenc); +#define GST_CAT_DEFAULT cmmlenc + +#define CMML_IDENT_HEADER_SIZE 29 + +enum +{ + ARG_0, + GST_CMML_ENC_GRANULERATE_N, + GST_CMML_ENC_GRANULERATE_D, + GST_CMML_ENC_GRANULESHIFT +}; + +enum +{ + LAST_SIGNAL +}; + +static GstElementDetails gst_cmml_enc_details = { + "cmmlenc: Encodes CMML streams", "Codec/Encoder", + "Encodes CMML streams", + "Alessandro Decina ", +}; + +static GstStaticPadTemplate gst_cmml_enc_src_factory = +GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("text/x-cmml") + ); + +static GstStaticPadTemplate gst_cmml_enc_sink_factory = +GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("text/xml") + ); + +GST_BOILERPLATE (GstCmmlEnc, gst_cmml_enc, GstElement, GST_TYPE_ELEMENT); +static void gst_cmml_enc_get_property (GObject * object, guint property_id, + GValue * value, GParamSpec * pspec); +static void gst_cmml_enc_set_property (GObject * object, guint property_id, + const GValue * value, GParamSpec * pspec); +static gboolean gst_cmml_enc_sink_event (GstPad * pad, GstEvent * event); +static GstStateChangeReturn gst_cmml_enc_change_state (GstElement * element, + GstStateChange transition); +static GstFlowReturn gst_cmml_enc_chain (GstPad * pad, GstBuffer * buffer); +static void gst_cmml_enc_parse_preamble (GstCmmlEnc * enc, + guchar * preamble, guchar * processing_instruction); +static void gst_cmml_enc_parse_end_tag (GstCmmlEnc * enc); +static void gst_cmml_enc_parse_tag_head (GstCmmlEnc * enc, + GstCmmlTagHead * head); +static void gst_cmml_enc_parse_tag_clip (GstCmmlEnc * enc, + GstCmmlTagClip * tag); +static GstFlowReturn gst_cmml_enc_new_buffer (GstCmmlEnc * enc, + guchar * data, gint size, GstBuffer ** buffer); +#if 0 +static void gst_cmml_enc_flush_clips (GstCmmlEnc * enc); +#endif +static GstFlowReturn gst_cmml_enc_push_clip (GstCmmlEnc * enc, + GstCmmlTagClip * clip, GstClockTime prev_clip_time); +static GstFlowReturn gst_cmml_enc_push (GstCmmlEnc * enc, GstBuffer * buffer); + +static void +gst_cmml_enc_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_cmml_enc_sink_factory)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&gst_cmml_enc_src_factory)); + gst_element_class_set_details (element_class, &gst_cmml_enc_details); +} + +static void +gst_cmml_enc_class_init (GstCmmlEncClass * enc_class) +{ + GObjectClass *klass = G_OBJECT_CLASS (enc_class); + + klass->get_property = gst_cmml_enc_get_property; + klass->set_property = gst_cmml_enc_set_property; + + g_object_class_install_property (klass, GST_CMML_ENC_GRANULERATE_N, + g_param_spec_int64 ("granule-rate-numerator", + "Granulerate numerator", + "Granulerate numerator", + 0, G_MAXINT64, 1, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_ENC_GRANULERATE_D, + g_param_spec_int64 ("granule-rate-denominator", + "Granulerate denominator", + "Granulerate denominator", + 0, G_MAXINT64, 1000, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_ENC_GRANULESHIFT, + g_param_spec_uchar ("granule-shift", + "Granuleshift", + "The number of lower bits to use for partitioning a granule position", + 0, G_MAXUINT8, 32, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + GST_ELEMENT_CLASS (klass)->change_state = gst_cmml_enc_change_state; +} + +static void +gst_cmml_enc_init (GstCmmlEnc * enc, GstCmmlEncClass * klass) +{ + enc->sinkpad = + gst_pad_new_from_static_template (&gst_cmml_enc_sink_factory, "sink"); + gst_pad_set_chain_function (enc->sinkpad, gst_cmml_enc_chain); + gst_pad_set_event_function (enc->sinkpad, gst_cmml_enc_sink_event); + gst_element_add_pad (GST_ELEMENT (enc), enc->sinkpad); + + enc->srcpad = + gst_pad_new_from_static_template (&gst_cmml_enc_src_factory, "src"); + gst_element_add_pad (GST_ELEMENT (enc), enc->srcpad); + + enc->major = 3; + enc->minor = 0; +} + +static void +gst_cmml_enc_set_property (GObject * object, guint property_id, + const GValue * value, GParamSpec * pspec) +{ + GstCmmlEnc *enc = GST_CMML_ENC (object); + + switch (property_id) { + case GST_CMML_ENC_GRANULERATE_N: + /* XXX: may need to flush clips */ + enc->granulerate_n = g_value_get_int64 (value); + break; + case GST_CMML_ENC_GRANULERATE_D: + enc->granulerate_d = g_value_get_int64 (value); + break; + case GST_CMML_ENC_GRANULESHIFT: + enc->granuleshift = g_value_get_uchar (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +gst_cmml_enc_get_property (GObject * object, guint property_id, + GValue * value, GParamSpec * pspec) +{ + GstCmmlEnc *enc = GST_CMML_ENC (object); + + switch (property_id) { + case GST_CMML_ENC_GRANULERATE_N: + g_value_set_int64 (value, enc->granulerate_n); + break; + case GST_CMML_ENC_GRANULERATE_D: + g_value_set_int64 (value, enc->granulerate_d); + break; + case GST_CMML_ENC_GRANULESHIFT: + g_value_set_uchar (value, enc->granuleshift); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static GstStateChangeReturn +gst_cmml_enc_change_state (GstElement * element, GstStateChange transition) +{ + GstCmmlEnc *enc = GST_CMML_ENC (element); + GstStateChangeReturn res; + + switch (transition) { + case GST_STATE_CHANGE_READY_TO_PAUSED: + enc->parser = gst_cmml_parser_new (GST_CMML_PARSER_ENCODE); + enc->parser->user_data = enc; + enc->parser->preamble_callback = + (GstCmmlParserPreambleCallback) gst_cmml_enc_parse_preamble; + enc->parser->head_callback = + (GstCmmlParserHeadCallback) gst_cmml_enc_parse_tag_head; + enc->parser->clip_callback = + (GstCmmlParserClipCallback) gst_cmml_enc_parse_tag_clip; + enc->parser->cmml_end_callback = + (GstCmmlParserCmmlEndCallback) gst_cmml_enc_parse_end_tag; + enc->tracks = gst_cmml_track_list_new (); + enc->sent_headers = FALSE; + enc->sent_eos = FALSE; + enc->flow_return = GST_FLOW_OK; + break; + default: + break; + } + + res = parent_class->change_state (element, transition); + + switch (transition) { + case GST_STATE_CHANGE_PAUSED_TO_READY: + { + gst_cmml_track_list_destroy (enc->tracks); + g_free (enc->preamble); + gst_cmml_parser_free (enc->parser); + break; + } + default: + break; + } + + return res; +} + +static gboolean +gst_cmml_enc_sink_event (GstPad * pad, GstEvent * event) +{ + GstCmmlEnc *enc = GST_CMML_ENC (GST_PAD_PARENT (pad)); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_EOS: + { + if (!enc->sent_eos) + gst_cmml_enc_parse_end_tag (enc); + + break; + } + default: + break; + } + + return gst_pad_event_default (pad, event); +} + +static GstFlowReturn +gst_cmml_enc_new_buffer (GstCmmlEnc * enc, + guchar * data, gint size, GstBuffer ** buffer) +{ + GstFlowReturn res; + + res = gst_pad_alloc_buffer (enc->srcpad, GST_BUFFER_OFFSET_NONE, size, + NULL, buffer); + if (res == GST_FLOW_OK) { + if (data) + memcpy (GST_BUFFER_DATA (*buffer), data, size); + } else { + GST_ELEMENT_ERROR (enc, STREAM, ENCODE, + (NULL), ("alloc function returned error %s", gst_flow_get_name (res))); + } + + return res; +} + +static GstCaps * +gst_cmml_enc_set_header_on_caps (GstCaps * caps, + GstBuffer * ident, GstBuffer * preamble, GstBuffer * head) +{ + GValue array = { 0 }; + GValue value = { 0 }; + GstStructure *structure; + + caps = gst_caps_make_writable (caps); + structure = gst_caps_get_structure (caps, 0); + + g_value_init (&array, GST_TYPE_ARRAY); + g_value_init (&value, GST_TYPE_BUFFER); + + gst_value_set_buffer (&value, ident); + gst_value_array_append_value (&array, &value); + gst_value_set_buffer (&value, preamble); + gst_value_array_append_value (&array, &value); + gst_value_set_buffer (&value, head); + gst_value_array_append_value (&array, &value); + + GST_BUFFER_FLAG_SET (ident, GST_BUFFER_FLAG_IN_CAPS); + GST_BUFFER_FLAG_SET (preamble, GST_BUFFER_FLAG_IN_CAPS); + GST_BUFFER_FLAG_SET (head, GST_BUFFER_FLAG_IN_CAPS); + + gst_structure_set_value (structure, "streamheader", &array); + + g_value_unset (&value); + g_value_unset (&array); + + return caps; +} + +/* create a CMML ident header buffer + */ +static GstFlowReturn +gst_cmml_enc_new_ident_header (GstCmmlEnc * enc, GstBuffer ** buffer) +{ + guint8 ident_header[CMML_IDENT_HEADER_SIZE]; + guint8 *wptr = ident_header; + + memcpy (wptr, "CMML\0\0\0\0", 8); + wptr += 8; + GST_WRITE_UINT16_LE (wptr, enc->major); + wptr += 2; + GST_WRITE_UINT16_LE (wptr, enc->minor); + wptr += 2; + GST_WRITE_UINT64_LE (wptr, enc->granulerate_n); + wptr += 8; + GST_WRITE_UINT64_LE (wptr, enc->granulerate_d); + wptr += 8; + *wptr = enc->granuleshift; + + return gst_cmml_enc_new_buffer (enc, + (guchar *) & ident_header, CMML_IDENT_HEADER_SIZE, buffer); +} + +/* parse the CMML preamble */ +static void +gst_cmml_enc_parse_preamble (GstCmmlEnc * enc, + guchar * preamble, guchar * processing_instruction) +{ + GST_INFO_OBJECT (enc, "parsing preamble"); + + /* save the preamble: it will be pushed when the head tag is found */ + enc->preamble = (guchar *) g_strconcat ((gchar *) preamble, + (gchar *) processing_instruction, NULL); +} + +/* parse the CMML end tag */ +static void +gst_cmml_enc_parse_end_tag (GstCmmlEnc * enc) +{ + GstBuffer *buffer; + + GST_INFO_OBJECT (enc, "parsing end tag"); +#if 0 + if (!enc->streaming) + gst_cmml_enc_flush_clips (enc); + + if (GST_FLOW_IS_FATAL (enc->flow_return)) + goto done; +#endif + + /* push an empty buffer to signal EOS */ + enc->flow_return = gst_cmml_enc_new_buffer (enc, NULL, 0, &buffer); + if (enc->flow_return == GST_FLOW_OK) { + /* set granulepos 0 on EOS */ + GST_BUFFER_OFFSET_END (buffer) = 0; + enc->flow_return = gst_cmml_enc_push (enc, buffer); + enc->sent_eos = TRUE; + } + + return; +} + +/* encode the CMML head tag and push the CMML headers + */ +static void +gst_cmml_enc_parse_tag_head (GstCmmlEnc * enc, GstCmmlTagHead * head) +{ + GList *headers = NULL; + GList *walk; + guchar *head_string; + GstCaps *caps; + GstBuffer *ident_buf, *preamble_buf, *head_buf; + GstBuffer *buffer; + + if (enc->preamble == NULL) + goto flow_unexpected; + + GST_INFO_OBJECT (enc, "parsing head tag"); + + enc->flow_return = gst_cmml_enc_new_ident_header (enc, &ident_buf); + if (enc->flow_return != GST_FLOW_OK) + goto alloc_error; + headers = g_list_append (headers, ident_buf); + + enc->flow_return = gst_cmml_enc_new_buffer (enc, + enc->preamble, strlen ((gchar *) enc->preamble), &preamble_buf); + if (enc->flow_return != GST_FLOW_OK) + goto alloc_error; + headers = g_list_append (headers, preamble_buf); + + head_string = gst_cmml_parser_tag_head_to_string (enc->parser, head); + enc->flow_return = gst_cmml_enc_new_buffer (enc, + head_string, strlen ((gchar *) head_string), &head_buf); + g_free (head_string); + if (enc->flow_return != GST_FLOW_OK) + goto alloc_error; + headers = g_list_append (headers, head_buf); + + caps = gst_pad_get_caps (enc->srcpad); + /* this call unrefs caps and creates new caps */ + caps = gst_cmml_enc_set_header_on_caps (caps, + ident_buf, preamble_buf, head_buf); + + for (walk = headers; walk; walk = walk->next) { + buffer = GST_BUFFER (walk->data); + /* set granulepos 0 on headers */ + GST_BUFFER_OFFSET_END (buffer) = 0; + gst_buffer_set_caps (buffer, caps); + + enc->flow_return = gst_cmml_enc_push (enc, buffer); + if (GST_FLOW_IS_FATAL (enc->flow_return)) + goto push_error; + + } + + gst_caps_unref (caps); + g_list_free (headers); + + enc->sent_headers = TRUE; + return; + +flow_unexpected: + GST_ELEMENT_ERROR (enc, STREAM, ENCODE, + (NULL), ("got head tag before preamble")); + enc->flow_return = GST_FLOW_UNEXPECTED; + return; +push_error: + gst_caps_unref (caps); + /* fallthrough */ +alloc_error: + for (walk = headers; walk; walk = walk->next) + gst_buffer_unref (GST_BUFFER (walk->data)); + g_list_free (headers); + return; +} + +#if 0 +static void +gst_cmml_enc_flush_clips (GstCmmlEnc * enc) +{ + GList *clips, *walk; + + clips = gst_cmml_track_list_get_clips (enc->tracks); + for (walk = clips; walk; walk = g_list_next (walk)) { + enc->flow_return = gst_cmml_enc_push_clip (enc, + GST_CMML_TAG_CLIP (walk->data)); + if (!GST_FLOW_IS_FATAL (enc->flow_return)) + break; + } +} +#endif + +/* encode a CMML clip tag + * remove the start and end attributes (GstCmmlParser does this itself) and + * push the tag with the timestamp of its start attribute. If the tag has the + * end attribute, create a new empty clip and encode it. + */ +static void +gst_cmml_enc_parse_tag_clip (GstCmmlEnc * enc, GstCmmlTagClip * clip) +{ + GstCmmlTagClip *prev_clip; + GstClockTime prev_clip_time = GST_CLOCK_TIME_NONE; + + /* this can happen if there's a programming error (eg user forgets to set + * the start-time property) or if one of the gst_cmml_clock_time_from_* + * overflows in the GstCmmlParser code */ + if (clip->start_time == GST_CLOCK_TIME_NONE) { + GST_ELEMENT_ERROR (enc, STREAM, ENCODE, + (NULL), ("invalid start time for clip (%s)", clip->id)); + enc->flow_return = GST_FLOW_ERROR; + + return; + } + + prev_clip = gst_cmml_track_list_get_track_last_clip (enc->tracks, + (gchar *) clip->track); + if (prev_clip) { + prev_clip_time = prev_clip->start_time; + gst_cmml_track_list_del_clip (enc->tracks, prev_clip); + } + + /* add the current clip to the tracklist */ + gst_cmml_track_list_add_clip (enc->tracks, clip); + + enc->flow_return = gst_cmml_enc_push_clip (enc, clip, prev_clip_time); +} + +static GstFlowReturn +gst_cmml_enc_push_clip (GstCmmlEnc * enc, GstCmmlTagClip * clip, + GstClockTime prev_clip_time) +{ + GstFlowReturn res; + GstBuffer *buffer; + gchar *clip_string; + gint64 granulepos; + + if (prev_clip_time != GST_CLOCK_TIME_NONE && + prev_clip_time > clip->start_time) { + GST_ELEMENT_ERROR (enc, STREAM, ENCODE, + (NULL), ("previous clip start time > current clip (%s) start time", + clip->id)); + return GST_FLOW_ERROR; + } + + /* encode the clip */ + clip_string = + (gchar *) gst_cmml_parser_tag_clip_to_string (enc->parser, clip); + + res = gst_cmml_enc_new_buffer (enc, + (guchar *) clip_string, strlen (clip_string), &buffer); + g_free (clip_string); + if (res != GST_FLOW_OK) + goto done; + + GST_INFO_OBJECT (enc, "encoding clip" + "(start-time: %" GST_TIME_FORMAT " end-time: %" GST_TIME_FORMAT, + GST_TIME_ARGS (clip->start_time), GST_TIME_ARGS (clip->end_time)); + + /* set the granulepos */ + granulepos = gst_cmml_clock_time_to_granule (prev_clip_time, clip->start_time, + enc->granulerate_n, enc->granulerate_d, enc->granuleshift); + GST_BUFFER_OFFSET_END (buffer) = granulepos; + GST_BUFFER_TIMESTAMP (buffer) = clip->start_time; + + res = gst_cmml_enc_push (enc, buffer); + if (GST_FLOW_IS_FATAL (res)) + goto done; + + if (clip->end_time != GST_CLOCK_TIME_NONE) { + /* create a new empty clip for the same cmml "track" starting at + * "end_time" + */ + GObject *end_clip = g_object_new (GST_TYPE_CMML_TAG_CLIP, + "start-time", clip->end_time, "track", clip->track, NULL); + + /* encode the empty end clip */ + gst_cmml_enc_push_clip (enc, GST_CMML_TAG_CLIP (end_clip), + clip->start_time); + g_object_unref (end_clip); + } +done: + return res; +} + +static GstFlowReturn +gst_cmml_enc_push (GstCmmlEnc * enc, GstBuffer * buffer) +{ + GstFlowReturn res; + + /* FIXME: hack to make oggmux flush every cmml tag in its own page */ + GST_BUFFER_DURATION (buffer) = G_MAXINT64; + + res = gst_pad_push (enc->srcpad, buffer); + if (GST_FLOW_IS_FATAL (res)) + GST_ELEMENT_ERROR (enc, STREAM, ENCODE, + (NULL), ("could not push the buffer: %s", gst_flow_get_name (res))); + + return res; +} + +static GstFlowReturn +gst_cmml_enc_chain (GstPad * pad, GstBuffer * buffer) +{ + GError *err = NULL; + GstCmmlEnc *enc = GST_CMML_ENC (GST_PAD_PARENT (pad)); + + /* the CMML handlers registered with enc->parser will override this when + * encoding/pushing the buffers downstream + */ + enc->flow_return = GST_FLOW_OK; + + if (!gst_cmml_parser_parse_chunk (enc->parser, + (gchar *) GST_BUFFER_DATA (buffer), GST_BUFFER_SIZE (buffer), &err)) { + GST_ELEMENT_ERROR (enc, STREAM, ENCODE, (NULL), (err->message)); + g_error_free (err); + enc->flow_return = GST_FLOW_ERROR; + } + + gst_buffer_unref (buffer); + return enc->flow_return; +} + +gboolean +gst_cmml_enc_plugin_init (GstPlugin * plugin) +{ + if (!gst_element_register (plugin, "cmmlenc", GST_RANK_NONE, + GST_TYPE_CMML_ENC)) + return FALSE; + + GST_DEBUG_CATEGORY_INIT (cmmlenc, "cmmlenc", 0, + "annodex cmml decoding element"); + + return TRUE; +} diff --git a/ext/annodex/gstcmmlenc.h b/ext/annodex/gstcmmlenc.h new file mode 100644 index 0000000..5c072ba --- /dev/null +++ b/ext/annodex/gstcmmlenc.h @@ -0,0 +1,77 @@ +/* + * gstcmmlenc.h - GStreamer CMML encoder + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Encina + * + * 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_CMML_ENC_H__ +#define __GST_CMML_ENC_H__ + +#define GST_TYPE_CMML_ENC (gst_cmml_enc_get_type()) +#define GST_CMML_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_CMML_ENC, GstCmmlEnc)) +#define GST_CMML_ENC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_CMML_ENC, GstCmmlEnc)) +#define GST_IS_CMML_ENC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_CMML_ENC)) +#define GST_IS_CMML_ENC_CLASS(obj) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_CMML_ENC)) +#define GST_CMML_ENC_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_CMML_ENC, GstCmmlEncClass)) + +#include +#include + +#include "gstcmmlparser.h" +#include "gstcmmlutils.h" + +typedef struct _GstCmmlEnc GstCmmlEnc; +typedef struct _GstCmmlEncClass GstCmmlEncClass; + +struct _GstCmmlEnc +{ + GstElement element; + + GstPad *sinkpad; + GstPad *srcpad; + + gint16 major; + gint16 minor; + gint64 granulerate_n; + gint64 granulerate_d; + gint8 granuleshift; + + GstCmmlParser *parser; + gboolean streaming; + GHashTable *tracks; + GstFlowReturn flow_return; + guchar *preamble; + gboolean sent_headers; + gboolean sent_eos; +}; + +struct _GstCmmlEncClass +{ + GstElementClass parent_class; +}; + +gboolean gst_cmml_enc_plugin_init (GstPlugin * plugin); + +#endif /* __GST_CMML_ENC_H__ */ diff --git a/ext/annodex/gstcmmlparser.c b/ext/annodex/gstcmmlparser.c new file mode 100644 index 0000000..c7931ea --- /dev/null +++ b/ext/annodex/gstcmmlparser.c @@ -0,0 +1,617 @@ +/* + * gstcmmlparser.c - GStreamer CMML document parser + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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. + */ + +#include +#include + +#include "gstcmmlparser.h" +#include "gstannodex.h" +#include "gstcmmlutils.h" + +static xmlNodePtr gst_cmml_parser_new_node (GstCmmlParser * parser, + const gchar * name, ...); +static void +gst_cmml_parser_parse_start_element_ns (xmlParserCtxt * ctxt, + const xmlChar * name, const xmlChar * prefix, const xmlChar * URI, + int nb_preferences, const xmlChar ** namespaces, + int nb_attributes, int nb_defaulted, const xmlChar ** attributes); +static void gst_cmml_parser_parse_end_element_ns (xmlParserCtxt * ctxt, + const xmlChar * name, const xmlChar * prefix, const xmlChar * URI); +static void gst_cmml_parser_parse_processing_instruction (xmlParserCtxtPtr ctxt, + const xmlChar * target, const xmlChar * data); +static void gst_cmml_parser_meta_to_string (GstCmmlParser * parser, + xmlNodePtr parent, GValueArray * meta); + +/* create a new CMML parser + */ +GstCmmlParser * +gst_cmml_parser_new (GstCmmlParserMode mode) +{ + GstCmmlParser *parser = g_malloc (sizeof (GstCmmlParser)); + + parser->mode = mode; + parser->context = xmlCreatePushParserCtxt (NULL, NULL, + NULL, 0, "cmml-bitstream"); + xmlCtxtUseOptions (parser->context, XML_PARSE_NONET | XML_PARSE_NOERROR); + parser->context->_private = parser; + parser->context->sax->startElementNs = + (startElementNsSAX2Func) gst_cmml_parser_parse_start_element_ns; + parser->context->sax->endElementNs = + (endElementNsSAX2Func) gst_cmml_parser_parse_end_element_ns; + parser->context->sax->processingInstruction = (processingInstructionSAXFunc) + gst_cmml_parser_parse_processing_instruction; + parser->preamble_callback = NULL; + parser->cmml_end_callback = NULL; + parser->stream_callback = NULL; + parser->head_callback = NULL; + parser->clip_callback = NULL; + parser->user_data = NULL; + + return parser; +} + +/* free a CMML parser instance + */ +void +gst_cmml_parser_free (GstCmmlParser * parser) +{ + if (parser) { + xmlFreeDoc (parser->context->myDoc); + xmlFreeParserCtxt (parser->context); + g_free (parser); + } +} + +/* parse an xml chunk + * + * returns false if the xml is invalid + */ +gboolean +gst_cmml_parser_parse_chunk (GstCmmlParser * parser, + const gchar * data, guint size, GError ** err) +{ + gint xmlres; + + xmlres = xmlParseChunk (parser->context, data, size, 0); + if (xmlres != XML_ERR_OK) { + xmlErrorPtr xml_error = xmlCtxtGetLastError (parser->context); + + g_set_error (err, + GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, xml_error->message); + return FALSE; + } + + return TRUE; +} + +/* convert an xmlNodePtr to a string + */ +guchar * +gst_cmml_parser_node_to_string (GstCmmlParser * parser, xmlNodePtr node) +{ + xmlBufferPtr xml_buffer; + xmlDocPtr doc; + guchar *str; + + if (parser) + doc = parser->context->myDoc; + else + doc = NULL; + + xml_buffer = xmlBufferCreate (); + xmlNodeDump (xml_buffer, doc, node, 0, 0); + str = xmlStrndup (xml_buffer->content, xml_buffer->use); + xmlBufferFree (xml_buffer); + + return str; +} + +guchar * +gst_cmml_parser_tag_stream_to_string (GstCmmlParser * parser, + GstCmmlTagStream * stream) +{ + xmlNodePtr node; + xmlNodePtr import; + guchar *ret; + + node = gst_cmml_parser_new_node (parser, "stream", NULL); + if (stream->timebase) + xmlSetProp (node, (xmlChar *) "timebase", stream->timebase); + + if (stream->utc) + xmlSetProp (node, (xmlChar *) "utc", stream->utc); + + if (stream->imports) { + gint i; + GValue *val; + + for (i = 0; i < stream->imports->n_values; ++i) { + val = g_value_array_get_nth (stream->imports, i); + import = gst_cmml_parser_new_node (parser, "import", + "src", g_value_get_string (val), NULL); + xmlAddChild (node, import); + } + } + + ret = gst_cmml_parser_node_to_string (parser, node); + + xmlUnlinkNode (node); + xmlFreeNode (node); + + return ret; +} + +/* convert a GstCmmlTagHead to its string representation + */ +guchar * +gst_cmml_parser_tag_head_to_string (GstCmmlParser * parser, + GstCmmlTagHead * head) +{ + xmlNodePtr node; + xmlNodePtr tmp; + guchar *ret; + + node = gst_cmml_parser_new_node (parser, "head", NULL); + if (head->title) { + tmp = gst_cmml_parser_new_node (parser, "title", NULL); + xmlNodeSetContent (tmp, head->title); + xmlAddChild (node, tmp); + } + + if (head->base) { + tmp = gst_cmml_parser_new_node (parser, "base", "uri", head->base, NULL); + xmlAddChild (node, tmp); + } + + if (head->meta) + gst_cmml_parser_meta_to_string (parser, node, head->meta); + + ret = gst_cmml_parser_node_to_string (parser, node); + + xmlUnlinkNode (node); + xmlFreeNode (node); + + return ret; +} + +/* convert a GstCmmlTagClip to its string representation + */ +guchar * +gst_cmml_parser_tag_clip_to_string (GstCmmlParser * parser, + GstCmmlTagClip * clip) +{ + xmlNodePtr node; + xmlNodePtr tmp; + guchar *ret; + + node = gst_cmml_parser_new_node (parser, "clip", + "id", clip->id, "track", clip->track, NULL); + /* add the anchor element */ + if (clip->anchor_href) { + tmp = gst_cmml_parser_new_node (parser, "a", + "href", clip->anchor_href, NULL); + if (clip->anchor_text) + xmlNodeSetContent (tmp, clip->anchor_text); + + xmlAddChild (node, tmp); + } + /* add the img element */ + if (clip->img_src) { + tmp = gst_cmml_parser_new_node (parser, "img", + "src", clip->img_src, "alt", clip->img_alt, NULL); + + xmlAddChild (node, tmp); + } + /* add the desc element */ + if (clip->desc_text) { + tmp = gst_cmml_parser_new_node (parser, "desc", NULL); + xmlNodeSetContent (tmp, clip->desc_text); + + xmlAddChild (node, tmp); + } + /* add the meta elements */ + if (clip->meta) + gst_cmml_parser_meta_to_string (parser, node, clip->meta); + + if (parser->mode == GST_CMML_PARSER_DECODE) { + gchar *time_str; + + time_str = gst_cmml_clock_time_to_npt (clip->start_time); + if (time_str == NULL) + goto fail; + + xmlSetProp (node, (xmlChar *) "start", (xmlChar *) time_str); + g_free (time_str); + + if (clip->end_time != GST_CLOCK_TIME_NONE) { + time_str = gst_cmml_clock_time_to_npt (clip->end_time); + if (time_str == NULL) + goto fail; + + xmlSetProp (node, (xmlChar *) "end", (xmlChar *) time_str); + g_free (time_str); + } + } + + ret = gst_cmml_parser_node_to_string (parser, node); + + xmlUnlinkNode (node); + xmlFreeNode (node); + + return ret; +fail: + xmlUnlinkNode (node); + xmlFreeNode (node); + return NULL; +} + +guchar * +gst_cmml_parser_tag_object_to_string (GstCmmlParser * parser, GObject * tag) +{ + guchar *tag_string = NULL; + GType tag_type = G_OBJECT_TYPE (tag); + + if (tag_type == GST_TYPE_CMML_TAG_STREAM) + tag_string = gst_cmml_parser_tag_stream_to_string (parser, + GST_CMML_TAG_STREAM (tag)); + else if (tag_type == GST_TYPE_CMML_TAG_HEAD) + tag_string = gst_cmml_parser_tag_head_to_string (parser, + GST_CMML_TAG_HEAD (tag)); + else if (tag_type == GST_TYPE_CMML_TAG_CLIP) + tag_string = gst_cmml_parser_tag_clip_to_string (parser, + GST_CMML_TAG_CLIP (tag)); + else + g_warning ("could not convert object to cmml"); + + return tag_string; +} + +/*** private section ***/ + +/* create a new node + * + * helper to create a node and set its attributes + */ +static xmlNodePtr +gst_cmml_parser_new_node (GstCmmlParser * parser, const gchar * name, ...) +{ + va_list args; + xmlNodePtr node; + xmlChar *prop_name, *prop_value; + + node = xmlNewNode (NULL, (xmlChar *) name); + + va_start (args, name); + + prop_name = va_arg (args, xmlChar *); + while (prop_name != NULL) { + prop_value = va_arg (args, xmlChar *); + if (prop_value != NULL) + xmlSetProp (node, prop_name, prop_value); + + prop_name = va_arg (args, xmlChar *); + } + va_end (args); + + return node; +} + +/* get the last node of the stream + * + * returns the last node at depth 1 (if any) or the root node + */ +static xmlNodePtr +gst_cmml_parser_get_last_element (GstCmmlParser * parser) +{ + xmlNodePtr node; + + node = xmlDocGetRootElement (parser->context->myDoc); + if (!node) { + g_warning ("no last cmml element"); + return NULL; + } + + if (node->children) + node = xmlGetLastChild (node); + + return node; +} + +static void +gst_cmml_parser_parse_preamble (GstCmmlParser * parser, + const guchar * attributes) +{ + gchar *preamble; + gchar *element; + const gchar *version; + const gchar *encoding; + const gchar *standalone; + xmlDocPtr doc; + + doc = parser->context->myDoc; + + version = doc->version ? (gchar *) doc->version : "1.0"; + encoding = doc->encoding ? (gchar *) doc->encoding : "UTF-8"; + standalone = doc->standalone ? "yes" : "no"; + + preamble = g_strdup_printf ("\n" + "\n", version, encoding, standalone); + + if (attributes == NULL) + attributes = (guchar *) ""; + + if (parser->mode == GST_CMML_PARSER_ENCODE) + element = g_strdup_printf ("", attributes); + else + element = g_strdup_printf ("", attributes); + + parser->preamble_callback (parser->user_data, + (guchar *) preamble, (guchar *) element); + + g_free (preamble); + g_free (element); +} + +/* parse the cmml stream tag */ +static void +gst_cmml_parser_parse_stream (GstCmmlParser * parser, xmlNodePtr stream) +{ + GstCmmlTagStream *stream_tag; + GValue str_val = { 0 }; + xmlNodePtr walk; + guchar *timebase; + + g_value_init (&str_val, G_TYPE_STRING); + + /* read the timebase and utc attributes */ + timebase = xmlGetProp (stream, (xmlChar *) "timebase"); + if (timebase == NULL) + timebase = (guchar *) g_strdup ("0"); + + stream_tag = g_object_new (GST_TYPE_CMML_TAG_STREAM, + "timebase", timebase, NULL); + g_free (timebase); + + stream_tag->utc = xmlGetProp (stream, (xmlChar *) "utc"); + + /* walk the children nodes */ + for (walk = stream->children; walk; walk = walk->next) { + /* for every import tag add its src attribute to stream_tag->imports */ + if (!xmlStrcmp (walk->name, (xmlChar *) "import")) { + g_value_take_string (&str_val, + (gchar *) xmlGetProp (walk, (xmlChar *) "src")); + + if (stream_tag->imports == NULL) + stream_tag->imports = g_value_array_new (0); + + g_value_array_append (stream_tag->imports, &str_val); + } + } + g_value_unset (&str_val); + + parser->stream_callback (parser->user_data, stream_tag); + g_object_unref (stream_tag); +} + +/* parse the cmml head tag */ +static void +gst_cmml_parser_parse_head (GstCmmlParser * parser, xmlNodePtr head) +{ + GstCmmlTagHead *head_tag; + xmlNodePtr walk; + GValue str_val = { 0 }; + + head_tag = g_object_new (GST_TYPE_CMML_TAG_HEAD, NULL); + + g_value_init (&str_val, G_TYPE_STRING); + + /* Parse the content of the node and setup the GST_TAG_CMML_HEAD tag. + * Create a GST_TAG_TITLE when we find the title element. + */ + for (walk = head->children; walk; walk = walk->next) { + if (!xmlStrcmp (walk->name, (xmlChar *) "title")) { + head_tag->title = xmlNodeGetContent (walk); + } else if (!xmlStrcmp (walk->name, (xmlChar *) "base")) { + head_tag->base = xmlGetProp (walk, (xmlChar *) "uri"); + } else if (!xmlStrcmp (walk->name, (xmlChar *) "meta")) { + if (head_tag->meta == NULL) + head_tag->meta = g_value_array_new (0); + /* add a pair name, content to the meta value array */ + g_value_take_string (&str_val, + (gchar *) xmlGetProp (walk, (xmlChar *) "name")); + g_value_array_append (head_tag->meta, &str_val); + g_value_take_string (&str_val, + (gchar *) xmlGetProp (walk, (xmlChar *) "content")); + g_value_array_append (head_tag->meta, &str_val); + } + } + g_value_unset (&str_val); + + parser->head_callback (parser->user_data, head_tag); + g_object_unref (head_tag); +} + +/* parse a cmml clip tag */ +static void +gst_cmml_parser_parse_clip (GstCmmlParser * parser, xmlNodePtr clip) +{ + GstCmmlTagClip *clip_tag; + GValue str_val = { 0 }; + guchar *id, *track, *start, *end; + xmlNodePtr walk; + GstClockTime start_time = GST_CLOCK_TIME_NONE; + GstClockTime end_time = GST_CLOCK_TIME_NONE; + + g_value_init (&str_val, G_TYPE_STRING); + + id = xmlGetProp (clip, (xmlChar *) "id"); + track = xmlGetProp (clip, (xmlChar *) "track"); + start = xmlGetProp (clip, (xmlChar *) "start"); + end = xmlGetProp (clip, (xmlChar *) "end"); + + if (start) { + if (!strncmp ((gchar *) start, "smpte", 5)) + start_time = gst_cmml_clock_time_from_smpte ((gchar *) start); + else + start_time = gst_cmml_clock_time_from_npt ((gchar *) start); + } + + if (end) { + if (!strncmp ((gchar *) end, "smpte", 5)) + start_time = gst_cmml_clock_time_from_smpte ((gchar *) end); + else + end_time = gst_cmml_clock_time_from_npt ((gchar *) end); + } + + if (track == NULL) + track = (guchar *) g_strdup ("default"); + + clip_tag = g_object_new (GST_TYPE_CMML_TAG_CLIP, + "id", id, + "track", track, "start-time", start_time, "end-time", end_time, NULL); + + g_free (id); + g_free (track); + g_free (start); + g_free (end); + + /* parse the children */ + for (walk = clip->children; walk; walk = walk->next) { + /* the clip is not empty */ + clip_tag->empty = FALSE; + + if (!xmlStrcmp (walk->name, (xmlChar *) "a")) { + clip_tag->anchor_href = xmlGetProp (walk, (xmlChar *) "href"); + clip_tag->anchor_text = xmlNodeGetContent (walk); + } else if (!xmlStrcmp (walk->name, (xmlChar *) "img")) { + clip_tag->img_src = xmlGetProp (walk, (xmlChar *) "src"); + clip_tag->img_alt = xmlGetProp (walk, (xmlChar *) "alt"); + } else if (!xmlStrcmp (walk->name, (xmlChar *) "desc")) { + clip_tag->desc_text = xmlNodeGetContent (walk); + } else if (!xmlStrcmp (walk->name, (xmlChar *) "meta")) { + if (clip_tag->meta == NULL) + clip_tag->meta = g_value_array_new (0); + /* add a pair name, content to the meta value array */ + g_value_take_string (&str_val, + (char *) xmlGetProp (walk, (xmlChar *) "name")); + g_value_array_append (clip_tag->meta, &str_val); + g_value_take_string (&str_val, + (char *) xmlGetProp (walk, (xmlChar *) "content")); + g_value_array_append (clip_tag->meta, &str_val); + } + } + g_value_unset (&str_val); + + parser->clip_callback (parser->user_data, clip_tag); + g_object_unref (clip_tag); +} + +void +gst_cmml_parser_meta_to_string (GstCmmlParser * parser, + xmlNodePtr parent, GValueArray * array) +{ + gint i; + xmlNodePtr node; + GValue *name, *content; + + for (i = 0; i < array->n_values - 1; i += 2) { + name = g_value_array_get_nth (array, i); + content = g_value_array_get_nth (array, i + 1); + node = gst_cmml_parser_new_node (parser, "meta", + "name", g_value_get_string (name), + "content", g_value_get_string (content), NULL); + xmlAddChild (parent, node); + } +} + +/* sax handler called when an element start tag is found + * this is used to parse the cmml start tag + */ +static void +gst_cmml_parser_parse_start_element_ns (xmlParserCtxt * ctxt, + const xmlChar * name, const xmlChar * prefix, const xmlChar * URI, + int nb_preferences, const xmlChar ** namespaces, + int nb_attributes, int nb_defaulted, const xmlChar ** attributes) +{ + GstCmmlParser *parser = (GstCmmlParser *) ctxt->_private; + + xmlSAX2StartElementNs (ctxt, name, prefix, URI, nb_preferences, namespaces, + nb_attributes, nb_defaulted, attributes); + + if (parser->mode == GST_CMML_PARSER_ENCODE) + if (!xmlStrcmp (name, (xmlChar *) "cmml")) + if (parser->preamble_callback) + /* FIXME: parse attributes */ + gst_cmml_parser_parse_preamble (parser, NULL); +} + +/* sax processing instruction handler + * used to parse the cmml processing instruction + */ +static void +gst_cmml_parser_parse_processing_instruction (xmlParserCtxtPtr ctxt, + const xmlChar * target, const xmlChar * data) +{ + GstCmmlParser *parser = (GstCmmlParser *) ctxt->_private; + + xmlSAX2ProcessingInstruction (ctxt, target, data); + + if (parser->mode == GST_CMML_PARSER_DECODE) + if (!xmlStrcmp (target, (xmlChar *) "cmml")) + if (parser->preamble_callback) + gst_cmml_parser_parse_preamble (parser, data); +} + +/* sax handler called when an xml end tag is found + * used to parse the stream, head and clip nodes + */ +static void +gst_cmml_parser_parse_end_element_ns (xmlParserCtxt * ctxt, + const xmlChar * name, const xmlChar * prefix, const xmlChar * URI) +{ + xmlNodePtr node; + GstCmmlParser *parser = (GstCmmlParser *) ctxt->_private; + + xmlSAX2EndElementNs (ctxt, name, prefix, URI); + + if (!xmlStrcmp (name, (xmlChar *) "clip")) { + if (parser->clip_callback) { + node = gst_cmml_parser_get_last_element (parser); + gst_cmml_parser_parse_clip (parser, node); + } + } else if (!xmlStrcmp (name, (xmlChar *) "cmml")) { + if (parser->cmml_end_callback) + parser->cmml_end_callback (parser->user_data); + } else if (!xmlStrcmp (name, (xmlChar *) "stream")) { + if (parser->stream_callback) { + node = gst_cmml_parser_get_last_element (parser); + gst_cmml_parser_parse_stream (parser, node); + } + } else if (!xmlStrcmp (name, (xmlChar *) "head")) { + if (parser->head_callback) { + node = gst_cmml_parser_get_last_element (parser); + gst_cmml_parser_parse_head (parser, node); + } + } +} diff --git a/ext/annodex/gstcmmlparser.h b/ext/annodex/gstcmmlparser.h new file mode 100644 index 0000000..926b509 --- /dev/null +++ b/ext/annodex/gstcmmlparser.h @@ -0,0 +1,90 @@ +/* + * gstcmmlparser.h - GStreamer CMML document parser + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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_CMML_PARSER_H__ +#define __GST_CMML_PARSER_H__ + +#include +#include + +#include "gstcmmltag.h" + +typedef struct _GstCmmlParser GstCmmlParser; +typedef enum _GstCmmlParserMode GstCmmlParserMode; + +typedef void (*GstCmmlParserPreambleCallback) (void *user_data, + const guchar * xml_preamble, const guchar * cmml_attrs); + +typedef void (*GstCmmlParserCmmlEndCallback) (void *user_data); + +typedef void (*GstCmmlParserStreamCallback) (void *user_data, + GstCmmlTagStream * stream); + +typedef void (*GstCmmlParserHeadCallback) (void *user_data, + GstCmmlTagHead * head); + +typedef void (*GstCmmlParserClipCallback) (void *user_data, + GstCmmlTagClip * clip); + +enum _GstCmmlParserMode +{ + GST_CMML_PARSER_ENCODE, + GST_CMML_PARSER_DECODE +}; + +struct _GstCmmlParser +{ + GstCmmlParserMode mode; + + xmlParserCtxtPtr context; + + const gchar *preamble; + guint preamble_size; + + void *user_data; + GstCmmlParserPreambleCallback preamble_callback; + GstCmmlParserStreamCallback stream_callback; + GstCmmlParserCmmlEndCallback cmml_end_callback; + GstCmmlParserHeadCallback head_callback; + GstCmmlParserClipCallback clip_callback; +}; + +GstCmmlParser *gst_cmml_parser_new (GstCmmlParserMode mode); +void gst_cmml_parser_free (GstCmmlParser * parser); + +gboolean gst_cmml_parser_parse_chunk (GstCmmlParser * parser, + const gchar * data, guint size, GError ** error); + +guchar *gst_cmml_parser_tag_stream_to_string (GstCmmlParser * parser, + GstCmmlTagStream * stream); + +guchar *gst_cmml_parser_tag_head_to_string (GstCmmlParser * parser, + GstCmmlTagHead * head); + +guchar *gst_cmml_parser_tag_clip_to_string (GstCmmlParser * parser, + GstCmmlTagClip * clip); + +guchar *gst_cmml_parser_tag_object_to_string (GstCmmlParser * parser, + GObject * tag); + +#endif /* __GST_CMML_PARSER_H__ */ diff --git a/ext/annodex/gstcmmltag.c b/ext/annodex/gstcmmltag.c new file mode 100644 index 0000000..1a49d79 --- /dev/null +++ b/ext/annodex/gstcmmltag.c @@ -0,0 +1,565 @@ +/* + * gstcmmltags.c - GStreamer CMML tag support + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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 "gstcmmlparser.h" +#include "gstcmmltag.h" +#include "gstannodex.h" + +enum +{ + ARG_0, + GST_CMML_TAG_STREAM_TIMEBASE, + GST_CMML_TAG_STREAM_UTC, + GST_CMML_TAG_STREAM_IMPORTS, + GST_CMML_TAG_HEAD_TITLE, + GST_CMML_TAG_HEAD_BASE, + GST_CMML_TAG_HEAD_META, + GST_CMML_TAG_CLIP_EMPTY, + GST_CMML_TAG_CLIP_ID, + GST_CMML_TAG_CLIP_TRACK, + GST_CMML_TAG_CLIP_START_TIME, + GST_CMML_TAG_CLIP_END_TIME, + GST_CMML_TAG_CLIP_ANCHOR_HREF, + GST_CMML_TAG_CLIP_ANCHOR_TEXT, + GST_CMML_TAG_CLIP_IMG_SRC, + GST_CMML_TAG_CLIP_IMG_ALT, + GST_CMML_TAG_CLIP_DESC_TEXT, + GST_CMML_TAG_CLIP_META, +}; + +G_DEFINE_TYPE (GstCmmlTagStream, gst_cmml_tag_stream, G_TYPE_OBJECT); +static void gst_cmml_tag_stream_finalize (GObject * object); +static void gst_cmml_tag_stream_set_property (GObject * object, + guint property_id, const GValue * value, GParamSpec * pspec); +static void gst_cmml_tag_stream_get_property (GObject * object, + guint property_id, GValue * value, GParamSpec * pspec); +static void gst_cmml_tag_stream_value_from_string_value (const GValue * src, + GValue * dest); + +G_DEFINE_TYPE (GstCmmlTagHead, gst_cmml_tag_head, G_TYPE_OBJECT); +static void gst_cmml_tag_head_finalize (GObject * object); +static void gst_cmml_tag_head_set_property (GObject * object, guint property_id, + const GValue * value, GParamSpec * pspec); +static void gst_cmml_tag_head_get_property (GObject * object, guint property_id, + GValue * value, GParamSpec * pspec); +static void gst_cmml_tag_head_value_from_string_value (const GValue * src, + GValue * dest); + +G_DEFINE_TYPE (GstCmmlTagClip, gst_cmml_tag_clip, G_TYPE_OBJECT); +static void gst_cmml_tag_clip_finalize (GObject * object); +static void gst_cmml_tag_clip_set_property (GObject * object, guint property_id, + const GValue * value, GParamSpec * pspec); +static void gst_cmml_tag_clip_get_property (GObject * object, guint property_id, + GValue * value, GParamSpec * pspec); + +static void gst_cmml_tag_clip_value_from_string_value (const GValue * src, + GValue * dest); + +static void set_object_on_value (GObject * object, GValue * dest); + +static const gchar *default_preamble = + ""; + +/* Stream tag */ +static void +gst_cmml_tag_stream_class_init (GstCmmlTagStreamClass * stream_class) +{ + GObjectClass *klass = G_OBJECT_CLASS (stream_class); + + klass->set_property = gst_cmml_tag_stream_set_property; + klass->get_property = gst_cmml_tag_stream_get_property; + klass->finalize = gst_cmml_tag_stream_finalize; + + g_object_class_install_property (klass, GST_CMML_TAG_STREAM_TIMEBASE, + g_param_spec_string ("base-time", + "Base time", + "Playback time (in seconds) of the first data packet", + "0", G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_STREAM_UTC, + g_param_spec_string ("calendar-base-time", + "Calendar base time", + "Date and wall-clock time (expressed as UTC time in the format " + "YYYYMMDDTHHMMSS.sssZ) associated with the base-time", + NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_STREAM_IMPORTS, + g_param_spec_value_array ("input-streams", + "Input streams", + "List of input streams that compose this bitstream", + NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_value_register_transform_func (G_TYPE_STRING, GST_TYPE_CMML_TAG_STREAM, + gst_cmml_tag_stream_value_from_string_value); +} + +static void +gst_cmml_tag_stream_init (GstCmmlTagStream * stream) +{ +} + +static void +gst_cmml_tag_stream_finalize (GObject * object) +{ + GstCmmlTagStream *stream = GST_CMML_TAG_STREAM (object); + + g_free (stream->timebase); + g_free (stream->utc); + if (stream->imports) + g_value_array_free (stream->imports); + + if (G_OBJECT_CLASS (gst_cmml_tag_stream_parent_class)->finalize) + G_OBJECT_CLASS (gst_cmml_tag_stream_parent_class)->finalize (object); +} + +static void +gst_cmml_tag_stream_set_property (GObject * object, guint property_id, + const GValue * value, GParamSpec * pspec) +{ + GstCmmlTagStream *stream = GST_CMML_TAG_STREAM (object); + + switch (property_id) { + case GST_CMML_TAG_STREAM_TIMEBASE: + g_free (stream->timebase); + stream->timebase = (guchar *) g_value_dup_string (value); + break; + case GST_CMML_TAG_STREAM_UTC: + g_free (stream->utc); + stream->utc = (guchar *) g_value_dup_string (value); + break; + case GST_CMML_TAG_STREAM_IMPORTS: + { + GValueArray *va = g_value_get_boxed (value); + + if (stream->imports) + g_value_array_free (stream->imports); + stream->imports = va != NULL ? g_value_array_copy (va) : NULL; + break; + } + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + + +static void +gst_cmml_tag_stream_value_from_string_value (const GValue * src, GValue * dest) +{ + GstCmmlParser *parser; + const gchar *str; + guint size; + + parser = gst_cmml_parser_new (GST_CMML_PARSER_DECODE); + parser->user_data = dest; + parser->stream_callback = (GstCmmlParserStreamCallback) set_object_on_value; + gst_cmml_parser_parse_chunk (parser, + default_preamble, strlen (default_preamble), NULL); + + str = g_value_get_string (src); + size = strlen (str); + gst_cmml_parser_parse_chunk (parser, str, size, NULL); + + gst_cmml_parser_free (parser); +} + +static void +gst_cmml_tag_stream_get_property (GObject * object, guint property_id, + GValue * value, GParamSpec * pspec) +{ + GstCmmlTagStream *stream = GST_CMML_TAG_STREAM (object); + + switch (property_id) { + case GST_CMML_TAG_STREAM_TIMEBASE: + g_value_set_string (value, (gchar *) stream->timebase); + break; + case GST_CMML_TAG_STREAM_UTC: + g_value_set_string (value, (gchar *) stream->utc); + break; + case GST_CMML_TAG_STREAM_IMPORTS: + g_value_set_boxed (value, stream->imports); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +/* Head tag */ +static void +gst_cmml_tag_head_class_init (GstCmmlTagHeadClass * head_class) +{ + GObjectClass *klass = G_OBJECT_CLASS (head_class); + + klass->set_property = gst_cmml_tag_head_set_property; + klass->get_property = gst_cmml_tag_head_get_property; + klass->finalize = gst_cmml_tag_head_finalize; + + g_object_class_install_property (klass, GST_CMML_TAG_HEAD_TITLE, + g_param_spec_string ("title", + "Title", + "Title of the bitstream", + NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_HEAD_BASE, + g_param_spec_string ("base-uri", + "Base URI", + "Base URI of the bitstream. All relative URIs are relative to this", + NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_HEAD_META, + g_param_spec_value_array ("meta", + "Meta annotations", + "Meta annotations for the complete Annodex bitstream", + NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_value_register_transform_func (G_TYPE_STRING, GST_TYPE_CMML_TAG_HEAD, + gst_cmml_tag_head_value_from_string_value); +} + +static void +gst_cmml_tag_head_init (GstCmmlTagHead * head) +{ +} + +static void +gst_cmml_tag_head_finalize (GObject * object) +{ + GstCmmlTagHead *head = GST_CMML_TAG_HEAD (object); + + g_free (head->title); + g_free (head->base); + if (head->meta) + g_value_array_free (head->meta); + + if (G_OBJECT_CLASS (gst_cmml_tag_head_parent_class)->finalize) + G_OBJECT_CLASS (gst_cmml_tag_head_parent_class)->finalize (object); +} + +static void +gst_cmml_tag_head_set_property (GObject * object, guint property_id, + const GValue * value, GParamSpec * pspec) +{ + GstCmmlTagHead *head = GST_CMML_TAG_HEAD (object); + + switch (property_id) { + case GST_CMML_TAG_HEAD_TITLE: + g_free (head->title); + head->title = (guchar *) g_value_dup_string (value); + break; + case GST_CMML_TAG_HEAD_BASE: + g_free (head->base); + head->base = (guchar *) g_value_dup_string (value); + break; + case GST_CMML_TAG_HEAD_META: + { + GValueArray *va = g_value_get_boxed (value); + + if (head->meta) + g_value_array_free (head->meta); + head->meta = va != NULL ? g_value_array_copy (va) : NULL; + break; + } + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +gst_cmml_tag_head_get_property (GObject * object, guint property_id, + GValue * value, GParamSpec * pspec) +{ + GstCmmlTagHead *head = GST_CMML_TAG_HEAD (object); + + switch (property_id) { + case GST_CMML_TAG_HEAD_TITLE: + g_value_set_string (value, (gchar *) head->title); + break; + case GST_CMML_TAG_HEAD_BASE: + g_value_set_string (value, (gchar *) head->base); + break; + case GST_CMML_TAG_HEAD_META: + g_value_set_boxed (value, head->meta); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +gst_cmml_tag_head_value_from_string_value (const GValue * src, GValue * dest) +{ + GstCmmlParser *parser; + const gchar *str; + guint size; + + parser = gst_cmml_parser_new (GST_CMML_PARSER_DECODE); + parser->user_data = dest; + parser->head_callback = (GstCmmlParserHeadCallback) set_object_on_value; + gst_cmml_parser_parse_chunk (parser, + default_preamble, strlen (default_preamble), NULL); + + str = g_value_get_string (src); + size = strlen (str); + gst_cmml_parser_parse_chunk (parser, str, size, NULL); + + gst_cmml_parser_free (parser); +} + +/* Clip tag */ +static void +gst_cmml_tag_clip_class_init (GstCmmlTagClipClass * clip_class) +{ + GObjectClass *klass = G_OBJECT_CLASS (clip_class); + + klass->set_property = gst_cmml_tag_clip_set_property; + klass->get_property = gst_cmml_tag_clip_get_property; + klass->finalize = gst_cmml_tag_clip_finalize; + + g_object_class_install_property (klass, GST_CMML_TAG_CLIP_EMPTY, + g_param_spec_boolean ("empty", + "Empty clip flag", + "An empty clip only marks the end of the previous clip", + TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_CLIP_ID, + g_param_spec_string ("id", + "Clip id", + "Id of the clip", NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_CLIP_TRACK, + g_param_spec_string ("track", + "Track number", + "The track this clip belongs to", + "default", G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_CLIP_START_TIME, + g_param_spec_uint64 ("start-time", + "Start time", + "The start time (in seconds) of the clip", + 0, G_MAXUINT64, GST_CLOCK_TIME_NONE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_CLIP_END_TIME, + g_param_spec_uint64 ("end-time", + "End time", + "The end time (in seconds) of the clip (only set if extract-mode=true)", + 0, G_MAXUINT64, GST_CLOCK_TIME_NONE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_CLIP_ANCHOR_HREF, + g_param_spec_string ("anchor-uri", + "Anchor URI", + "The location of a Web resource closely connected to the clip", + NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_CLIP_ANCHOR_TEXT, + g_param_spec_string ("anchor-text", + "Anchor text", + "A short description of the resource pointed by anchor-uri", + NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_CLIP_IMG_SRC, + g_param_spec_string ("img-uri", + "Image URI", + "The URI of a representative image for the clip", + NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_CLIP_IMG_ALT, + g_param_spec_string ("img-alt", + "Image alternative text", + "Alternative text to be displayed instead of the image " + "specified in img-uri", NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_CLIP_DESC_TEXT, + g_param_spec_string ("description", + "Description", + "A textual description of the content of the clip", + NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_CMML_TAG_CLIP_META, + g_param_spec_value_array ("meta", + "Meta annotations", + "Meta annotations for the clip", + NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_value_register_transform_func (G_TYPE_STRING, GST_TYPE_CMML_TAG_CLIP, + gst_cmml_tag_clip_value_from_string_value); +} + +static void +gst_cmml_tag_clip_init (GstCmmlTagClip * clip) +{ +} + +static void +gst_cmml_tag_clip_finalize (GObject * object) +{ + GstCmmlTagClip *clip = GST_CMML_TAG_CLIP (object); + + g_free (clip->id); + g_free (clip->track); + g_free (clip->anchor_href); + g_free (clip->anchor_text); + g_free (clip->img_src); + g_free (clip->img_alt); + g_free (clip->desc_text); + if (clip->meta) + g_value_array_free (clip->meta); + + if (G_OBJECT_CLASS (gst_cmml_tag_clip_parent_class)->finalize) + G_OBJECT_CLASS (gst_cmml_tag_clip_parent_class)->finalize (object); +} + +static void +gst_cmml_tag_clip_set_property (GObject * object, guint property_id, + const GValue * value, GParamSpec * pspec) +{ + GstCmmlTagClip *clip = GST_CMML_TAG_CLIP (object); + + switch (property_id) { + case GST_CMML_TAG_CLIP_EMPTY: + clip->empty = g_value_get_boolean (value); + break; + case GST_CMML_TAG_CLIP_ID: + g_free (clip->id); + clip->id = (guchar *) g_value_dup_string (value); + break; + case GST_CMML_TAG_CLIP_TRACK: + g_free (clip->track); + clip->track = (guchar *) g_value_dup_string (value); + break; + case GST_CMML_TAG_CLIP_START_TIME: + clip->start_time = g_value_get_uint64 (value); + break; + case GST_CMML_TAG_CLIP_END_TIME: + clip->end_time = g_value_get_uint64 (value); + break; + case GST_CMML_TAG_CLIP_ANCHOR_HREF: + g_free (clip->anchor_href); + clip->anchor_href = (guchar *) g_value_dup_string (value); + break; + case GST_CMML_TAG_CLIP_ANCHOR_TEXT: + g_free (clip->anchor_text); + clip->anchor_text = (guchar *) g_value_dup_string (value); + break; + case GST_CMML_TAG_CLIP_IMG_SRC: + g_free (clip->img_src); + clip->img_src = (guchar *) g_value_dup_string (value); + break; + case GST_CMML_TAG_CLIP_IMG_ALT: + g_free (clip->img_alt); + clip->img_alt = (guchar *) g_value_dup_string (value); + break; + case GST_CMML_TAG_CLIP_DESC_TEXT: + g_free (clip->desc_text); + clip->desc_text = (guchar *) g_value_dup_string (value); + break; + case GST_CMML_TAG_CLIP_META: + { + GValueArray *va = (GValueArray *) g_value_get_boxed (value); + + if (clip->meta) + g_value_array_free (clip->meta); + + clip->meta = va != NULL ? g_value_array_copy (va) : NULL; + + break; + } + } +} + +static void +gst_cmml_tag_clip_get_property (GObject * object, guint property_id, + GValue * value, GParamSpec * pspec) +{ + GstCmmlTagClip *clip = GST_CMML_TAG_CLIP (object); + + switch (property_id) { + case GST_CMML_TAG_CLIP_EMPTY: + g_value_set_boolean (value, clip->empty); + break; + case GST_CMML_TAG_CLIP_ID: + g_value_set_string (value, (gchar *) clip->id); + break; + case GST_CMML_TAG_CLIP_TRACK: + g_value_set_string (value, (gchar *) clip->track); + break; + case GST_CMML_TAG_CLIP_START_TIME: + g_value_set_uint64 (value, clip->start_time); + break; + case GST_CMML_TAG_CLIP_END_TIME: + g_value_set_uint64 (value, clip->end_time); + break; + case GST_CMML_TAG_CLIP_ANCHOR_HREF: + g_value_set_string (value, (gchar *) clip->anchor_href); + break; + case GST_CMML_TAG_CLIP_ANCHOR_TEXT: + g_value_set_string (value, (gchar *) clip->anchor_text); + break; + case GST_CMML_TAG_CLIP_IMG_SRC: + g_value_set_string (value, (gchar *) clip->img_src); + break; + case GST_CMML_TAG_CLIP_IMG_ALT: + g_value_set_string (value, (gchar *) clip->img_alt); + break; + case GST_CMML_TAG_CLIP_DESC_TEXT: + g_value_set_string (value, (gchar *) clip->desc_text); + break; + case GST_CMML_TAG_CLIP_META: + g_value_set_boxed (value, clip->meta); + break; + } +} + +static void +gst_cmml_tag_clip_value_from_string_value (const GValue * src, GValue * dest) +{ + GstCmmlParser *parser; + const gchar *str; + guint size; + + parser = gst_cmml_parser_new (GST_CMML_PARSER_DECODE); + parser->user_data = dest; + parser->clip_callback = (GstCmmlParserClipCallback) set_object_on_value; + + gst_cmml_parser_parse_chunk (parser, default_preamble, + strlen (default_preamble), NULL); + + str = g_value_get_string (src); + size = strlen (str); + + gst_cmml_parser_parse_chunk (parser, str, size, NULL); + + gst_cmml_parser_free (parser); +} + +static void +set_object_on_value (GObject * tag, GValue * dest) +{ + g_value_take_object (dest, tag); +} diff --git a/ext/annodex/gstcmmltag.h b/ext/annodex/gstcmmltag.h new file mode 100644 index 0000000..c8c0950 --- /dev/null +++ b/ext/annodex/gstcmmltag.h @@ -0,0 +1,131 @@ +/* + * gstcmmltag.h - GStreamer annodex CMML tag support + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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_CMML_TAG_H__ +#define __GST_CMML_TAG_H__ + +#include + +/* GstCmmlTagStream */ +#define GST_TYPE_CMML_TAG_STREAM (gst_cmml_tag_stream_get_type ()) +#define GST_CMML_TAG_STREAM(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), \ + GST_TYPE_CMML_TAG_STREAM, GstCmmlTagStream)) +#define GST_CMML_TAG_STREAM_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_CMML_TAG_STREAM, GstCmmlTagStream)) +#define GST_CMML_TAG_STREAM_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), \ + GST_TYPE_CMML_TAG_STREAM, GstCmmlTagStreamClass)) + +/* GstCmmlTagHead */ +#define GST_TYPE_CMML_TAG_HEAD (gst_cmml_tag_head_get_type ()) +#define GST_CMML_TAG_HEAD(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_CMML_TAG_HEAD, GstCmmlTagHead)) +#define GST_CMML_TAG_HEAD_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_CMML_TAG_HEAD, GstCmmlTagHead)) +#define GST_CMML_TAG_HEAD_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), \ + GST_TYPE_CMML_TAG_HEAD, GstCmmlTagHeadClass)) + +/* GstCmmlTagClip */ +#define GST_TYPE_CMML_TAG_CLIP (gst_cmml_tag_clip_get_type ()) +#define GST_CMML_TAG_CLIP(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_CMML_TAG_CLIP, GstCmmlTagClip)) +#define GST_CMML_TAG_CLIP_CLASS(obj) \ + (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_CMML_TAG_CLIP, GstCmmlTagClip)) +#define GST_CMML_TAG_CLIP_GET_CLASS(obj) \ +(G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_CMML_TAG_CLIP, GstCmmlTagClipClass)) + +typedef struct _GstCmmlTagStream GstCmmlTagStream; +typedef struct _GstCmmlTagStreamClass GstCmmlTagStreamClass; +typedef struct _GstCmmlTagHead GstCmmlTagHead; +typedef struct _GstCmmlTagHeadClass GstCmmlTagHeadClass; +typedef struct _GstCmmlTagClip GstCmmlTagClip; +typedef struct _GstCmmlTagClipClass GstCmmlTagClipClass; + +struct _GstCmmlTagStream { + GObject object; + + guchar *timebase; + guchar *utc; + + GValueArray *imports; +}; + +struct _GstCmmlTagStreamClass { + GObjectClass parent_class; +}; + +struct _GstCmmlTagHead { + GObject object; + + guchar *title; /* title of the media */ + guchar *base; + GValueArray *meta; /* metadata attached to the media. + * The elements are positioned in key-value + * pairs ie (key, content, key2, content2, + * ...) + */ +}; + +struct _GstCmmlTagHeadClass { + GObjectClass parent_class; +}; + +struct _GstCmmlTagClip { + GObject object; + + gboolean empty; /* empty flag. An empty clip marks the + * end of the previous clip. + */ + + guchar *id; /* clip id */ + guchar *track; /* clip track */ + + GstClockTime start_time; /* clip start time */ + GstClockTime end_time; /* clip end time */ + + guchar *anchor_href; /* anchor href URI */ + guchar *anchor_text; /* anchor text */ + + guchar *img_src; /* image URI */ + guchar *img_alt; /* image alternative text */ + + guchar *desc_text; /* clip description */ + + GValueArray *meta; /* metadata attached to the clip + * The elements are positioned in key-value + * pairs ie (key, content, key2, content2, + * ...) + */ +}; + +struct _GstCmmlTagClipClass { + GObjectClass parent_class; +}; + +GType gst_cmml_tag_stream_get_type (void); +GType gst_cmml_tag_head_get_type (void); +GType gst_cmml_tag_clip_get_type (void); + +#endif /* __GST_CMML_TAG_H__ */ diff --git a/ext/annodex/gstcmmlutils.c b/ext/annodex/gstcmmlutils.c new file mode 100644 index 0000000..8e3e4ff --- /dev/null +++ b/ext/annodex/gstcmmlutils.c @@ -0,0 +1,376 @@ +/* + * gstcmmlutils.c - GStreamer CMML utility functions + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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. + */ + +#include "gstcmmlutils.h" + +#include +#include + +typedef struct +{ + GList *clips; + gpointer user_data; +} GstCmmlTrack; + +GstClockTime +gst_cmml_clock_time_from_npt (const gchar * time) +{ + GstClockTime res; + gint fields; + gint hours = 0; + gint minutes = 0; + gint seconds = 0; + gint mseconds = 0; + GstClockTime hours_t = 0, seconds_t = 0; + + if (!strncmp (time, "npt:", 4)) + time += 4; + + /* parse npt-hhmmss */ + fields = sscanf (time, "%d:%d:%d.%d", &hours, &minutes, &seconds, &mseconds); + if (fields == 4) { + if (hours < 0 || (guint) minutes > 59 || (guint) seconds > 59) + goto bad_input; + + hours_t = gst_util_uint64_scale (hours, GST_SECOND * 3600, 1); + if (hours_t == G_MAXUINT64) + goto overflow; + + seconds_t = seconds * GST_SECOND; + } else { + /* parse npt-sec */ + hours_t = 0; + minutes = 0; + fields = sscanf (time, "%d.%d", &seconds, &mseconds); + if (seconds < 0) + goto bad_input; + + seconds_t = gst_util_uint64_scale (seconds, GST_SECOND, 1); + if (seconds == G_MAXUINT64) + goto overflow; + } + + if ((guint) mseconds > 999) + goto bad_input; + + res = (minutes * 60) * GST_SECOND + mseconds * GST_MSECOND; + if (G_MAXUINT64 - hours_t - seconds_t < res) + goto overflow; + + res += hours_t + seconds_t; + + return res; + +bad_input: +overflow: + return GST_CLOCK_TIME_NONE; +} + +GstClockTime +gst_cmml_clock_time_from_smpte (const gchar * time) +{ + GstClockTime res; + GstClockTime hours_t; + gint hours, minutes, seconds; + gdouble framerate; + gfloat frames; + gint fields; + + if (!strncmp (time, "smpte-24:", 9)) { + framerate = 24.0; + time += 9; + } else if (!strncmp (time, "smpte-24-drop:", 14)) { + framerate = 23.976; + time += 14; + } else if (!strncmp (time, "smpte-25:", 9)) { + framerate = 25.0; + time += 9; + } else if (!strncmp (time, "smpte-30:", 9)) { + framerate = 30.0; + time += 9; + } else if (!strncmp (time, "smpte-30-drop:", 14)) { + framerate = 29.976; + time += 14; + } else if (!strncmp (time, "smpte-50:", 9)) { + framerate = 50.0; + time += 9; + } else if (!strncmp (time, "smpte-60:", 9)) { + framerate = 60.0; + time += 9; + } else if (!strncmp (time, "smpte-60-drop:", 14)) { + framerate = 59.94; + time += 14; + } else { + return GST_CLOCK_TIME_NONE; + } + + fields = sscanf (time, "%d:%d:%d:%f", &hours, &minutes, &seconds, &frames); + if (fields == 4) { + if (hours < 0 || (guint) minutes > 59 || (guint) seconds > 59 || + frames < 0 || frames > ceil (framerate)) { + res = GST_CLOCK_TIME_NONE; + } else { + hours_t = gst_util_uint64_scale (hours, GST_SECOND * 3600, 1); + if (hours_t == G_MAXUINT64) + goto overflow; + + res = ((minutes * 60) + seconds + (frames / framerate)) + * GST_SECOND; + if (G_MAXUINT64 - hours_t < res) + goto overflow; + + res = hours_t + res; + } + } else { + res = GST_CLOCK_TIME_NONE; + } + + return res; +overflow: + return GST_CLOCK_TIME_NONE; +} + +gchar * +gst_cmml_clock_time_to_npt (const GstClockTime time) +{ + guint seconds, hours, minutes, mseconds; + gchar *res; + + g_return_val_if_fail (time != GST_CLOCK_TIME_NONE, NULL); + + hours = time / (GST_SECOND * 3600); + minutes = (time / ((GST_SECOND * 60)) % 60); + seconds = (time / GST_SECOND) % 60; + mseconds = (time % GST_SECOND) / GST_MSECOND; + + if (mseconds < 100) + mseconds *= 10; + + res = g_strdup_printf ("%u:%02u:%02u.%03u", + hours, minutes, seconds, mseconds); + + return res; +} + +gint64 +gst_cmml_clock_time_to_granule (GstClockTime prev_time, + GstClockTime current_time, gint64 granulerate_n, gint64 granulerate_d, + guint8 granuleshift) +{ + gint64 keyindex, keyoffset, granulepos; + gint64 granulerate; + + if (prev_time == GST_CLOCK_TIME_NONE) + prev_time = 0; + + if (prev_time > current_time) + return -1; + + granulerate = gst_util_uint64_scale (GST_SECOND, + granulerate_n, granulerate_d); + keyindex = prev_time / granulerate << granuleshift; + keyoffset = (current_time - prev_time) / granulerate; + granulepos = keyindex + keyoffset; + + return granulepos; +} + +/* track list */ +GHashTable * +gst_cmml_track_list_new () +{ + return g_hash_table_new (g_str_hash, g_str_equal); +} + +static gboolean +gst_cmml_track_list_destroy_track (gchar * key, + GstCmmlTrack * track, gpointer user_data) +{ + GList *walk; + + for (walk = track->clips; walk; walk = g_list_next (walk)) + g_object_unref (G_OBJECT (walk->data)); + + g_free (key); + g_list_free (track->clips); + g_free (track); + + return TRUE; +} + +void +gst_cmml_track_list_destroy (GHashTable * tracks) +{ + g_hash_table_foreach_remove (tracks, + (GHRFunc) gst_cmml_track_list_destroy_track, NULL); + g_hash_table_destroy (tracks); +} + +static gint +gst_cmml_track_list_compare_clips (GstCmmlTagClip * a, GstCmmlTagClip * b) +{ + if (a->start_time < b->start_time) + return -1; + + return 1; +} + +void +gst_cmml_track_list_add_clip (GHashTable * tracks, GstCmmlTagClip * clip) +{ + GstCmmlTrack *track = NULL; + gchar *track_name = NULL; + void *key = NULL, *value = NULL; + + /* find clip's track */ + g_hash_table_lookup_extended (tracks, clip->track, &key, &value); + track_name = (gchar *) key; + track = (GstCmmlTrack *) track; + + if (track_name == NULL) + /* it doesn't exist yet: create its key */ + track_name = g_strdup ((gchar *) clip->track); + + if (track == NULL) + track = g_new0 (GstCmmlTrack, 1); + + /* add clip to the tracklist */ + track->clips = g_list_insert_sorted (track->clips, g_object_ref (clip), + (GCompareFunc) gst_cmml_track_list_compare_clips); + + /* reset the head every time as it could change */ + g_hash_table_insert (tracks, track_name, track); +} + +gboolean +gst_cmml_track_list_del_clip (GHashTable * tracks, GstCmmlTagClip * clip) +{ + GstCmmlTrack *track; + GList *link; + gboolean res = FALSE; + + track = g_hash_table_lookup (tracks, clip->track); + if (track) { + link = g_list_find (track->clips, clip); + if (link) { + g_object_unref (G_OBJECT (link->data)); + track->clips = g_list_remove_link (track->clips, link); + res = TRUE; + } + } + + return res; +} + +gboolean +gst_cmml_track_list_has_clip (GHashTable * tracks, GstCmmlTagClip * clip) +{ + GstCmmlTrack *track; + GList *walk; + GstCmmlTagClip *tmp; + gchar *clip_id = (gchar *) clip->id; + gboolean res = FALSE; + + track = g_hash_table_lookup (tracks, clip_id); + if (track) { + for (walk = track->clips; walk; walk = g_list_next (walk)) { + tmp = GST_CMML_TAG_CLIP (walk->data); + if (!strcmp ((gchar *) tmp->id, clip_id)) { + res = TRUE; + break; + } + } + } + + return res; +} + +static gboolean +gst_cmml_track_list_merge_track (gchar * track_name, + GstCmmlTrack * track, GList ** list) +{ + GList *walk; + GstCmmlTagClip *cur; + + for (walk = track->clips; walk; walk = g_list_next (walk)) { + cur = GST_CMML_TAG_CLIP (walk->data); + *list = g_list_insert_sorted (*list, cur, + (GCompareFunc) gst_cmml_track_list_compare_clips); + } + + return TRUE; +} + +GList * +gst_cmml_track_list_get_track_clips (GHashTable * tracks, + const gchar * track_name) +{ + GstCmmlTrack *track; + + track = g_hash_table_lookup (tracks, track_name); + return track ? track->clips : NULL; +} + +GList * +gst_cmml_track_list_get_clips (GHashTable * tracks) +{ + GList *list = NULL; + + g_hash_table_foreach (tracks, + (GHFunc) gst_cmml_track_list_merge_track, &list); + return list; +} + +GstCmmlTagClip * +gst_cmml_track_list_get_track_last_clip (GHashTable * tracks, + const gchar * track_name) +{ + GstCmmlTrack *track; + GList *res = NULL; + + track = g_hash_table_lookup (tracks, track_name); + if (track && track->clips) + res = g_list_last (track->clips); + + return res ? GST_CMML_TAG_CLIP (res->data) : NULL; +} + +void +gst_cmml_track_list_set_data (GHashTable * tracks, + const gchar * track_name, gpointer data) +{ + GstCmmlTrack *track; + + track = g_hash_table_lookup (tracks, track_name); + if (track) + track->user_data = data; +} + +gpointer +gst_cmml_track_get_data (GHashTable * tracks, const gchar * track_name) +{ + GstCmmlTrack *track; + + track = g_hash_table_lookup (tracks, track_name); + return track ? track->user_data : NULL; +} diff --git a/ext/annodex/gstcmmlutils.h b/ext/annodex/gstcmmlutils.h new file mode 100644 index 0000000..5aa2416 --- /dev/null +++ b/ext/annodex/gstcmmlutils.h @@ -0,0 +1,53 @@ +/* + * gstcmmlutils.h - GStreamer CMML utility functions + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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_CMML_CLOCK_TIME_H__ +#define __GST_CMML_CLOCK_TIME_H__ + +#include +#include "gstcmmltag.h" + +/* time utils */ +GstClockTime gst_cmml_clock_time_from_npt (const gchar * time); +GstClockTime gst_cmml_clock_time_from_smpte (const gchar * time); +gchar * gst_cmml_clock_time_to_npt (const GstClockTime time); +gint64 gst_cmml_clock_time_to_granule (GstClockTime prev_time, + GstClockTime current_time, gint64 granulerate_n, gint64 granulerate_d, + guint8 granuleshift); + +/* tracklist */ +GHashTable * gst_cmml_track_list_new (void); +void gst_cmml_track_list_destroy (GHashTable * tracks); +void gst_cmml_track_list_add_clip (GHashTable * tracks, GstCmmlTagClip * clip); +gboolean gst_cmml_track_list_del_clip (GHashTable * tracks, + GstCmmlTagClip * clip); +gboolean gst_cmml_track_list_has_clip (GHashTable * tracks, + GstCmmlTagClip * clip); +GstCmmlTagClip * gst_cmml_track_list_get_track_last_clip (GHashTable * tracks, + const gchar * track_name); +GList * gst_cmml_track_list_get_track_clips (GHashTable * tracks, + const gchar * track_name); +GList * gst_cmml_track_list_get_clips (GHashTable * tracks); +void gst_cmml_track_list_set_track_data (GHashTable * tracks, gpointer data); +gpointer gst_cmml_track_list_get_track_data (GHashTable * tracks); +#endif /* __GST_CMML_CLOCK_TIME_H__ */ diff --git a/ext/annodex/gstskeldec.c b/ext/annodex/gstskeldec.c new file mode 100644 index 0000000..6e72c79 --- /dev/null +++ b/ext/annodex/gstskeldec.c @@ -0,0 +1,380 @@ +/* + * gstskeldec.c - GStreamer annodex skeleton decoder + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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. + */ + +#include +#include "gstskeldec.h" +#include "gstskeltag.h" +#include "gstannodex.h" + +GST_DEBUG_CATEGORY (skeldec); +#define GST_CAT_DEFAULT skeldec + +#define FISHEAD_SIZE 64 +#define FISBONE_MIN_SIZE 52 + +enum +{ + GST_SKEL_TAG_FISHEAD_UTC_LEN = 19 +}; + +enum +{ + LAST_SIGNAL +}; + +static GstElementDetails gst_skel_dec_details = { + "skeldec: Annodex skeleton stream decoder", + "Codec/Decoder", + "Decodes ogg skeleton streams", + "Alessandro Decina ", +}; + +static GstStaticPadTemplate gst_skel_dec_src_factory = +GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("application/x-ogg-skeleton, parsed=(boolean)TRUE") + ); + +static GstStaticPadTemplate gst_skel_dec_sink_factory = +GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("application/x-ogg-skeleton, parsed=(boolean)FALSE") + ); + +/* GstSkelDec prototypes */ +GST_BOILERPLATE (GstSkelDec, gst_skel_dec, GstElement, GST_TYPE_ELEMENT); +static gboolean gst_skel_dec_sink_query (GstPad * pad, GstQuery * query); +static GstStateChangeReturn gst_skel_dec_change_state (GstElement * element, + GstStateChange transition); +static GstFlowReturn gst_skel_dec_chain (GstPad * pad, GstBuffer * buffer); +static GstFlowReturn gst_skel_dec_parse_fishead (GstSkelDec * dec, + GstBuffer * buffer); +static GstFlowReturn gst_skel_dec_parse_fisbone (GstSkelDec * dec, + GstBuffer * buffer); + +/* GstSkelDec code */ +static void +gst_skel_dec_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_skel_dec_sink_factory)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&gst_skel_dec_src_factory)); + gst_element_class_set_details (element_class, &gst_skel_dec_details); +} + +static void +gst_skel_dec_class_init (GstSkelDecClass * klass) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + + element_class->change_state = gst_skel_dec_change_state; +} + +static void +gst_skel_dec_init (GstSkelDec * dec, GstSkelDecClass * klass) +{ + dec->sinkpad = + gst_pad_new_from_static_template (&gst_skel_dec_sink_factory, "sink"); + gst_pad_set_query_function (dec->sinkpad, gst_skel_dec_sink_query); + gst_pad_set_chain_function (dec->sinkpad, gst_skel_dec_chain); + gst_element_add_pad (GST_ELEMENT (dec), dec->sinkpad); + + dec->srcpad = + gst_pad_new_from_static_template (&gst_skel_dec_src_factory, "src"); + gst_element_add_pad (GST_ELEMENT (dec), dec->srcpad); + +} + +static gboolean +gst_skel_dec_sink_query (GstPad * pad, GstQuery * query) +{ + gboolean res = FALSE; + + switch (GST_QUERY_TYPE (query)) { + case GST_QUERY_CONVERT: + { + GstFormat src_format, dest_format; + gint64 src_val, dest_val; + + gst_query_parse_convert (query, &src_format, &src_val, + &dest_format, &dest_val); + + if (dest_format == GST_FORMAT_TIME) { + dest_val = GST_CLOCK_TIME_NONE; + res = TRUE; + } + + if (res) { + gst_query_set_convert (query, src_format, src_val, + dest_format, dest_val); + } + + break; + } + default: + break; + } + + return res; +} + +static GstStateChangeReturn +gst_skel_dec_change_state (GstElement * element, GstStateChange transition) +{ + GstSkelDec *dec = GST_SKEL_DEC (element); + GstStateChangeReturn res; + + /* handle the upward state changes */ + switch (transition) { + case GST_STATE_CHANGE_READY_TO_PAUSED: + dec->major = 0; + dec->minor = 0; + break; + default: + break; + } + + res = parent_class->change_state (element, transition); + + /* no need to handle downward state changes */ + + return res; +} + +static GstFlowReturn +gst_skel_dec_chain (GstPad * pad, GstBuffer * buffer) +{ + GstSkelDec *dec = GST_SKEL_DEC (GST_PAD_PARENT (pad)); + GstFlowReturn ret; + + gint size = GST_BUFFER_SIZE (buffer); + guint8 *data = GST_BUFFER_DATA (buffer); + + if (GST_BUFFER_SIZE (buffer) == 0) { + /* the skeleton EOS has no packet data */ + return GST_FLOW_OK; + } + + if (size >= GST_SKEL_OGG_FISHEAD_SIZE && !memcmp (data, "fishead\0", 8)) { + ret = gst_skel_dec_parse_fishead (dec, buffer); + } else if (size >= 8 && !memcmp (data, "fisbone\0", 8)) { + ret = gst_skel_dec_parse_fisbone (dec, buffer); + } else { + /* maybe it would be better to ignore the packet */ + GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL), ("unknown packet type")); + ret = GST_FLOW_UNEXPECTED; + } + + return ret; +} + +static GstFlowReturn +gst_skel_dec_parse_fishead (GstSkelDec * dec, GstBuffer * buffer) +{ + GstTagList *tags; + guint8 *data = GST_BUFFER_DATA (buffer); + GstSkelTagFishead *fishead; + + if (GST_BUFFER_SIZE (buffer) != FISHEAD_SIZE) + goto wrong_size; + + fishead = g_object_new (GST_TYPE_SKEL_TAG_FISHEAD, NULL); + + data += 8; + fishead->major = GST_READ_UINT16_LE (data); + data += 2; + fishead->minor = GST_READ_UINT16_LE (data); + data += 2; + fishead->prestime_n = (gint64) GST_READ_UINT64_LE (data); + data += 8; + fishead->prestime_d = (gint64) GST_READ_UINT64_LE (data); + data += 8; + fishead->basetime_n = (gint64) GST_READ_UINT64_LE (data); + data += 8; + fishead->basetime_d = (gint64) GST_READ_UINT64_LE (data); + data += 8; + fishead->utc = g_strndup ((gchar *) data, GST_SKEL_TAG_FISHEAD_UTC_LEN); + + GST_INFO_OBJECT (dec, "fishead parsed (" + "major: %" G_GUINT16_FORMAT " minor: %" G_GUINT16_FORMAT + " prestime_n: %" G_GINT64_FORMAT " prestime_d: %" G_GINT64_FORMAT + " basetime_n: %" G_GINT64_FORMAT " basetime_d: %" G_GINT64_FORMAT + " utc: %s)", fishead->major, fishead->minor, fishead->prestime_n, + fishead->prestime_d, fishead->basetime_n, fishead->basetime_d, + fishead->utc); + + /* send the TAG_MESSAGE */ + tags = gst_tag_list_new (); + gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, + GST_TAG_SKELETON_FISHEAD, fishead, NULL); + gst_element_found_tags_for_pad (GST_ELEMENT (dec), dec->srcpad, tags); + + g_object_unref (fishead); + + /* forward the fishead */ + gst_buffer_set_caps (buffer, + gst_static_pad_template_get_caps (&gst_skel_dec_src_factory)); + return gst_pad_push (dec->srcpad, buffer); + +wrong_size: + GST_ELEMENT_ERROR (dec, STREAM, DECODE, + (NULL), ("wrong fishead packet size: %d", GST_BUFFER_SIZE (buffer))); + + gst_buffer_unref (buffer); + return GST_FLOW_ERROR; +} + +static GstFlowReturn +gst_skel_dec_parse_fisbone (GstSkelDec * dec, GstBuffer * buffer) +{ + GstSkelTagFisbone *fisbone; + guint8 *data; + gchar *headers; + gchar **tokens; + const gchar *content_type; + GstTagList *tags; + GValue *val; + + if (GST_BUFFER_SIZE (buffer) < FISBONE_MIN_SIZE) + goto wrong_size; + + data = GST_BUFFER_DATA (buffer); + fisbone = g_object_new (GST_TYPE_SKEL_TAG_FISBONE, NULL); + + data += 8; + fisbone->hdr_offset = GST_READ_UINT32_LE (data); + data += 4; + fisbone->serialno = GST_READ_UINT32_LE (data); + data += 4; + fisbone->hdr_num = GST_READ_UINT32_LE (data); + data += 4; + fisbone->granulerate_n = GST_READ_UINT64_LE (data); + data += 8; + fisbone->granulerate_d = GST_READ_UINT64_LE (data); + data += 8; + fisbone->start_granule = GST_READ_UINT64_LE (data); + data += 8; + fisbone->preroll = GST_READ_UINT32_LE (data); + data += 4; + fisbone->granuleshift = GST_READ_UINT8 (data); + data += 1; + data += 3; /* padding */ + + /* 8 = strlen ("fishead\0") */ + headers = g_strndup ((gchar *) data, + GST_BUFFER_SIZE (buffer) - 8 - fisbone->hdr_offset); + fisbone->headers = gst_annodex_parse_headers (headers); + g_free (headers); + + if (!fisbone->headers) + goto bad_headers; + + /* check for the mandatory Content-Type header: it MUST be the first + * header */ + if (fisbone->headers->n_values < 2 || + (val = g_value_array_get_nth (fisbone->headers, 0)) == NULL || + strcmp (g_value_get_string (val), "Content-Type")) + goto no_content_type; + + /* get the Content-Type value */ + val = g_value_array_get_nth (fisbone->headers, 1); + content_type = g_value_get_string (val); + + /* Content-Type must not be empty */ + if (*content_type == '\0') + goto bad_content_type; + + /* split the content-type field into "content_type; encoding" */ + tokens = g_strsplit (content_type, ";", 2); + fisbone->content_type = g_strdup (g_strstrip (tokens[0])); + fisbone->encoding = tokens[1] == NULL ? NULL : + g_strdup (g_strstrip (tokens[1])); + g_strfreev (tokens); + + GST_INFO_OBJECT (dec, "fisbone parsed (" + "serialno %" G_GUINT32_FORMAT " granulerate_n: %" G_GINT64_FORMAT + " granulerate_d: %" G_GINT64_FORMAT " start_granule: %" G_GINT64_FORMAT + " preroll: %" G_GUINT32_FORMAT " granuleshift: %d" + " content-type: %s)", + fisbone->serialno, fisbone->granulerate_n, fisbone->granulerate_d, + fisbone->start_granule, fisbone->preroll, fisbone->granuleshift, + fisbone->content_type); + + /* send the tag message */ + tags = gst_tag_list_new (); + gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, + GST_TAG_SKELETON_FISBONE, fisbone, NULL); + gst_element_found_tags_for_pad (GST_ELEMENT (dec), dec->srcpad, tags); + + g_object_unref (fisbone); + + gst_buffer_set_caps (buffer, + gst_static_pad_template_get_caps (&gst_skel_dec_src_factory)); + return gst_pad_push (dec->srcpad, buffer); + +wrong_size: + GST_ELEMENT_ERROR (dec, STREAM, DECODE, + (NULL), ("wrong fisbone size (%d)", GST_BUFFER_SIZE (buffer))); + gst_buffer_unref (buffer); + return GST_FLOW_ERROR; + +bad_headers: + GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL), ("bad fisbone headers")); + gst_buffer_unref (buffer); + g_object_unref (fisbone); + return GST_FLOW_ERROR; + +no_content_type: +bad_content_type: + GST_ELEMENT_ERROR (dec, STREAM, DECODE, + (NULL), ("missing or bad fisbone content-type")); + gst_buffer_unref (buffer); + g_object_unref (fisbone); + return GST_FLOW_ERROR; +} + +gboolean +gst_skel_dec_plugin_init (GstPlugin * plugin) +{ + if (!gst_element_register (plugin, "skeldec", GST_RANK_PRIMARY, + gst_skel_dec_get_type ())) + return FALSE; + + gst_tag_register (GST_TAG_SKELETON_FISHEAD, GST_TAG_FLAG_META, + GST_TYPE_SKEL_TAG_FISHEAD, "skeleton-fishead", + "annodex skeleton fishead tag", NULL); + + gst_tag_register (GST_TAG_SKELETON_FISBONE, GST_TAG_FLAG_META, + GST_TYPE_SKEL_TAG_FISBONE, "skeleton-fisbone", + "annodex skeleton fisbone tag", NULL); + + GST_DEBUG_CATEGORY_INIT (skeldec, "skeldec", 0, + "annodex skeleton decoding element"); + + return TRUE; +} diff --git a/ext/annodex/gstskeldec.h b/ext/annodex/gstskeldec.h new file mode 100644 index 0000000..b6eceaf --- /dev/null +++ b/ext/annodex/gstskeldec.h @@ -0,0 +1,62 @@ +/* + * gstskeldec.h - GStreamer annodex skeleton decoder + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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_SKEL_DEC_H__ +#define __GST_SKEL_DEC_H__ + +#include + +/* GstSkelDec */ +#define GST_TYPE_SKEL_DEC (gst_skel_dec_get_type ()) +#define GST_SKEL_DEC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_SKEL_DEC, GstSkelDec)) +#define GST_SKEL_DEC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_SKEL_DEC, GstSkelDec)) +#define GST_SKEL_DEC_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_SKEL_DEC, GstSkelDecClass)) + +typedef struct _GstSkelDec GstSkelDec; +typedef struct _GstSkelDecClass GstSkelDecClass; + +#define GST_SKEL_OGG_FISHEAD_SIZE 64 +#define UTC_LEN 20 + +struct _GstSkelDec +{ + GstElement element; + + GstPad *sinkpad; + GstPad *srcpad; + + gint16 major; /* skeleton version major */ + gint16 minor; /* skeleton version minor */ +}; + +struct _GstSkelDecClass +{ + GstElementClass parent_class; +}; + +GType gst_skel_dec_get_type (void); +gboolean gst_skel_dec_plugin_init (GstPlugin * plugin); + +#endif /* __GST_SKEL_DEC_H__ */ diff --git a/ext/annodex/gstskeltag.c b/ext/annodex/gstskeltag.c new file mode 100644 index 0000000..3bd3a67 --- /dev/null +++ b/ext/annodex/gstskeltag.c @@ -0,0 +1,371 @@ +/* + * gstskeltag.c - GStreamer annodex skeleton tags + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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. + */ + +#include "gstskeltag.h" + +enum +{ + ARG_0, + GST_SKEL_TAG_FISHEAD_MAJOR, + GST_SKEL_TAG_FISHEAD_MINOR, + GST_SKEL_TAG_FISHEAD_PRESTIME_N, + GST_SKEL_TAG_FISHEAD_PRESTIME_D, + GST_SKEL_TAG_FISHEAD_BASETIME_N, + GST_SKEL_TAG_FISHEAD_BASETIME_D, + GST_SKEL_TAG_FISHEAD_UTC, + GST_SKEL_TAG_FISBONE_SERIALNO, + GST_SKEL_TAG_FISBONE_GRANULERATE_N, + GST_SKEL_TAG_FISBONE_GRANULERATE_D, + GST_SKEL_TAG_FISBONE_START_GRANULE, + GST_SKEL_TAG_FISBONE_PREROLL, + GST_SKEL_TAG_FISBONE_GRANULESHIFT, + GST_SKEL_TAG_FISBONE_HEADERS, + GST_SKEL_TAG_FISBONE_CONTENT_TYPE, + GST_SKEL_TAG_FISBONE_ENCODING, +}; + +/* GstSkelTagFishead prototypes */ +G_DEFINE_TYPE (GstSkelTagFishead, gst_skel_tag_fishead, G_TYPE_OBJECT); +static void gst_skel_tag_fishead_finalize (GObject * object); +static void gst_skel_tag_fishead_set_property (GObject * object, + guint property_id, const GValue * value, GParamSpec * pspec); +static void gst_skel_tag_fishead_get_property (GObject * object, + guint property_id, GValue * value, GParamSpec * pspec); + +/* GstSkelTagFisbone prototypes */ +G_DEFINE_TYPE (GstSkelTagFisbone, gst_skel_tag_fisbone, G_TYPE_OBJECT); +static void gst_skel_tag_fisbone_finalize (GObject * object); +static void gst_skel_tag_fisbone_set_property (GObject * object, + guint property_id, const GValue * value, GParamSpec * pspec); +static void gst_skel_tag_fisbone_get_property (GObject * object, + guint property_id, GValue * value, GParamSpec * pspec); + +/* GstSkelTagFishead */ +static void +gst_skel_tag_fishead_class_init (GstSkelTagFisheadClass * fishead_class) +{ + GObjectClass *klass = G_OBJECT_CLASS (fishead_class); + + klass->set_property = gst_skel_tag_fishead_set_property; + klass->get_property = gst_skel_tag_fishead_get_property; + klass->finalize = gst_skel_tag_fishead_finalize; + + g_object_class_install_property (klass, GST_SKEL_TAG_FISHEAD_MAJOR, + g_param_spec_int ("version-major", + "Major version number", + "Major number of the skeleton bitstream", + 0, 0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISHEAD_MINOR, + g_param_spec_int ("version-minor", + "Minor version number", + "Minor number of the skeleton bitstream", + 0, 0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISHEAD_PRESTIME_N, + g_param_spec_int64 ("presentation-time-numerator", + "Presentation time numerator", + "Stream presentation time numerator", + 0, 0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + + g_object_class_install_property (klass, GST_SKEL_TAG_FISHEAD_PRESTIME_D, + g_param_spec_int64 ("presentation-time-denominator", + "Presentation time denominator", + "Stream presentation time denominator", + 0, 0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISHEAD_BASETIME_N, + g_param_spec_int64 ("base-time-numerator", + "Basetime numerator", + "Stream base time numerator", + 0, 0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISHEAD_BASETIME_D, + g_param_spec_int64 ("base-time-denominator", + "Base time denominator", + "Stream base time denominator", + 0, 0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISHEAD_UTC, + g_param_spec_string ("calendar-base-time", + "Calendar base time", + "Date and all-clock time (expressed as UTC in the format " + "YYYYMMDDTHHMMSS.sssZ) associated with the base time", + NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); +} + +static void +gst_skel_tag_fishead_init (GstSkelTagFishead * fishead) +{ +} + +static void +gst_skel_tag_fishead_finalize (GObject * object) +{ + GObjectClass *parent_class = + G_OBJECT_CLASS (gst_skel_tag_fishead_parent_class); + GstSkelTagFishead *fishead = GST_SKEL_TAG_FISHEAD (object); + + g_free (fishead->utc); + + GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object)); +} + +static void +gst_skel_tag_fishead_set_property (GObject * object, guint property_id, + const GValue * value, GParamSpec * pspec) +{ + GstSkelTagFishead *fishead = GST_SKEL_TAG_FISHEAD (object); + + switch (property_id) { + case GST_SKEL_TAG_FISHEAD_MAJOR: + fishead->major = g_value_get_int (value); + break; + case GST_SKEL_TAG_FISHEAD_MINOR: + fishead->minor = g_value_get_int (value); + break; + case GST_SKEL_TAG_FISHEAD_PRESTIME_N: + fishead->prestime_n = g_value_get_int64 (value); + break; + case GST_SKEL_TAG_FISHEAD_PRESTIME_D: + fishead->prestime_d = g_value_get_int64 (value); + break; + case GST_SKEL_TAG_FISHEAD_BASETIME_N: + fishead->basetime_n = g_value_get_int64 (value); + break; + case GST_SKEL_TAG_FISHEAD_BASETIME_D: + fishead->basetime_d = g_value_get_int64 (value); + break; + case GST_SKEL_TAG_FISHEAD_UTC: + g_free (fishead->utc); + fishead->utc = g_value_dup_string (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +gst_skel_tag_fishead_get_property (GObject * object, guint property_id, + GValue * value, GParamSpec * pspec) +{ + GstSkelTagFishead *fishead = GST_SKEL_TAG_FISHEAD (object); + + switch (property_id) { + case GST_SKEL_TAG_FISHEAD_MAJOR: + g_value_set_int (value, fishead->major); + break; + case GST_SKEL_TAG_FISHEAD_MINOR: + g_value_set_int (value, fishead->minor); + break; + case GST_SKEL_TAG_FISHEAD_BASETIME_N: + g_value_set_int64 (value, fishead->basetime_n); + break; + case GST_SKEL_TAG_FISHEAD_BASETIME_D: + g_value_set_int64 (value, fishead->basetime_d); + break; + case GST_SKEL_TAG_FISHEAD_PRESTIME_N: + g_value_set_int64 (value, fishead->prestime_n); + break; + case GST_SKEL_TAG_FISHEAD_PRESTIME_D: + g_value_set_int64 (value, fishead->prestime_d); + break; + case GST_SKEL_TAG_FISHEAD_UTC: + g_value_set_string (value, fishead->utc); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +/* GstSkelTagFisbone code */ + +static void +gst_skel_tag_fisbone_class_init (GstSkelTagFisboneClass * fisbone_class) +{ + GObjectClass *klass = G_OBJECT_CLASS (fisbone_class); + + klass->set_property = gst_skel_tag_fisbone_set_property; + klass->get_property = gst_skel_tag_fisbone_get_property; + klass->finalize = gst_skel_tag_fisbone_finalize; + + g_object_class_install_property (klass, GST_SKEL_TAG_FISBONE_SERIALNO, + g_param_spec_uint ("serial-number", + "Serial number", + "Serial number of the logical bitstream", + 0, 0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISBONE_GRANULERATE_N, + g_param_spec_int64 ("granule-rate-numerator", + "Granulerate numerator", + "Granulerate numerator", + 0, 0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISBONE_GRANULERATE_D, + g_param_spec_int64 ("granule-rate-denominator", + "Granulerate denominator", + "Granulerate denominator", + 0, 0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISBONE_START_GRANULE, + g_param_spec_int64 ("granule-start", + "Start granule", + "The granule number with which this logical bitstream starts", + 0, 0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISBONE_PREROLL, + g_param_spec_uint64 ("preroll", + "The number of packets to preroll", + "The number of packets to preroll to decode a packet correctly", + 0, 0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISBONE_GRANULESHIFT, + g_param_spec_uint ("granule-shift", + "Granuleshift", + "The number of lower bits to use for partitioning a granule position", + 0, 0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISBONE_HEADERS, + g_param_spec_boxed ("headers", + "Message header fields", + "RFC2822 header fields describing a logical bitstream", + G_TYPE_VALUE_ARRAY, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISBONE_CONTENT_TYPE, + g_param_spec_string ("content-type", + "Content type", + "Bitstream content type", + NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + + g_object_class_install_property (klass, GST_SKEL_TAG_FISBONE_ENCODING, + g_param_spec_string ("encoding", + "Encoding", + "Bitstream encoding", NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); +} + +static void +gst_skel_tag_fisbone_init (GstSkelTagFisbone * fisbone) +{ +} + +static void +gst_skel_tag_fisbone_finalize (GObject * object) +{ + GObjectClass *parent_class = + G_OBJECT_CLASS (gst_skel_tag_fishead_parent_class); + GstSkelTagFisbone *fisbone = GST_SKEL_TAG_FISBONE (object); + + g_free (fisbone->content_type); + g_free (fisbone->encoding); + g_value_array_free (fisbone->headers); + + GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object)); +} + +static void +gst_skel_tag_fisbone_set_property (GObject * object, guint property_id, + const GValue * value, GParamSpec * pspec) +{ + GstSkelTagFisbone *fisbone = GST_SKEL_TAG_FISBONE (object); + + switch (property_id) { + case GST_SKEL_TAG_FISBONE_SERIALNO: + fisbone->serialno = g_value_get_uint (value); + break; + case GST_SKEL_TAG_FISBONE_GRANULERATE_N: + fisbone->granulerate_n = g_value_get_int64 (value); + break; + case GST_SKEL_TAG_FISBONE_GRANULERATE_D: + fisbone->granulerate_d = g_value_get_int64 (value); + break; + case GST_SKEL_TAG_FISBONE_START_GRANULE: + fisbone->start_granule = g_value_get_int64 (value); + break; + case GST_SKEL_TAG_FISBONE_PREROLL: + fisbone->preroll = g_value_get_uint64 (value); + break; + case GST_SKEL_TAG_FISBONE_GRANULESHIFT: + fisbone->granuleshift = g_value_get_uint (value); + break; + case GST_SKEL_TAG_FISBONE_HEADERS: + { + GValueArray *va; + + va = g_value_get_boxed (value); + if (fisbone->headers) + g_value_array_free (fisbone->headers); + fisbone->headers = va != NULL ? g_value_array_copy (va) : NULL; + break; + } + case GST_SKEL_TAG_FISBONE_CONTENT_TYPE: + g_free (fisbone->content_type); + fisbone->content_type = g_value_dup_string (value); + break; + case GST_SKEL_TAG_FISBONE_ENCODING: + g_free (fisbone->encoding); + fisbone->encoding = g_value_dup_string (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +gst_skel_tag_fisbone_get_property (GObject * object, guint property_id, + GValue * value, GParamSpec * pspec) +{ + GstSkelTagFisbone *fisbone = GST_SKEL_TAG_FISBONE (object); + + switch (property_id) { + case GST_SKEL_TAG_FISBONE_SERIALNO: + g_value_set_uint (value, fisbone->serialno); + break; + case GST_SKEL_TAG_FISBONE_GRANULERATE_N: + g_value_set_int64 (value, fisbone->granulerate_n); + break; + case GST_SKEL_TAG_FISBONE_GRANULERATE_D: + g_value_set_int64 (value, fisbone->granulerate_d); + break; + case GST_SKEL_TAG_FISBONE_START_GRANULE: + g_value_set_int64 (value, fisbone->start_granule); + break; + case GST_SKEL_TAG_FISBONE_GRANULESHIFT: + g_value_set_uint (value, fisbone->granuleshift); + break; + case GST_SKEL_TAG_FISBONE_PREROLL: + g_value_set_uint64 (value, fisbone->preroll); + break; + case GST_SKEL_TAG_FISBONE_HEADERS: + g_value_set_boxed (value, fisbone->headers); + break; + case GST_SKEL_TAG_FISBONE_CONTENT_TYPE: + g_value_set_string (value, fisbone->content_type); + break; + case GST_SKEL_TAG_FISBONE_ENCODING: + g_value_set_string (value, fisbone->encoding); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} diff --git a/ext/annodex/gstskeltag.h b/ext/annodex/gstskeltag.h new file mode 100644 index 0000000..80c5bf6 --- /dev/null +++ b/ext/annodex/gstskeltag.h @@ -0,0 +1,101 @@ +/* + * gstskeltag.h - GStreamer annodex skeleton tags + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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_SKEL_TAG_H__ +#define __GST_SKEL_TAG_H__ + +#include + +/* GstSkelTagFishead */ +#define GST_TYPE_SKEL_TAG_FISHEAD (gst_skel_tag_fishead_get_type ()) +#define GST_SKEL_TAG_FISHEAD(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_SKEL_TAG_FISHEAD, \ + GstSkelTagFishead)) +#define GST_SKEL_TAG_FISHEAD_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_SKEL_TAG_FISHEAD, \ + GstSkelTagFishead)) +#define GST_SKEL_TAG_FISHEAD_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_SKEL_TAG_FISHEAD, \ + GstSkelTagFisheadClass)) + +/* GstSkelTagFisbone */ +#define GST_TYPE_SKEL_TAG_FISBONE (gst_skel_tag_fisbone_get_type ()) +#define GST_SKEL_TAG_FISBONE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_SKEL_TAG_FISBONE, \ + GstSkelTagFisbone)) +#define GST_SKEL_TAG_FISBONE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_SKEL_TAG_FISBONE, \ + GstSkelTagFisbone)) +#define GST_SKEL_TAG_FISBONE_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_SKEL_TAG_FISBONE, \ + GstSkelTagFisboneClass)) + +typedef struct _GstSkelTagFishead GstSkelTagFishead; +typedef struct _GstSkelTagFisheadClass GstSkelTagFisheadClass; + +typedef struct _GstSkelTagFisbone GstSkelTagFisbone; +typedef struct _GstSkelTagFisboneClass GstSkelTagFisboneClass; + + +struct _GstSkelTagFishead { + GObject object; + + guint16 major; + guint16 minor; + + gint64 prestime_n; + gint64 prestime_d; + + gint64 basetime_n; + gint64 basetime_d; + + gchar *utc; +}; + +struct _GstSkelTagFisheadClass { + GObjectClass parent_class; +}; + +struct _GstSkelTagFisbone { + GObject object; + + guint32 hdr_offset; + guint32 serialno; + guint32 hdr_num; + gint64 granulerate_n; + gint64 granulerate_d; + gint64 start_granule; + guint32 preroll; + guint8 granuleshift; + gchar *content_type; + gchar *encoding; + GValueArray *headers; +}; + +struct _GstSkelTagFisboneClass { + GObjectClass parent_class; +}; + +GType gst_skel_tag_fishead_get_type (void); +GType gst_skel_tag_fisbone_get_type (void); + +#endif /* __GST_SKEL_TAG_H__ */ diff --git a/tests/check/Makefile.am b/tests/check/Makefile.am index 4826e4e..70a7fbf 100644 --- a/tests/check/Makefile.am +++ b/tests/check/Makefile.am @@ -19,7 +19,10 @@ TESTS = $(check_PROGRAMS) check_PROGRAMS = \ elements/level \ - elements/matroskamux + elements/matroskamux \ + elements/cmmldec \ + elements/cmmlenc \ + elements/skeldec # these tests don't even pass diff --git a/tests/check/elements/cmmldec.c b/tests/check/elements/cmmldec.c new file mode 100644 index 0000000..f2498d2 --- /dev/null +++ b/tests/check/elements/cmmldec.c @@ -0,0 +1,409 @@ +/* + * cmmldec.c - GStreamer CMML decoder test suite + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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. + */ + +#include + +#define SINK_CAPS "text/xml" +#define SRC_CAPS "text/x-cmml" + +#define IDENT_HEADER \ + "CMML\x00\x00\x00\x00"\ + "\x03\x00\x00\x00"\ + "\x01\x00\x00\x00\x00\x00\x00\x00"\ + "\xe8\x03\x00\x00\x00\x00\x00\x00"\ + "\x20" + +#define XML_PREAMBLE \ + "\n"\ + "\n"\ + +#define PREAMBLE \ + XML_PREAMBLE "" + +#define PREAMBLE_DECODED \ + XML_PREAMBLE "" + +#define HEAD_TAG \ + ""\ + "The Research Hunter"\ + ""\ + ""\ + ""\ + ""\ + ""\ + "" + +#define HEAD_TAG_DECODED HEAD_TAG + +#define CLIP_TEMPLATE \ + ""\ + "http://www.csiro.au"\ + ""\ + "Welcome to CSIRO"\ + ""\ + "" + +#define CLIP_TEMPLATE_DECODED \ + ""\ + "http://www.csiro.au"\ + ""\ + "Welcome to CSIRO"\ + ""\ + "" + +#define END_TAG \ + "" + +GList *buffers; +GList *current_buf = NULL; +gint64 granulerate; +guint8 granuleshift; + +GstPad *srcpad, *sinkpad; + +static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (SINK_CAPS) + ); + +static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (SRC_CAPS) + ); + +static GstBuffer * +buffer_new (const gchar * buffer_data, guint size) +{ + GstBuffer *buffer; + GstCaps *caps; + + buffer = gst_buffer_new_and_alloc (size); + memcpy (GST_BUFFER_DATA (buffer), buffer_data, size); + caps = gst_caps_from_string (SRC_CAPS); + gst_buffer_set_caps (buffer, caps); + gst_caps_unref (caps); + + return buffer; +} + +static void +buffer_unref (void *buffer, void *user_data) +{ + ASSERT_OBJECT_REFCOUNT (buffer, "buf", 1); + gst_buffer_unref (GST_BUFFER (buffer)); +} + +GstElement * +setup_cmmldec () +{ + GstElement *cmmldec; + GstBus *bus; + + GST_DEBUG ("setup_cmmldec"); + cmmldec = gst_check_setup_element ("cmmldec"); + srcpad = gst_check_setup_src_pad (cmmldec, &srctemplate, NULL); + sinkpad = gst_check_setup_sink_pad (cmmldec, &sinktemplate, NULL); + + bus = gst_bus_new (); + gst_element_set_bus (cmmldec, bus); + + fail_unless (gst_element_set_state (cmmldec, + GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE, + "could not set to playing"); + + granulerate = GST_SECOND / 1000; + granuleshift = 32; + buffers = NULL; + + return cmmldec; +} + +static void +cleanup_cmmldec (GstElement * cmmldec) +{ + GstBus *bus; + + g_list_foreach (buffers, buffer_unref, NULL); + g_list_free (buffers); + + bus = GST_ELEMENT_BUS (cmmldec); + gst_bus_set_flushing (bus, TRUE); + gst_object_unref (bus); + + GST_DEBUG ("cleanup_cmmldec"); + gst_check_teardown_src_pad (cmmldec); + gst_check_teardown_sink_pad (cmmldec); + gst_check_teardown_element (cmmldec); +} + +static void +check_output_buffer_is_equal (const gchar * name, + const gchar * data, gint refcount) +{ + GstBuffer *buffer = GST_BUFFER (current_buf->data); + + ASSERT_OBJECT_REFCOUNT (buffer, name, refcount); + fail_unless (memcmp (GST_BUFFER_DATA (buffer), data, + GST_BUFFER_SIZE (buffer)) == 0, + "'%s' (%s) is not equal to (%s)", name, GST_BUFFER_DATA (buffer), data); +} + +static void +push_data (const gchar * name, + const gchar * data, gint size, gint64 granulepos, + GstFlowReturn expected_return) +{ + GstBuffer *buffer; + GstFlowReturn res; + + buffer = buffer_new (data, size); + GST_BUFFER_OFFSET_END (buffer) = granulepos; + res = gst_pad_push (srcpad, buffer); + fail_unless (res == expected_return, + "pushing %s returned %d not %d", name, res, expected_return); +} + +static void +check_headers () +{ + /* push the ident header */ + push_data ("ident-header", IDENT_HEADER, 29, 0, GST_FLOW_OK); + /* push the cmml start tag */ + push_data ("preamble", PREAMBLE, strlen (PREAMBLE), 0, GST_FLOW_OK); + /* push the head tag */ + push_data ("head", HEAD_TAG, strlen (HEAD_TAG), 0, GST_FLOW_OK); + + current_buf = buffers; + fail_unless_equals_int (g_list_length (current_buf), 2); + + /* check the preamble */ + check_output_buffer_is_equal ("cmml-preamble-buffer", PREAMBLE_DECODED, 1); + + /* check the decoded head tag */ + current_buf = current_buf->next; + check_output_buffer_is_equal ("head-tag-buffer", HEAD_TAG_DECODED, 1); +} + +static void +push_clip (const gchar * name, const gchar * track, GstClockTime prev, + GstClockTime start, GstClockTime end, GstFlowReturn expected_return) +{ + gchar *clip; + gint64 keyindex, keyoffset, granulepos; + + if (track == NULL) + track = "default"; + + keyindex = prev / granulerate << granuleshift; + keyoffset = (start - prev) / granulerate; + granulepos = keyindex + keyoffset; + + clip = g_strdup_printf (CLIP_TEMPLATE, name, track); + push_data (name, clip, strlen (clip), granulepos, expected_return); + g_free (clip); +} + +static void +check_clip (const gchar * name, const gchar * track, + const gchar * start, const gchar * end) +{ + gchar *decoded_clip; + + if (track == NULL) + track = "default"; + + current_buf = current_buf->next; + fail_unless (g_list_length (current_buf)); + decoded_clip = g_strdup_printf (CLIP_TEMPLATE_DECODED, name, track, start); + check_output_buffer_is_equal (name, decoded_clip, 1); + g_free (decoded_clip); +} + +static void +check_end () +{ + current_buf = current_buf->next; + check_output_buffer_is_equal ("cmml-end-tag", END_TAG, 1); +} + +GST_START_TEST (test_dec) +{ + GstElement *cmmldec; + + cmmldec = setup_cmmldec (); + + check_headers (); + + push_clip ("clip-1", "default", + 0, 1 * GST_SECOND + 234 * GST_MSECOND, 0, GST_FLOW_OK); + push_clip ("clip-2", "othertrack", + 0, 4 * GST_SECOND + 321 * GST_MSECOND, 0, GST_FLOW_OK); + push_clip ("clip-3", "default", + 1 * GST_SECOND + 234 * GST_MSECOND, + ((100 * 3600) + (59 * 60) + 59) * GST_SECOND + 678 * GST_MSECOND, 0, + GST_FLOW_OK); + /* send EOS to flush clip-2 and clip-3 */ + gst_pad_send_event (GST_PAD_PEER (srcpad), gst_event_new_eos ()); + + printf ("Check1\n"); + check_clip ("clip-1", "default", "0:00:01.234", NULL); + printf ("Check2\n"); + check_clip ("clip-2", "othertrack", "0:00:04.321", NULL); + printf ("Check3\n"); + check_clip ("clip-3", "default", "100:59:59.678", NULL); + check_end (); + + cleanup_cmmldec (cmmldec); +} + +GST_END_TEST; + +GST_START_TEST (test_tags) +{ + GstElement *cmmldec; + GstBus *bus; + GstMessage *message; + GstTagList *tags; + const GValue *tag_val; + GObject *tag; + gchar *title, *base; + gboolean empty; + gchar *id, *track; + gint64 start_time, end_time; + gchar *anchor_href, *anchor_text; + gchar *img_src, *img_alt; + gchar *desc; + GValueArray *meta; + + cmmldec = setup_cmmldec (); + bus = gst_element_get_bus (cmmldec); + + check_headers (); + + /* read the GstCmmlTagHead tag */ + message = gst_bus_poll (bus, GST_MESSAGE_TAG, -1); + fail_unless (message != NULL); + + gst_message_parse_tag (message, &tags); + fail_unless (tags != NULL); + + tag_val = gst_tag_list_get_value_index (tags, GST_TAG_CMML_HEAD, 0); + fail_unless (tag_val != NULL); + + tag = g_value_get_object (tag_val); + fail_unless (tags != NULL); + + g_object_get (tag, "title", &title, "base-uri", &base, "meta", &meta, NULL); + fail_unless_equals_string ("The Research Hunter", title); + fail_unless (base == NULL); + fail_unless (meta != NULL); + fail_unless_equals_int (meta->n_values, 10); + + gst_message_unref (message); + gst_tag_list_free (tags); + g_free (title); + g_free (base); + g_value_array_free (meta); + + push_clip ("clip-1", "default", + 0, 1 * GST_SECOND + 234 * GST_MSECOND, 0, GST_FLOW_OK); + + /* read the GstCmmlTagClip */ + message = gst_bus_poll (bus, GST_MESSAGE_TAG, -1); + fail_unless (message != NULL); + + gst_message_parse_tag (message, &tags); + fail_unless (tags != NULL); + + tag_val = gst_tag_list_get_value_index (tags, GST_TAG_CMML_CLIP, 0); + fail_unless (tag_val != NULL); + + tag = g_value_get_object (tag_val); + fail_unless (tag != NULL); + + g_object_get (tag, "id", &id, "empty", &empty, "track", &track, + "start-time", &start_time, "end-time", &end_time, + "anchor-uri", &anchor_href, "anchor-text", &anchor_text, + "img-uri", &img_src, "img-alt", &img_alt, + "description", &desc, "meta", &meta, NULL); + + fail_unless (empty == FALSE); + fail_unless_equals_string (id, "clip-1"); + fail_unless_equals_string (track, "default"); + fail_unless_equals_int (start_time, 1 * GST_SECOND + 234 * GST_MSECOND); + fail_unless_equals_uint64 (end_time, GST_CLOCK_TIME_NONE); + fail_unless_equals_string (anchor_href, "http://www.csiro.au/"); + fail_unless_equals_string (anchor_text, "http://www.csiro.au"); + fail_unless_equals_string (img_src, "images/index1.jpg"); + fail_unless (img_alt == NULL); + fail_unless_equals_string (desc, "Welcome to CSIRO"); + fail_unless (meta != NULL); + fail_unless_equals_int (meta->n_values, 2); + + g_free (id); + g_free (track); + g_free (anchor_href); + g_free (anchor_text); + g_free (img_src); + g_free (img_alt); + g_free (desc); + g_value_array_free (meta); + gst_tag_list_free (tags); + gst_message_unref (message); + gst_object_unref (bus); + cleanup_cmmldec (cmmldec); +} + +GST_END_TEST; + +Suite * +cmmldec_suite () +{ + Suite *s = suite_create ("cmmldec"); + TCase *tc_chain = tcase_create ("general"); + + suite_add_tcase (s, tc_chain); + tcase_add_test (tc_chain, test_dec); + tcase_add_test (tc_chain, test_tags); + + return s; +} + +int +main (int argc, char **argv) +{ + int nf; + + Suite *s = cmmldec_suite (); + SRunner *sr = srunner_create (s); + + gst_check_init (&argc, &argv); + + srunner_run_all (sr, CK_NORMAL); + nf = srunner_ntests_failed (sr); + srunner_free (sr); + + return nf; +} diff --git a/tests/check/elements/cmmlenc.c b/tests/check/elements/cmmlenc.c new file mode 100644 index 0000000..da01984 --- /dev/null +++ b/tests/check/elements/cmmlenc.c @@ -0,0 +1,361 @@ +/* + * cmmlenc.c - GStreamer CMML decoder test suite + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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. + */ + +#include + +#define SINK_CAPS "text/x-cmml" +#define SRC_CAPS "text/xml" + +#define IDENT_HEADER \ + "CMML\x00\x00\x00\x00"\ + "\x03\x00\x00\x00"\ + "\x01\x00\x00\x00\x00\x00\x00\x00"\ + "\xe8\x03\x00\x00\x00\x00\x00\x00"\ + "\x20" + +#define XML_PREAMBLE \ + "\n"\ + "\n" + +#define START_TAG \ + "" + +#define PROCESSING_INSTRUCTION \ + "" + +#define PREAMBLE \ + XML_PREAMBLE START_TAG + +#define PREAMBLE_ENCODED \ + XML_PREAMBLE PROCESSING_INSTRUCTION + +#define STREAM_TAG \ + ""\ + ""\ + ""\ + "" + +#define STREAM_TAG_ENCODED STREAM_TAG + +#define HEAD_TAG \ + ""\ + "The Research Hunter"\ + ""\ + ""\ + ""\ + ""\ + ""\ + "" + +#define HEAD_TAG_ENCODED HEAD_TAG + +#define END_TAG \ + "" + +#define CLIP_TEMPLATE \ + ""\ + "http://www.annodex.org"\ + ""\ + "Annodex Foundation"\ + ""\ + "" + +#define CLIP_TEMPLATE_ENCODED \ + ""\ + "http://www.annodex.org"\ + ""\ + "Annodex Foundation"\ + ""\ + "" + +GList *buffers; +GList *current_buf = NULL; +guint64 granulerate; +guint8 granuleshift; + +GstPad *srcpad, *sinkpad; + +static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (SINK_CAPS) + ); + +static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (SRC_CAPS) + ); + +GstBuffer * +buffer_new (const gchar * buffer_data, guint size) +{ + GstBuffer *buffer; + GstCaps *caps; + + buffer = gst_buffer_new_and_alloc (size); + memcpy (GST_BUFFER_DATA (buffer), buffer_data, size); + caps = gst_caps_from_string (SRC_CAPS); + gst_buffer_set_caps (buffer, caps); + gst_caps_unref (caps); + + return buffer; +} + +static void +buffer_unref (void *buffer, void *user_data) +{ + gst_buffer_unref (GST_BUFFER (buffer)); +} + +GstElement * +setup_cmmlenc () +{ + GstElement *cmmlenc; + GstBus *bus; + guint64 granulerate_n, granulerate_d; + + GST_DEBUG ("setup_cmmlenc"); + + cmmlenc = gst_check_setup_element ("cmmlenc"); + srcpad = gst_check_setup_src_pad (cmmlenc, &srctemplate, NULL); + sinkpad = gst_check_setup_sink_pad (cmmlenc, &sinktemplate, NULL); + + bus = gst_bus_new (); + gst_element_set_bus (cmmlenc, bus); + + fail_unless (gst_element_set_state (cmmlenc, + GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE, + "could not set to playing"); + + g_object_get (cmmlenc, "granule-rate-numerator", &granulerate_n, + "granule-rate-denominator", &granulerate_d, + "granule-shift", &granuleshift, NULL); + + granulerate = GST_SECOND * granulerate_n / granulerate_d; + buffers = NULL; + return cmmlenc; +} + +static void +cleanup_cmmlenc (GstElement * cmmlenc) +{ + GstBus *bus; + + /* free encoded buffers */ + g_list_foreach (buffers, buffer_unref, NULL); + g_list_free (buffers); + buffers = NULL; + + bus = GST_ELEMENT_BUS (cmmlenc); + gst_bus_set_flushing (bus, TRUE); + gst_object_unref (bus); + + GST_DEBUG ("cleanup_cmmlenc"); + gst_check_teardown_src_pad (cmmlenc); + gst_check_teardown_sink_pad (cmmlenc); + gst_check_teardown_element (cmmlenc); +} + +static void +check_output_buffer_is_equal (const gchar * name, + const gchar * data, gint refcount) +{ + GstBuffer *buffer = GST_BUFFER (current_buf->data); + + ASSERT_OBJECT_REFCOUNT (buffer, name, refcount); + fail_unless (memcmp (GST_BUFFER_DATA (buffer), data, + GST_BUFFER_SIZE (buffer)) == 0, + "'%s' (%s) is not equal to (%s)", name, GST_BUFFER_DATA (buffer), data); +} + +static void +push_data (const gchar * name, + const gchar * data, gint size, GstFlowReturn expected_return) +{ + GstBuffer *buffer; + GstFlowReturn res; + + buffer = buffer_new (data, size); + res = gst_pad_push (srcpad, buffer); + fail_unless (res == expected_return, + "pushing %s returned %d not %d", name, res, expected_return); +} + +static void +check_headers () +{ + /* push the cmml start tag */ + push_data ("preamble", PREAMBLE, strlen (PREAMBLE), GST_FLOW_OK); + /* push the stream tag */ + push_data ("stream", STREAM_TAG, strlen (STREAM_TAG), GST_FLOW_OK); + /* push the head tag */ + push_data ("head", HEAD_TAG, strlen (HEAD_TAG), GST_FLOW_OK); + + /* should output the cmml ident header and the cmml start tag transformed + * into a processing instruction */ + current_buf = buffers; + fail_unless_equals_int (g_list_length (current_buf), 3); + + /* check the ident header */ + check_output_buffer_is_equal ("cmml-ident-buffer", IDENT_HEADER, 2); + + /* check the cmml processing instruction */ + current_buf = current_buf->next; + check_output_buffer_is_equal ("cmml-preamble-buffer", PREAMBLE_ENCODED, 2); + + /* check the encoded head tag */ + current_buf = current_buf->next; + check_output_buffer_is_equal ("head-tag-buffer", HEAD_TAG_ENCODED, 2); +} + +static void +push_clip (const gchar * name, const gchar * track, + const gchar * start, const gchar * end, GstFlowReturn expected_return) +{ + gchar *clip; + + if (track == NULL) + track = "default"; + + clip = g_strdup_printf (CLIP_TEMPLATE, name, track, start, end); + push_data (name, clip, strlen (clip), expected_return); + g_free (clip); +} + +static void +check_clip (const gchar * name, const gchar * track, + GstClockTime start, GstClockTime prev) +{ + gchar *encoded_clip; + GstBuffer *buffer; + gint64 keyindex, keyoffset, granulepos; + + if (track == NULL) + track = "default"; + + current_buf = current_buf->next; + fail_unless (g_list_length (current_buf)); + encoded_clip = g_strdup_printf (CLIP_TEMPLATE_ENCODED, name, track); + check_output_buffer_is_equal (name, encoded_clip, 1); + g_free (encoded_clip); + buffer = GST_BUFFER (current_buf->data); + granulepos = GST_BUFFER_OFFSET_END (GST_BUFFER (buffer)); + keyindex = granulepos >> granuleshift; + keyoffset = granulepos - (keyindex << granuleshift); + fail_unless_equals_uint64 (keyindex * granulerate, prev); + fail_unless_equals_uint64 ((keyindex + keyoffset) * granulerate, start); +} + +static void +push_end () +{ + push_data ("end", END_TAG, strlen (END_TAG), GST_FLOW_OK); +} + +static void +check_end () +{ + /* should output the EOS page */ + current_buf = current_buf->next; + fail_unless_equals_int (g_list_length (current_buf), 1); + check_output_buffer_is_equal ("cmml-eos-buffer", NULL, 1); +} + +GST_START_TEST (test_enc) +{ + GstElement *cmmlenc; + + cmmlenc = setup_cmmlenc (); + + check_headers (); + + push_clip ("clip-1", "default", "1.234", NULL, GST_FLOW_OK); + check_clip ("clip-1", "default", 1234 * granulerate, 0); + + push_clip ("clip-2", NULL, "5.678", NULL, GST_FLOW_OK); + check_clip ("clip-2", "default", 5678 * granulerate, 1234 * granulerate); + + push_clip ("clip-3", "othertrack", "9.123", NULL, GST_FLOW_OK); + check_clip ("clip-3", "othertrack", 9123 * granulerate, 0); + + push_end (); + check_end (); + + cleanup_cmmlenc (cmmlenc); +} + +GST_END_TEST; + +GST_START_TEST (test_bad_start_time) +{ + GstElement *cmmlenc; + + cmmlenc = setup_cmmlenc (); + + check_headers (); + + push_clip ("clip-1", "default", "1.234", NULL, GST_FLOW_OK); + check_clip ("clip-1", "default", 1234 * granulerate, 0); + + push_clip ("clip-bad", "default", "1.1000", NULL, GST_FLOW_ERROR); + + push_clip ("clip-2", NULL, "5.678", NULL, GST_FLOW_OK); + check_clip ("clip-2", "default", 5678 * granulerate, 1234 * granulerate); + + push_clip ("clip-3", "othertrack", "9.123", NULL, GST_FLOW_OK); + check_clip ("clip-3", "othertrack", 9123 * granulerate, 0); + + push_end (); + check_end (); + + cleanup_cmmlenc (cmmlenc); +} +GST_END_TEST static Suite * +cmmlenc_suite () +{ + Suite *s = suite_create ("cmmlenc"); + TCase *tc_chain = tcase_create ("general"); + + suite_add_tcase (s, tc_chain); + tcase_add_test (tc_chain, test_enc); + tcase_add_test (tc_chain, test_bad_start_time); + return s; +} + +int +main (int argc, char **argv) +{ + int nf; + + Suite *s = cmmlenc_suite (); + SRunner *sr = srunner_create (s); + + gst_check_init (&argc, &argv); + + srunner_run_all (sr, CK_NORMAL); + nf = srunner_ntests_failed (sr); + srunner_free (sr); + + return nf; +} diff --git a/tests/check/elements/skeldec.c b/tests/check/elements/skeldec.c new file mode 100644 index 0000000..04d6dd3 --- /dev/null +++ b/tests/check/elements/skeldec.c @@ -0,0 +1,258 @@ +/* + * skeldec.c - GStreamer annodex skeleton decoder test suite + * Copyright (C) 2005 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * 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. + */ + +#include + +GList *buffers; + +GstPad *srcpad, *sinkpad; + +#define SKELETON_CAPS "application/x-ogg-skeleton" + +#define SKELETON_FISHEAD \ + "fishead\0"\ + "\x03\0\0\0"\ + "\x39\x30\0\0\0\0\0\0"\ + "\x39\x30\0\0\0\0\0\0"\ + "\x39\x30\0\0\0\0\0\0"\ + "\x39\x30\0\0\0\0\0\0"\ + "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + +#define SKELETON_FISHEAD_SIZE 64 + +#define SKELETON_FISBONE \ + "fisbone\0"\ + "\x2c\0\0\0"\ + "\x39\x30\0\0"\ + "\x39\x30\0\0"\ + "\x39\x30\0\0\0\0\0\0"\ + "\x39\x30\0\0\0\0\0\0"\ + "\x39\x30\0\0\0\0\0\0"\ + "\x39\x30\0\0"\ + "\x20"\ + "\0\0\0"\ + "Content-Type: application/ogg; UTF-8\r\n" + +#define SKELETON_FISBONE_SIZE 90 + +static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS_ANY); + +static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (SKELETON_CAPS) + ); + +static GstElement * +setup_skeldec () +{ + GstElement *skeldec; + + GST_DEBUG ("setup_skeldec"); + skeldec = gst_check_setup_element ("skeldec"); + srcpad = gst_check_setup_src_pad (skeldec, &srctemplate, NULL); + sinkpad = gst_check_setup_sink_pad (skeldec, &sinktemplate, NULL); + + return skeldec; +} + +static void +cleanup_skeldec (GstElement * skeldec) +{ + GST_DEBUG ("cleanup_skeldec"); + + gst_check_teardown_src_pad (skeldec); + gst_check_teardown_sink_pad (skeldec); + gst_check_teardown_element (skeldec); +} + +static void +skel_buffer_unref (void *buf, void *user_data) +{ + GstBuffer *buffer = GST_BUFFER (buf); + + ASSERT_OBJECT_REFCOUNT (buffer, "skel-buffer", 1); + gst_buffer_unref (buffer); +} + +static GstBuffer * +skel_buffer_new (gchar * buffer_data, guint size) +{ + GstBuffer *buffer; + GstCaps *caps; + + buffer = gst_buffer_new_and_alloc (size); + memcpy (GST_BUFFER_DATA (buffer), buffer_data, size); + caps = gst_caps_from_string (SKELETON_CAPS); + gst_buffer_set_caps (buffer, caps); + gst_caps_unref (caps); + + return buffer; +} + +GST_START_TEST (test_dec) +{ + GstElement *skeldec; + GstBus *bus; + GstBuffer *inbuffer; + GstMessage *message; + GstTagList *tags; + const GValue *tag_val, *val; + GObject *tag; + gint major, minor; + gint64 prestime_n, prestime_d; + gint64 basetime_n, basetime_d; + guint serial_number; + gint64 granule_rate_n, granule_rate_d; + gint64 granule_start; + guint64 preroll; + guint granule_shift; + GValueArray *headers; + gchar *content_type; + gchar *encoding; + + skeldec = setup_skeldec (); + + bus = gst_bus_new (); + gst_element_set_bus (skeldec, bus); + + fail_unless (gst_element_set_state (skeldec, + GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS, + "could not set to playing"); + + /* test the fishead */ + inbuffer = skel_buffer_new (SKELETON_FISHEAD, SKELETON_FISHEAD_SIZE); + fail_unless_equals_int (gst_pad_push (srcpad, inbuffer), GST_FLOW_OK); + + message = gst_bus_poll (bus, GST_MESSAGE_TAG, -1); + fail_unless (GST_MESSAGE_SRC (message) == GST_OBJECT (skeldec)); + + gst_message_parse_tag (message, &tags); + fail_unless (tags != NULL); + fail_unless_equals_int (gst_tag_list_get_tag_size (tags, + GST_TAG_SKELETON_FISHEAD), 1); + + tag_val = gst_tag_list_get_value_index (tags, GST_TAG_SKELETON_FISHEAD, 0); + fail_unless (tag_val != NULL); + + tag = g_value_get_object (tag_val); + fail_unless (tag != NULL); + + g_object_get (tag, + "version-major", &major, "version-minor", &minor, + "presentation-time-numerator", &prestime_n, + "presentation-time-denominator", &prestime_d, + "base-time-numerator", &basetime_n, + "base-time-denominator", &basetime_d, NULL); + + fail_unless_equals_int (major, 3); + fail_unless_equals_int (minor, 0); + fail_unless_equals_int (prestime_n, 12345); + fail_unless_equals_int (prestime_d, 12345); + fail_unless_equals_int (basetime_n, 12345); + fail_unless_equals_int (basetime_d, 12345); + + gst_tag_list_free (tags); + gst_message_unref (message); + + /* test the fisbone */ + inbuffer = skel_buffer_new (SKELETON_FISBONE, SKELETON_FISBONE_SIZE); + fail_unless_equals_int (gst_pad_push (srcpad, inbuffer), GST_FLOW_OK); + + message = gst_bus_poll (bus, GST_MESSAGE_TAG, -1); + fail_unless (GST_MESSAGE_SRC (message) == GST_OBJECT (skeldec)); + + gst_message_parse_tag (message, &tags); + fail_unless (tags != NULL); + fail_unless_equals_int (gst_tag_list_get_tag_size (tags, + GST_TAG_SKELETON_FISBONE), 1); + + tag_val = gst_tag_list_get_value_index (tags, GST_TAG_SKELETON_FISBONE, 0); + fail_unless (tag_val != NULL); + + tag = g_value_get_object (tag_val); + fail_unless (tag != NULL); + + g_object_get (tag, "serial-number", &serial_number, + "granule-rate-numerator", &granule_rate_n, + "granule-rate-denominator", &granule_rate_d, + "granule-start", &granule_start, + "granule-shift", &granule_shift, + "preroll", &preroll, + "headers", &headers, + "content-type", &content_type, "encoding", &encoding, NULL); + + fail_unless_equals_int (serial_number, 12345); + fail_unless_equals_int (granule_rate_n, 12345); + fail_unless_equals_int (granule_rate_d, 12345); + fail_unless_equals_int (granule_start, 12345); + fail_unless_equals_int (preroll, 12345); + fail_unless_equals_int (granule_shift, 32); + fail_unless_equals_int (headers->n_values, 2); + fail_unless_equals_string (content_type, "application/ogg"); + fail_unless_equals_string (encoding, "UTF-8"); + + g_value_array_free (headers); + g_free (content_type); + g_free (encoding); + gst_tag_list_free (tags); + gst_message_unref (message); + gst_bus_set_flushing (bus, TRUE); + gst_object_unref (bus); + g_list_foreach (buffers, skel_buffer_unref, NULL); + cleanup_skeldec (skeldec); +} + +GST_END_TEST; + +static Suite * +skeldec_suite () +{ + Suite *s = suite_create ("skeldec"); + TCase *tc_chain = tcase_create ("general"); + + suite_add_tcase (s, tc_chain); + tcase_add_test (tc_chain, test_dec); + + return s; +} + +int +main (int argc, char **argv) +{ + int nf; + + Suite *s = skeldec_suite (); + SRunner *sr = srunner_create (s); + + gst_check_init (&argc, &argv); + + srunner_run_all (sr, CK_NORMAL); + nf = srunner_ntests_failed (sr); + srunner_free (sr); + + return nf; +} -- 2.7.4