From 93f27006cfa693626e10fa4aacb036f1ade85a77 Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Sat, 18 Jan 2003 18:09:47 +0000 Subject: [PATCH] Added first unusable code that should become the base element for a new aviparser Original commit message from CVS: Added first unusable code that should become the base element for a new aviparser --- gst/avi/Makefile.am | 8 +- gst/avi/gstaviparse.c | 337 +++++++++++++++++++++++++++++++++++++++++++++++ gst/avi/riff.c | 115 ++++++++++++++++ gst/avi/riff.h | 356 ++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 815 insertions(+), 1 deletion(-) create mode 100644 gst/avi/gstaviparse.c create mode 100644 gst/avi/riff.c create mode 100644 gst/avi/riff.h diff --git a/gst/avi/Makefile.am b/gst/avi/Makefile.am index 7a9d68d..9d95c71 100644 --- a/gst/avi/Makefile.am +++ b/gst/avi/Makefile.am @@ -2,11 +2,13 @@ plugindir = $(libdir)/gstreamer-@GST_MAJORMINOR@ plugin_LTLIBRARIES = \ libgstavimux.la \ - libgstavidemux.la + libgstavidemux.la \ + libgstaviparse.la # libgstaviaudiodecoder.la libgstavidemux_la_SOURCES = gstavidemux.c libgstavimux_la_SOURCES = gstavimux.c +libgstaviparse_la_SOURCES = gstaviparse.c riff.c # libgstaviaudiodecoder_la_SOURCES = gstaviaudiodecoder.c noinst_HEADERS = \ @@ -24,6 +26,10 @@ libgstavimux_la_CFLAGS = -O2 -ffast-math $(GST_CFLAGS) libgstavimux_la_LIBADD = libgstavimux_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) +libgstaviparse_la_CFLAGS = -O2 -ffast-math $(GST_CFLAGS) +libgstaviparse_la_LIBADD = +libgstaviparse_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) + # libgstaviaudiodecoder_la_CFLAGS = -O2 -ffast-math $(GST_CFLAGS) # libgstaviaudiodecoder_la_LIBADD = # libgstaviaudiodecoder_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) diff --git a/gst/avi/gstaviparse.c b/gst/avi/gstaviparse.c new file mode 100644 index 0000000..f4c35f7 --- /dev/null +++ b/gst/avi/gstaviparse.c @@ -0,0 +1,337 @@ +/* GStreamer + * Copyright (C) <1999> Erik Walthinsen + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + + +/* #define GST_DEBUG_ENABLED */ +#include +#include +#include +#include + +#include "riff.h" + +#define GST_TYPE_AVI_PARSE \ + (gst_avi_parse_get_type()) +#define GST_AVI_PARSE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AVI_PARSE,GstAviParse)) +#define GST_AVI_PARSE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AVI_PARSE,GstAviParse)) +#define GST_IS_AVI_PARSE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AVI_PARSE)) +#define GST_IS_AVI_PARSE_CLASS(obj) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AVI_PARSE)) + +typedef struct _GstAviParse GstAviParse; +typedef struct _GstAviParseClass GstAviParseClass; + +struct _GstAviParse { + GstElement element; + + /* pads */ + GstPad *sinkpad, + *srcpad; + + GstRiffParse *rp; +}; + +struct _GstAviParseClass { + GstElementClass parent_class; +}; + +/* elementfactory information */ +static GstElementDetails gst_avi_parse_details = { + "Avi parseer", + "Codec/Parseer", + "LGPL", + "Demultiplex an avi file into audio and video", + VERSION, + "Wim Taymans ", + "(C) 2003", +}; + +static GstCaps* avi_type_find (GstBuffer *buf, gpointer private); + +/* typefactory for 'avi' */ +static GstTypeDefinition avidefinition = { + "aviparse_video/avi", + "video/avi", + ".avi", + avi_type_find, +}; + +/* AviParse signals and args */ +enum { + /* FILL ME */ + LAST_SIGNAL +}; + +enum { + ARG_0, + ARG_BITRATE, + /* FILL ME */ +}; + +GST_PAD_TEMPLATE_FACTORY (sink_templ, + "sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_CAPS_NEW ( + "aviparse_sink", + "video/avi", + "format", GST_PROPS_STRING ("AVI") + ) +) + +GST_PAD_TEMPLATE_FACTORY (src_templ, + "src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_CAPS_NEW ( + "aviparse_sink", + "video/avi", + "format", GST_PROPS_STRING ("AVI") + ) +) + +static void gst_avi_parse_class_init (GstAviParseClass *klass); +static void gst_avi_parse_init (GstAviParse *avi_parse); + +static void gst_avi_parse_loop (GstElement *element); + +static GstElementStateReturn + gst_avi_parse_change_state (GstElement *element); + +static void gst_avi_parse_get_property (GObject *object, guint prop_id, + GValue *value, GParamSpec *pspec); + + +static GstElementClass *parent_class = NULL; +/*static guint gst_avi_parse_signals[LAST_SIGNAL] = { 0 }; */ + +GType +gst_avi_parse_get_type(void) +{ + static GType avi_parse_type = 0; + + if (!avi_parse_type) { + static const GTypeInfo avi_parse_info = { + sizeof(GstAviParseClass), + NULL, + NULL, + (GClassInitFunc)gst_avi_parse_class_init, + NULL, + NULL, + sizeof(GstAviParse), + 0, + (GInstanceInitFunc)gst_avi_parse_init, + }; + avi_parse_type = g_type_register_static(GST_TYPE_ELEMENT, "GstAviParse", &avi_parse_info, 0); + } + return avi_parse_type; +} + +static void +gst_avi_parse_class_init (GstAviParseClass *klass) +{ + GObjectClass *gobject_class; + GstElementClass *gstelement_class; + + gobject_class = (GObjectClass*)klass; + gstelement_class = (GstElementClass*)klass; + + g_object_class_install_property (G_OBJECT_CLASS(klass), ARG_BITRATE, + g_param_spec_long ("bitrate","bitrate","bitrate", + G_MINLONG, G_MAXLONG, 0, G_PARAM_READABLE)); /* CHECKME */ + + parent_class = g_type_class_ref (GST_TYPE_ELEMENT); + + gobject_class->get_property = gst_avi_parse_get_property; + + gstelement_class->change_state = gst_avi_parse_change_state; +} + +static void +gst_avi_parse_init (GstAviParse *avi_parse) +{ + GST_FLAG_SET (avi_parse, GST_ELEMENT_EVENT_AWARE); + + avi_parse->sinkpad = gst_pad_new_from_template ( + GST_PAD_TEMPLATE_GET (sink_templ), "sink"); + gst_element_add_pad (GST_ELEMENT (avi_parse), avi_parse->sinkpad); + + avi_parse->srcpad = gst_pad_new_from_template ( + GST_PAD_TEMPLATE_GET (src_templ), "src"); + gst_element_add_pad (GST_ELEMENT (avi_parse), avi_parse->srcpad); + + gst_element_set_loop_function (GST_ELEMENT (avi_parse), gst_avi_parse_loop); +} + +static GstCaps* +avi_type_find (GstBuffer *buf, + gpointer private) +{ + gchar *data = GST_BUFFER_DATA (buf); + GstCaps *new; + + GST_DEBUG (0,"avi_parse: typefind"); + + if (GUINT32_FROM_LE (((guint32 *)data)[0]) != GST_RIFF_TAG_RIFF) + return NULL; + if (GUINT32_FROM_LE (((guint32 *)data)[2]) != GST_RIFF_RIFF_AVI) + return NULL; + + new = GST_CAPS_NEW ("avi_type_find", + "video/avi", + "format", GST_PROPS_STRING ("AVI")); + return new; +} + +static void +gst_avi_parse_loop (GstElement *element) +{ + GstAviParse *avi_parse; + GstRiffParse *rp; + GstBuffer *buf; + guint32 id; + GstRiffReturn res; + + g_return_if_fail (element != NULL); + g_return_if_fail (GST_IS_AVI_PARSE (element)); + + avi_parse = GST_AVI_PARSE (element); + + rp = avi_parse->rp; + + res = gst_riff_parse_next_chunk (rp, &id, &buf); + if (res == GST_RIFF_EOS) { + gst_element_set_eos (element); + return; + } + + switch (id) { + case GST_RIFF_TAG_RIFF: + case GST_RIFF_TAG_LIST: + { + gst_riff_list *list; + + list = (gst_riff_list *) GST_BUFFER_DATA (buf); + + g_print ("%4.4s %08x %4.4s\n", (gchar *)&list->id, list->size, (gchar *)&list->type); + break; + } + default: + { + gst_riff_chunk *chunk; + + chunk = (gst_riff_chunk *) GST_BUFFER_DATA (buf); + + g_print ("%4.4s %08x\n", (gchar *)&chunk->id, chunk->size); + break; + } + } + + if (GST_PAD_IS_USABLE (avi_parse->srcpad)) { + gst_pad_push (avi_parse->srcpad, buf); + } + else { + gst_buffer_unref (buf); + } +} + +static GstElementStateReturn +gst_avi_parse_change_state (GstElement *element) +{ + GstAviParse *avi_parse = GST_AVI_PARSE (element); + + switch (GST_STATE_TRANSITION (element)) { + case GST_STATE_NULL_TO_READY: + break; + case GST_STATE_READY_TO_PAUSED: + avi_parse->rp = gst_riff_parse_new (avi_parse->sinkpad); + break; + case GST_STATE_PAUSED_TO_PLAYING: + break; + case GST_STATE_PLAYING_TO_PAUSED: + break; + case GST_STATE_PAUSED_TO_READY: + gst_riff_parse_free (avi_parse->rp); + break; + case GST_STATE_READY_TO_NULL: + break; + default: + break; + } + + parent_class->change_state (element); + + return GST_STATE_SUCCESS; +} + +static void +gst_avi_parse_get_property (GObject *object, guint prop_id, GValue *value, + GParamSpec *pspec) +{ + GstAviParse *src; + + g_return_if_fail (GST_IS_AVI_PARSE (object)); + + src = GST_AVI_PARSE (object); + + switch (prop_id) { + case ARG_BITRATE: + break; + default: + break; + } +} + +static gboolean +plugin_init (GModule *module, GstPlugin *plugin) +{ + GstElementFactory *factory; + GstTypeFactory *type; + + /* this filter needs the riff parser */ + if (!gst_library_load ("gstbytestream")) + return FALSE; + + /* create an elementfactory for the avi_parse element */ + factory = gst_element_factory_new ("aviparse", GST_TYPE_AVI_PARSE, + &gst_avi_parse_details); + g_return_val_if_fail (factory != NULL, FALSE); + gst_element_factory_set_rank (factory, GST_ELEMENT_RANK_PRIMARY); + + gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (src_templ)); + gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (sink_templ)); + + type = gst_type_factory_new (&avidefinition); + gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type)); + + gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory)); + + return TRUE; +} + +GstPluginDesc plugin_desc = { + GST_VERSION_MAJOR, + GST_VERSION_MINOR, + "aviparse", + plugin_init +}; + diff --git a/gst/avi/riff.c b/gst/avi/riff.c new file mode 100644 index 0000000..5138b8d --- /dev/null +++ b/gst/avi/riff.c @@ -0,0 +1,115 @@ +/* GStreamer + * Copyright (C) <1999> Erik Walthinsen + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include "riff.h" + +GstRiffParse* +gst_riff_parse_new (GstPad *pad) +{ + GstRiffParse *parse; + + parse = g_new0 (GstRiffParse, 1); + parse->pad = pad; + parse->bs = gst_bytestream_new (pad); + + return parse; +} + +void +gst_riff_parse_free (GstRiffParse *parse) +{ + gst_bytestream_destroy (parse->bs); + g_free (parse); +} + + +static GstRiffReturn +gst_riff_parse_handle_sink_event (GstRiffParse *parse) +{ + guint32 remaining; + GstEvent *event; + GstEventType type; + GstRiffReturn ret = GST_RIFF_OK; + + gst_bytestream_get_status (parse->bs, &remaining, &event); + + type = event? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN; + + switch (type) { + case GST_EVENT_EOS: + ret = GST_RIFF_EOS; + break; + default: + g_warning ("unhandled event %d", type); + break; + } + + gst_event_unref (event); + + return ret; +} + +GstRiffReturn +gst_riff_parse_next_chunk (GstRiffParse *parse, guint32 *id, GstBuffer **buf) +{ + GstByteStream *bs; + guint32 got_bytes; + gint skipsize; + gst_riff_chunk *chunk; + + bs = parse->bs; + + do { + got_bytes = gst_bytestream_peek_bytes (bs, (guint8 **) &chunk, sizeof (gst_riff_chunk)); + if (got_bytes < sizeof (gst_riff_chunk)) { + GstRiffReturn ret; + + ret = gst_riff_parse_handle_sink_event (parse); + + if (ret == GST_RIFF_EOS) + return ret; + } + } while (got_bytes != sizeof (gst_riff_chunk)); + + *id = chunk->id; + + switch (chunk->id) { + case GST_RIFF_TAG_RIFF: + case GST_RIFF_TAG_LIST: + skipsize = sizeof (gst_riff_list); + break; + default: + skipsize = (chunk->size + 8 + 1) & ~1; + break; + } + + do { + got_bytes = gst_bytestream_read (bs, buf, skipsize); + if (got_bytes < skipsize) { + GstRiffReturn ret; + + ret = gst_riff_parse_handle_sink_event (parse); + + if (ret == GST_RIFF_EOS) + return ret; + } + } while (got_bytes != skipsize); + + return GST_RIFF_OK; +} diff --git a/gst/avi/riff.h b/gst/avi/riff.h new file mode 100644 index 0000000..f78e72c --- /dev/null +++ b/gst/avi/riff.h @@ -0,0 +1,356 @@ +/* GStreamer + * Copyright (C) <1999> Erik Walthinsen + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __GST_RIFF_PARSE_H__ +#define __GST_RIFF_PARSE_H__ + +#include +#include + +typedef enum { + GST_RIFF_OK = 0, + GST_RIFF_EOS = -1, + GST_RIFF_ERROR = -2, + GST_RIFF_EINVAL = -3, +} GstRiffReturn; + +#define MAKE_FOUR_CC(a,b,c,d) ( ((guint32)a) | (((guint32)b)<< 8) | \ + ((guint32)c)<<16 | (((guint32)d)<<24) ) + +/* RIFF types */ +#define GST_RIFF_RIFF_WAVE MAKE_FOUR_CC('W','A','V','E') +#define GST_RIFF_RIFF_AVI MAKE_FOUR_CC('A','V','I',' ') + +/* tags */ +#define GST_RIFF_TAG_RIFF MAKE_FOUR_CC('R','I','F','F') +#define GST_RIFF_TAG_RIFX MAKE_FOUR_CC('R','I','F','X') +#define GST_RIFF_TAG_LIST MAKE_FOUR_CC('L','I','S','T') +#define GST_RIFF_TAG_avih MAKE_FOUR_CC('a','v','i','h') +#define GST_RIFF_TAG_strd MAKE_FOUR_CC('s','t','r','d') +#define GST_RIFF_TAG_strh MAKE_FOUR_CC('s','t','r','h') +#define GST_RIFF_TAG_strf MAKE_FOUR_CC('s','t','r','f') +#define GST_RIFF_TAG_vedt MAKE_FOUR_CC('v','e','d','t') +#define GST_RIFF_TAG_JUNK MAKE_FOUR_CC('J','U','N','K') +#define GST_RIFF_TAG_idx1 MAKE_FOUR_CC('i','d','x','1') +/* WAV stuff */ +#define GST_RIFF_TAG_fmt MAKE_FOUR_CC('f','m','t',' ') +#define GST_RIFF_TAG_data MAKE_FOUR_CC('d','a','t','a') + +/* LIST types */ +#define GST_RIFF_LIST_movi MAKE_FOUR_CC('m','o','v','i') +#define GST_RIFF_LIST_hdrl MAKE_FOUR_CC('h','d','r','l') +#define GST_RIFF_LIST_strl MAKE_FOUR_CC('s','t','r','l') + +/* fcc types */ +#define GST_RIFF_FCC_vids MAKE_FOUR_CC('v','i','d','s') +#define GST_RIFF_FCC_auds MAKE_FOUR_CC('a','u','d','s') +#define GST_RIFF_FCC_pads MAKE_FOUR_CC('p','a','d','s') +#define GST_RIFF_FCC_txts MAKE_FOUR_CC('t','x','t','s') +#define GST_RIFF_FCC_vidc MAKE_FOUR_CC('v','i','d','c') +#define GST_RIFF_FCC_iavs MAKE_FOUR_CC('i','a','v','s') +/* fcc handlers */ +#define GST_RIFF_FCCH_RLE MAKE_FOUR_CC('R','L','E',' ') +#define GST_RIFF_FCCH_msvc MAKE_FOUR_CC('m','s','v','c') +#define GST_RIFF_FCCH_MSVC MAKE_FOUR_CC('M','S','V','C') + +/*********Chunk Names***************/ +#define GST_RIFF_FF00 MAKE_FOUR_CC(0xFF,0xFF,0x00,0x00) +#define GST_RIFF_00 MAKE_FOUR_CC( '0', '0',0x00,0x00) +#define GST_RIFF_01 MAKE_FOUR_CC( '0', '1',0x00,0x00) +#define GST_RIFF_02 MAKE_FOUR_CC( '0', '2',0x00,0x00) +#define GST_RIFF_03 MAKE_FOUR_CC( '0', '3',0x00,0x00) +#define GST_RIFF_04 MAKE_FOUR_CC( '0', '4',0x00,0x00) +#define GST_RIFF_05 MAKE_FOUR_CC( '0', '5',0x00,0x00) +#define GST_RIFF_06 MAKE_FOUR_CC( '0', '6',0x00,0x00) +#define GST_RIFF_07 MAKE_FOUR_CC( '0', '7',0x00,0x00) +#define GST_RIFF_00pc MAKE_FOUR_CC( '0', '0', 'p', 'c') +#define GST_RIFF_01pc MAKE_FOUR_CC( '0', '1', 'p', 'c') +#define GST_RIFF_00dc MAKE_FOUR_CC( '0', '0', 'd', 'c') +#define GST_RIFF_00dx MAKE_FOUR_CC( '0', '0', 'd', 'x') +#define GST_RIFF_00db MAKE_FOUR_CC( '0', '0', 'd', 'b') +#define GST_RIFF_00xx MAKE_FOUR_CC( '0', '0', 'x', 'x') +#define GST_RIFF_00id MAKE_FOUR_CC( '0', '0', 'i', 'd') +#define GST_RIFF_00rt MAKE_FOUR_CC( '0', '0', 'r', 't') +#define GST_RIFF_0021 MAKE_FOUR_CC( '0', '0', '2', '1') +#define GST_RIFF_00iv MAKE_FOUR_CC( '0', '0', 'i', 'v') +#define GST_RIFF_0031 MAKE_FOUR_CC( '0', '0', '3', '1') +#define GST_RIFF_0032 MAKE_FOUR_CC( '0', '0', '3', '2') +#define GST_RIFF_00vc MAKE_FOUR_CC( '0', '0', 'v', 'c') +#define GST_RIFF_00xm MAKE_FOUR_CC( '0', '0', 'x', 'm') +#define GST_RIFF_01wb MAKE_FOUR_CC( '0', '1', 'w', 'b') +#define GST_RIFF_01dc MAKE_FOUR_CC( '0', '1', 'd', 'c') +#define GST_RIFF_00__ MAKE_FOUR_CC( '0', '0', '_', '_') + +/*********VIDEO CODECS**************/ +#define GST_RIFF_cram MAKE_FOUR_CC( 'c', 'r', 'a', 'm') +#define GST_RIFF_CRAM MAKE_FOUR_CC( 'C', 'R', 'A', 'M') +#define GST_RIFF_wham MAKE_FOUR_CC( 'w', 'h', 'a', 'm') +#define GST_RIFF_WHAM MAKE_FOUR_CC( 'W', 'H', 'A', 'M') +#define GST_RIFF_rgb MAKE_FOUR_CC(0x00,0x00,0x00,0x00) +#define GST_RIFF_RGB MAKE_FOUR_CC( 'R', 'G', 'B', ' ') +#define GST_RIFF_rle8 MAKE_FOUR_CC(0x01,0x00,0x00,0x00) +#define GST_RIFF_RLE8 MAKE_FOUR_CC( 'R', 'L', 'E', '8') +#define GST_RIFF_rle4 MAKE_FOUR_CC(0x02,0x00,0x00,0x00) +#define GST_RIFF_RLE4 MAKE_FOUR_CC( 'R', 'L', 'E', '4') +#define GST_RIFF_none MAKE_FOUR_CC(0x00,0x00,0xFF,0xFF) +#define GST_RIFF_NONE MAKE_FOUR_CC( 'N', 'O', 'N', 'E') +#define GST_RIFF_pack MAKE_FOUR_CC(0x01,0x00,0xFF,0xFF) +#define GST_RIFF_PACK MAKE_FOUR_CC( 'P', 'A', 'C', 'K') +#define GST_RIFF_tran MAKE_FOUR_CC(0x02,0x00,0xFF,0xFF) +#define GST_RIFF_TRAN MAKE_FOUR_CC( 'T', 'R', 'A', 'N') +#define GST_RIFF_ccc MAKE_FOUR_CC(0x03,0x00,0xFF,0xFF) +#define GST_RIFF_CCC MAKE_FOUR_CC( 'C', 'C', 'C', ' ') +#define GST_RIFF_cyuv MAKE_FOUR_CC( 'c', 'y', 'u', 'v') +#define GST_RIFF_CYUV MAKE_FOUR_CC( 'C', 'Y', 'U', 'V') +#define GST_RIFF_jpeg MAKE_FOUR_CC(0x04,0x00,0xFF,0xFF) +#define GST_RIFF_JPEG MAKE_FOUR_CC( 'J', 'P', 'E', 'G') +#define GST_RIFF_MJPG MAKE_FOUR_CC( 'M', 'J', 'P', 'G') +#define GST_RIFF_mJPG MAKE_FOUR_CC( 'm', 'J', 'P', 'G') +#define GST_RIFF_IJPG MAKE_FOUR_CC( 'I', 'J', 'P', 'G') +#define GST_RIFF_rt21 MAKE_FOUR_CC( 'r', 't', '2', '1') +#define GST_RIFF_RT21 MAKE_FOUR_CC( 'R', 'T', '2', '1') +#define GST_RIFF_iv31 MAKE_FOUR_CC( 'i', 'v', '3', '1') +#define GST_RIFF_IV31 MAKE_FOUR_CC( 'I', 'V', '3', '1') +#define GST_RIFF_iv32 MAKE_FOUR_CC( 'i', 'v', '3', '2') +#define GST_RIFF_IV32 MAKE_FOUR_CC( 'I', 'V', '3', '2') +#define GST_RIFF_iv41 MAKE_FOUR_CC( 'i', 'v', '4', '1') +#define GST_RIFF_IV41 MAKE_FOUR_CC( 'I', 'V', '4', '1') +#define GST_RIFF_iv50 MAKE_FOUR_CC( 'i', 'v', '5', '0') +#define GST_RIFF_IV50 MAKE_FOUR_CC( 'I', 'V', '5', '0') +#define GST_RIFF_cvid MAKE_FOUR_CC( 'c', 'v', 'i', 'd') +#define GST_RIFF_CVID MAKE_FOUR_CC( 'C', 'V', 'I', 'D') +#define GST_RIFF_ULTI MAKE_FOUR_CC( 'U', 'L', 'T', 'I') +#define GST_RIFF_ulti MAKE_FOUR_CC( 'u', 'l', 't', 'i') +#define GST_RIFF_YUV9 MAKE_FOUR_CC( 'Y', 'V', 'U', '9') +#define GST_RIFF_YVU9 MAKE_FOUR_CC( 'Y', 'U', 'V', '9') +#define GST_RIFF_XMPG MAKE_FOUR_CC( 'X', 'M', 'P', 'G') +#define GST_RIFF_xmpg MAKE_FOUR_CC( 'x', 'm', 'p', 'g') +#define GST_RIFF_VDOW MAKE_FOUR_CC( 'V', 'D', 'O', 'W') +#define GST_RIFF_MVI1 MAKE_FOUR_CC( 'M', 'V', 'I', '1') +#define GST_RIFF_v422 MAKE_FOUR_CC( 'v', '4', '2', '2') +#define GST_RIFF_V422 MAKE_FOUR_CC( 'V', '4', '2', '2') +#define GST_RIFF_mvi1 MAKE_FOUR_CC( 'm', 'v', 'i', '1') +#define GST_RIFF_MPIX MAKE_FOUR_CC(0x04,0x00, 'i', '1') /* MotionPixels munged their id */ +#define GST_RIFF_AURA MAKE_FOUR_CC( 'A', 'U', 'R', 'A') +#define GST_RIFF_DMB1 MAKE_FOUR_CC( 'D', 'M', 'B', '1') +#define GST_RIFF_dmb1 MAKE_FOUR_CC( 'd', 'm', 'b', '1') + +#define GST_RIFF_BW10 MAKE_FOUR_CC( 'B', 'W', '1', '0') +#define GST_RIFF_bw10 MAKE_FOUR_CC( 'b', 'w', '1', '0') + +#define GST_RIFF_yuy2 MAKE_FOUR_CC( 'y', 'u', 'y', '2') +#define GST_RIFF_YUY2 MAKE_FOUR_CC( 'Y', 'U', 'Y', '2') +#define GST_RIFF_YUV8 MAKE_FOUR_CC( 'Y', 'U', 'V', '8') +#define GST_RIFF_WINX MAKE_FOUR_CC( 'W', 'I', 'N', 'X') +#define GST_RIFF_WPY2 MAKE_FOUR_CC( 'W', 'P', 'Y', '2') +#define GST_RIFF_m263 MAKE_FOUR_CC( 'm', '2', '6', '3') +#define GST_RIFF_M263 MAKE_FOUR_CC( 'M', '2', '6', '3') + +#define GST_RIFF_Q1_0 MAKE_FOUR_CC( 'Q', '1',0x2e, '0') +#define GST_RIFF_SFMC MAKE_FOUR_CC( 'S', 'F', 'M', 'C') + +#define GST_RIFF_y41p MAKE_FOUR_CC( 'y', '4', '1', 'p') +#define GST_RIFF_Y41P MAKE_FOUR_CC( 'Y', '4', '1', 'P') +#define GST_RIFF_yv12 MAKE_FOUR_CC( 'y', 'v', '1', '2') +#define GST_RIFF_YV12 MAKE_FOUR_CC( 'Y', 'V', '1', '2') +#define GST_RIFF_vixl MAKE_FOUR_CC( 'v', 'i', 'x', 'l') +#define GST_RIFF_VIXL MAKE_FOUR_CC( 'V', 'I', 'X', 'L') +#define GST_RIFF_iyuv MAKE_FOUR_CC( 'i', 'y', 'u', 'v') +#define GST_RIFF_IYUV MAKE_FOUR_CC( 'I', 'Y', 'U', 'V') +#define GST_RIFF_i420 MAKE_FOUR_CC( 'i', '4', '2', '0') +#define GST_RIFF_I420 MAKE_FOUR_CC( 'I', '4', '2', '0') +#define GST_RIFF_vyuy MAKE_FOUR_CC( 'v', 'y', 'u', 'y') +#define GST_RIFF_VYUY MAKE_FOUR_CC( 'V', 'Y', 'U', 'Y') + +#define GST_RIFF_DIV3 MAKE_FOUR_CC( 'D', 'I', 'V', '3') + +#define GST_RIFF_rpza MAKE_FOUR_CC( 'r', 'p', 'z', 'a') +/* And this here's the mistakes that need to be supported */ +#define GST_RIFF_azpr MAKE_FOUR_CC( 'a', 'z', 'p', 'r') /* recognize Apple's rpza mangled? */ + +/*********** FND in MJPG **********/ +#define GST_RIFF_ISFT MAKE_FOUR_CC( 'I', 'S', 'F', 'T') +#define GST_RIFF_IDIT MAKE_FOUR_CC( 'I', 'D', 'I', 'T') + +#define GST_RIFF_00AM MAKE_FOUR_CC( '0', '0', 'A', 'M') +#define GST_RIFF_DISP MAKE_FOUR_CC( 'D', 'I', 'S', 'P') +#define GST_RIFF_ISBJ MAKE_FOUR_CC( 'I', 'S', 'B', 'J') + +#define GST_RIFF_rec MAKE_FOUR_CC( 'r', 'e', 'c', ' ') + +/* common data structures */ +struct _gst_riff_avih { + guint32 us_frame; /* microsec per frame */ + guint32 max_bps; /* byte/s overall */ + guint32 pad_gran; /* pad_gran (???) */ + guint32 flags; +/* flags values */ +#define GST_RIFF_AVIH_HASINDEX 0x00000010 /* has idx1 chunk */ +#define GST_RIFF_AVIH_MUSTUSEINDEX 0x00000020 /* must use idx1 chunk to determine order */ +#define GST_RIFF_AVIH_ISINTERLEAVED 0x00000100 /* AVI file is interleaved */ +#define GST_RIFF_AVIH_WASCAPTUREFILE 0x00010000 /* specially allocated used for capturing real time video */ +#define GST_RIFF_AVIH_COPYRIGHTED 0x00020000 /* contains copyrighted data */ + guint32 tot_frames; /* # of frames (all) */ + guint32 init_frames; /* initial frames (???) */ + guint32 streams; + guint32 bufsize; /* suggested buffer size */ + guint32 width; + guint32 height; + guint32 scale; + guint32 rate; + guint32 start; + guint32 length; +}; + +struct _gst_riff_strh { + guint32 type; /* stream type */ + guint32 fcc_handler; /* fcc_handler */ + guint32 flags; +/* flags values */ +#define GST_RIFF_STRH_DISABLED 0x000000001 +#define GST_RIFF_STRH_VIDEOPALCHANGES 0x000010000 + guint32 priority; + guint32 init_frames; /* initial frames (???) */ + guint32 scale; + guint32 rate; + guint32 start; + guint32 length; + guint32 bufsize; /* suggested buffer size */ + guint32 quality; + guint32 samplesize; + /* XXX 16 bytes ? */ +}; + +struct _gst_riff_strf_vids { /* == BitMapInfoHeader */ + guint32 size; + guint32 width; + guint32 height; + guint16 planes; + guint16 bit_cnt; + guint32 compression; + guint32 image_size; + guint32 xpels_meter; + guint32 ypels_meter; + guint32 num_colors; /* used colors */ + guint32 imp_colors; /* important colors */ + /* may be more for some codecs */ +}; + + +struct _gst_riff_strf_auds { /* == WaveHeader (?) */ + guint16 format; +/**** from public Microsoft RIFF docs ******/ +#define GST_RIFF_WAVE_FORMAT_UNKNOWN (0x0000) +#define GST_RIFF_WAVE_FORMAT_PCM (0x0001) +#define GST_RIFF_WAVE_FORMAT_ADPCM (0x0002) +#define GST_RIFF_WAVE_FORMAT_IBM_CVSD (0x0005) +#define GST_RIFF_WAVE_FORMAT_ALAW (0x0006) +#define GST_RIFF_WAVE_FORMAT_MULAW (0x0007) +#define GST_RIFF_WAVE_FORMAT_OKI_ADPCM (0x0010) +#define GST_RIFF_WAVE_FORMAT_DVI_ADPCM (0x0011) +#define GST_RIFF_WAVE_FORMAT_DIGISTD (0x0015) +#define GST_RIFF_WAVE_FORMAT_DIGIFIX (0x0016) +#define GST_RIFF_WAVE_FORMAT_YAMAHA_ADPCM (0x0020) +#define GST_RIFF_WAVE_FORMAT_DSP_TRUESPEECH (0x0022) +#define GST_RIFF_WAVE_FORMAT_GSM610 (0x0031) +#define GST_RIFF_WAVE_FORMAT_MSN (0x0032) +#define GST_RIFF_WAVE_FORMAT_MPEGL12 (0x0050) +#define GST_RIFF_WAVE_FORMAT_MPEGL3 (0x0055) +#define GST_RIFF_IBM_FORMAT_MULAW (0x0101) +#define GST_RIFF_IBM_FORMAT_ALAW (0x0102) +#define GST_RIFF_IBM_FORMAT_ADPCM (0x0103) +#define GST_RIFF_WAVE_FORMAT_DIVX (0x0160) +#define GST_RIFF_WAVE_FORMAT_divx (0x0161) +#define GST_RIFF_WAVE_FORMAT_VORBIS1 (0x674f) +#define GST_RIFF_WAVE_FORMAT_VORBIS2 (0x6750) +#define GST_RIFF_WAVE_FORMAT_VORBIS3 (0x6751) +#define GST_RIFF_WAVE_FORMAT_VORBIS1PLUS (0x676f) +#define GST_RIFF_WAVE_FORMAT_VORBIS2PLUS (0x6770) +#define GST_RIFF_WAVE_FORMAT_VORBIS3PLUS (0x6771) + guint16 channels; + guint32 rate; + guint32 av_bps; + guint16 blockalign; + guint16 size; +}; + +struct _gst_riff_strf_iavs { + guint32 DVAAuxSrc; + guint32 DVAAuxCtl; + guint32 DVAAuxSrc1; + guint32 DVAAuxCtl1; + guint32 DVVAuxSrc; + guint32 DVVAuxCtl; + guint32 DVReserved1; + guint32 DVReserved2; +}; + +struct _gst_riff_riff { + guint32 id; + guint32 size; + guint32 type; +}; + +struct _gst_riff_list { + guint32 id; + guint32 size; + guint32 type; +}; + +struct _gst_riff_chunk { + guint32 id; + guint32 size; +}; + +struct _gst_riff_index_entry { + guint32 id; + guint32 flags; +#define GST_RIFF_IF_LIST (0x00000001L) +#define GST_RIFF_IF_KEYFRAME (0x00000010L) +#define GST_RIFF_IF_NO_TIME (0x00000100L) +#define GST_RIFF_IF_COMPUSE (0x0FFF0000L) + guint32 offset; + guint32 size; +}; + +typedef struct _gst_riff_riff gst_riff_riff; +typedef struct _gst_riff_list gst_riff_list; +typedef struct _gst_riff_chunk gst_riff_chunk; +typedef struct _gst_riff_index_entry gst_riff_index_entry; + +typedef struct _gst_riff_avih gst_riff_avih; +typedef struct _gst_riff_strh gst_riff_strh; +typedef struct _gst_riff_strf_vids gst_riff_strf_vids; +typedef struct _gst_riff_strf_auds gst_riff_strf_auds; +typedef struct _gst_riff_strf_iavs gst_riff_strf_iavs; + + +typedef struct _GstRiffParse GstRiffParse; + +struct _GstRiffParse { + GstPad *pad; + + GstByteStream *bs; +}; + +GstRiffParse* gst_riff_parse_new (GstPad *pad); +GstRiffReturn gst_riff_parse_next_chunk (GstRiffParse *parse, guint32 *id, GstBuffer **buf); +void gst_riff_parse_free (GstRiffParse *parse); + +#endif /* __GST_RIFF_PARSE_H__ */ -- 2.7.4