From 6f5a3ecfa7358b8c50c71ac6fe3464a0bb2503e0 Mon Sep 17 00:00:00 2001 From: Mark Nauwelaerts Date: Mon, 23 May 2011 12:06:01 +0200 Subject: [PATCH] videoparsers: add new mpegvideoparse --- gst/videoparsers/Makefile.am | 6 +- gst/videoparsers/gstmpegvideoparse.c | 656 +++++++++++++++++++++++++++ gst/videoparsers/gstmpegvideoparse.h | 75 +++ gst/videoparsers/mpegvideoparse.c | 270 +++++++++++ gst/videoparsers/mpegvideoparse.h | 77 ++++ gst/videoparsers/plugin.c | 3 + 6 files changed, 1085 insertions(+), 2 deletions(-) create mode 100644 gst/videoparsers/gstmpegvideoparse.c create mode 100644 gst/videoparsers/gstmpegvideoparse.h create mode 100644 gst/videoparsers/mpegvideoparse.c create mode 100644 gst/videoparsers/mpegvideoparse.h diff --git a/gst/videoparsers/Makefile.am b/gst/videoparsers/Makefile.am index aca503306e..6cebef5330 100644 --- a/gst/videoparsers/Makefile.am +++ b/gst/videoparsers/Makefile.am @@ -3,7 +3,8 @@ plugin_LTLIBRARIES = libgstvideoparsersbad.la libgstvideoparsersbad_la_SOURCES = plugin.c \ h263parse.c gsth263parse.c \ gsth264parse.c h264parse.c \ - gstdiracparse.c dirac_parse.c + gstdiracparse.c dirac_parse.c \ + gstmpegvideoparse.c mpegvideoparse.c libgstvideoparsersbad_la_CFLAGS = \ $(GST_BASE_CFLAGS) $(GST_CFLAGS) libgstvideoparsersbad_la_LIBADD = \ @@ -13,7 +14,8 @@ libgstvideoparsersbad_la_LIBTOOLFLAGS = --tag=disable-static noinst_HEADERS = gsth263parse.h h263parse.h \ gsth264parse.h h264parse.h \ - gstdiracparse.h dirac_parse.h + gstdiracparse.h dirac_parse.h \ + gstmpegvideoparse.h mpegvideoparse.h Android.mk: Makefile.am $(BUILT_SOURCES) androgenizer \ diff --git a/gst/videoparsers/gstmpegvideoparse.c b/gst/videoparsers/gstmpegvideoparse.c new file mode 100644 index 0000000000..9136cd4ae1 --- /dev/null +++ b/gst/videoparsers/gstmpegvideoparse.c @@ -0,0 +1,656 @@ +/* GStreamer + * Copyright (C) <2007> Jan Schmidt + * Copyright (C) <2011> Mark Nauwelaerts + * Copyright (C) <2011> Collabora Multimedia + * Copyright (C) <2011> Nokia Corporation + * + * 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 + +#include "gstmpegvideoparse.h" + +GST_DEBUG_CATEGORY (mpegv_parse_debug); +#define GST_CAT_DEFAULT mpegv_parse_debug + +static GstStaticPadTemplate src_template = +GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/mpeg, " + "mpegversion = (int) [1, 2], " + "parsed = (boolean) true, " "systemstream = (boolean) false") + ); + +static GstStaticPadTemplate sink_template = +GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/mpeg, " + "mpegversion = (int) 4, " + "parsed = (boolean) false, " "systemstream = (boolean) false") + ); + +/* Properties */ +#define DEFAULT_PROP_DROP TRUE +#define DEFAULT_PROP_GOP_SPLIT FALSE + +enum +{ + PROP_0, + PROP_DROP, + PROP_GOP_SPLIT, + PROP_LAST +}; + +GST_BOILERPLATE (GstMpegvParse, gst_mpegv_parse, GstBaseParse, + GST_TYPE_BASE_PARSE); + +static gboolean gst_mpegv_parse_start (GstBaseParse * parse); +static gboolean gst_mpegv_parse_stop (GstBaseParse * parse); +static gboolean gst_mpegv_parse_check_valid_frame (GstBaseParse * parse, + GstBaseParseFrame * frame, guint * framesize, gint * skipsize); +static GstFlowReturn gst_mpegv_parse_parse_frame (GstBaseParse * parse, + GstBaseParseFrame * frame); +static gboolean gst_mpegv_parse_set_caps (GstBaseParse * parse, GstCaps * caps); + +static void gst_mpegv_parse_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_mpegv_parse_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); + +static void +gst_mpegv_parse_base_init (gpointer klass) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&src_template)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&sink_template)); + + gst_element_class_set_details_simple (element_class, + "MPEG video elementary stream parser", + "Codec/Parser/Video", + "Parses and frames MPEG-1 and MPEG-2 elementary video streams", + "Wim Taymans , " + "Jan Schmidt , " + "Mark Nauwelaerts "); + + GST_DEBUG_CATEGORY_INIT (mpegv_parse_debug, "mpegvideoparse", 0, + "MPEG-1/2 video parser"); +} + +static void +gst_mpegv_parse_set_property (GObject * object, guint property_id, + const GValue * value, GParamSpec * pspec) +{ + GstMpegvParse *parse = GST_MPEGVIDEO_PARSE (object); + + switch (property_id) { + case PROP_DROP: + parse->drop = g_value_get_boolean (value); + break; + case PROP_GOP_SPLIT: + parse->gop_split = g_value_get_boolean (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +gst_mpegv_parse_get_property (GObject * object, guint property_id, + GValue * value, GParamSpec * pspec) +{ + GstMpegvParse *parse = GST_MPEGVIDEO_PARSE (object); + + switch (property_id) { + case PROP_DROP: + g_value_set_boolean (value, parse->drop); + break; + case PROP_GOP_SPLIT: + g_value_set_boolean (value, parse->gop_split); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +gst_mpegv_parse_class_init (GstMpegvParseClass * klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + gobject_class->set_property = gst_mpegv_parse_set_property; + gobject_class->get_property = gst_mpegv_parse_get_property; + + g_object_class_install_property (gobject_class, PROP_DROP, + g_param_spec_boolean ("drop", "drop", + "Drop data untill valid configuration data is received either " + "in the stream or through caps", DEFAULT_PROP_DROP, + G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property (gobject_class, PROP_GOP_SPLIT, + g_param_spec_boolean ("gop-split", "gop-split", + "Split frame when encountering GOP", DEFAULT_PROP_GOP_SPLIT, + G_PARAM_CONSTRUCT | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + /* Override BaseParse vfuncs */ + parse_class->start = GST_DEBUG_FUNCPTR (gst_mpegv_parse_start); + parse_class->stop = GST_DEBUG_FUNCPTR (gst_mpegv_parse_stop); + parse_class->check_valid_frame = + GST_DEBUG_FUNCPTR (gst_mpegv_parse_check_valid_frame); + parse_class->parse_frame = GST_DEBUG_FUNCPTR (gst_mpegv_parse_parse_frame); + parse_class->set_sink_caps = GST_DEBUG_FUNCPTR (gst_mpegv_parse_set_caps); +} + +static void +gst_mpegv_parse_init (GstMpegvParse * parse, GstMpegvParseClass * g_class) +{ +} + +static void +gst_mpegv_parse_reset_frame (GstMpegvParse * mpvparse) +{ + /* done parsing; reset state */ + mpvparse->last_sc = -1; + mpvparse->seq_offset = -1; + mpvparse->pic_offset = -1; +} + +static void +gst_mpegv_parse_reset (GstMpegvParse * mpvparse) +{ + gst_mpegv_parse_reset_frame (mpvparse); + mpvparse->profile = 0; + mpvparse->update_caps = TRUE; + + gst_buffer_replace (&mpvparse->config, NULL); + memset (&mpvparse->params, 0, sizeof (mpvparse->params)); +} + +static gboolean +gst_mpegv_parse_start (GstBaseParse * parse) +{ + GstMpegvParse *mpvparse = GST_MPEGVIDEO_PARSE (parse); + + GST_DEBUG_OBJECT (parse, "start"); + + gst_mpegv_parse_reset (mpvparse); + /* at least this much for a valid frame */ + gst_base_parse_set_min_frame_size (parse, 6); + + return TRUE; +} + +static gboolean +gst_mpegv_parse_stop (GstBaseParse * parse) +{ + GstMpegvParse *mpvparse = GST_MPEGVIDEO_PARSE (parse); + + GST_DEBUG_OBJECT (parse, "stop"); + + gst_mpegv_parse_reset (mpvparse); + + return TRUE; +} + +static gboolean +gst_mpegv_parse_process_config (GstMpegvParse * mpvparse, const guint8 * data, + gsize size) +{ + /* only do stuff if something new */ + if (mpvparse->config && size == GST_BUFFER_SIZE (mpvparse->config) && + memcmp (GST_BUFFER_DATA (mpvparse->config), data, size) == 0) + return TRUE; + + if (!gst_mpeg_video_params_parse_config (&mpvparse->params, data, size)) { + GST_DEBUG_OBJECT (mpvparse, "failed to parse config data (size %d)", size); + return FALSE; + } + + GST_LOG_OBJECT (mpvparse, "accepting parsed config size %d", size); + + /* parsing ok, so accept it as new config */ + if (mpvparse->config != NULL) + gst_buffer_unref (mpvparse->config); + + mpvparse->config = gst_buffer_new_and_alloc (size); + memcpy (GST_BUFFER_DATA (mpvparse->config), data, size); + + /* trigger src caps update */ + mpvparse->update_caps = TRUE; + + return TRUE; +} + +#ifndef GST_DISABLE_GST_DEBUG +static const gchar * +picture_start_code_name (guint8 psc) +{ + guint i; + const struct + { + guint8 psc; + const gchar *name; + } psc_names[] = { + { + 0x00, "Picture Start"}, { + 0xb0, "Reserved"}, { + 0xb1, "Reserved"}, { + 0xb2, "User Data Start"}, { + 0xb3, "Sequence Header Start"}, { + 0xb4, "Sequence Error"}, { + 0xb5, "Extension Start"}, { + 0xb6, "Reserved"}, { + 0xb7, "Sequence End"}, { + 0xb8, "Group Start"}, { + 0xb9, "Program End"} + }; + if (psc < 0xB0 && psc > 0) + return "Slice Start"; + + for (i = 0; i < G_N_ELEMENTS (psc_names); i++) + if (psc_names[i].psc == psc) + return psc_names[i].name; + + return "UNKNOWN"; +}; + +static const gchar * +picture_type_name (guint8 pct) +{ + guint i; + const struct + { + guint8 pct; + const gchar *name; + } pct_names[] = { + { + 0, "Forbidden"}, { + 1, "I Frame"}, { + 2, "P Frame"}, { + 3, "B Frame"}, { + 4, "DC Intra Coded (Shall Not Be Used!)"} + }; + + for (i = 0; i < G_N_ELEMENTS (pct_names); i++) + if (pct_names[i].pct == pct) + return pct_names[i].name; + + return "Reserved/Unknown"; +} +#endif /* GST_DISABLE_GST_DEBUG */ + +/* caller guarantees at least start code in @buf at @off */ +/* for off == 0 initial code; returns TRUE if code starts a frame, + * otherwise returns TRUE if code terminates preceding frame */ +static gboolean +gst_mpegv_parse_process_sc (GstMpegvParse * mpvparse, GstBuffer * buf, gint off) +{ + gboolean ret = FALSE, do_seq = TRUE; + guint8 *data; + guint code; + + g_return_val_if_fail (buf && GST_BUFFER_SIZE (buf) >= 4, FALSE); + + data = GST_BUFFER_DATA (buf); + code = data[off + 3]; + + GST_LOG_OBJECT (mpvparse, "process startcode %x (%s)", code, + picture_start_code_name (code)); + + switch (code) { + case MPEG_PACKET_PICTURE: + GST_LOG_OBJECT (mpvparse, "startcode is PICTURE"); + /* picture is aggregated with preceding sequence/gop, if any. + * so, picture start code only ends if already a previous one */ + if (mpvparse->pic_offset < 0) + mpvparse->pic_offset = off; + else + ret = TRUE; + if (!off) + ret = TRUE; + break; + case MPEG_PACKET_SEQUENCE: + GST_LOG_OBJECT (mpvparse, "startcode is SEQUENCE"); + if (off == 0) + mpvparse->seq_offset = off; + ret = TRUE; + break; + case MPEG_PACKET_GOP: + GST_LOG_OBJECT (mpvparse, "startcode is GOP"); + if (mpvparse->seq_offset >= 0) + ret = mpvparse->gop_split; + else + ret = TRUE; + break; + default: + do_seq = FALSE; + break; + } + + /* process config data */ + if (G_UNLIKELY (mpvparse->seq_offset >= 0 && off && do_seq)) { + g_assert (mpvparse->seq_offset == 0); + gst_mpegv_parse_process_config (mpvparse, GST_BUFFER_DATA (buf), off); + /* avoid accepting again for a PICTURE sc following a GOP sc */ + mpvparse->seq_offset = -1; + } + + /* extract some picture info if there is any in the frame being terminated */ + if (G_UNLIKELY (ret && off)) { + if (G_LIKELY (mpvparse->pic_offset >= 0 && mpvparse->pic_offset < off)) { + if (G_LIKELY (GST_BUFFER_SIZE (buf) >= mpvparse->pic_offset + 6)) { + gint pct = (data[mpvparse->pic_offset + 5] >> 3) & 0x7; + + GST_LOG_OBJECT (mpvparse, "picture_coding_type %d (%s)", pct, + picture_type_name (pct)); + mpvparse->intra_frame = (pct == MPEG_PICTURE_TYPE_I); + } else { + GST_WARNING_OBJECT (mpvparse, "no data following PICTURE startcode"); + mpvparse->intra_frame = FALSE; + } + } else { + /* frame without picture must be some config, consider as keyframe */ + mpvparse->intra_frame = TRUE; + } + GST_LOG_OBJECT (mpvparse, "ending frame of size %d, is intra %d", off, + mpvparse->intra_frame); + } + + return ret; +} + +/* FIXME move into baseparse, or anything equivalent; + * see https://bugzilla.gnome.org/show_bug.cgi?id=650093 */ +#define GST_BASE_PARSE_FRAME_FLAG_PARSING 0x10000 + +static gboolean +gst_mpegv_parse_check_valid_frame (GstBaseParse * parse, + GstBaseParseFrame * frame, guint * framesize, gint * skipsize) +{ + GstMpegvParse *mpvparse = GST_MPEGVIDEO_PARSE (parse); + GstBuffer *buf = frame->buffer; + GstByteReader reader = GST_BYTE_READER_INIT_FROM_BUFFER (buf); + gint off = 0; + gboolean ret; + +retry: + /* at least start code and subsequent byte */ + if (G_UNLIKELY (GST_BUFFER_SIZE (buf) - off < 5)) + return FALSE; + + /* avoid stale cached parsing state */ + if (!(frame->flags & GST_BASE_PARSE_FRAME_FLAG_PARSING)) { + GST_LOG_OBJECT (mpvparse, "parsing new frame"); + gst_mpegv_parse_reset_frame (mpvparse); + frame->flags |= GST_BASE_PARSE_FRAME_FLAG_PARSING; + } else { + GST_LOG_OBJECT (mpvparse, "resuming frame parsing"); + } + + /* if already found a previous start code, e.g. start of frame, go for next */ + if (mpvparse->last_sc >= 0) { + off = mpvparse->last_sc; + goto next; + } + + off = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffff00, 0x00000100, + off, GST_BUFFER_SIZE (buf) - off); + + GST_LOG_OBJECT (mpvparse, "possible sync at buffer offset %d", off); + + /* didn't find anything that looks like a sync word, skip */ + if (G_UNLIKELY (off < 0)) { + *skipsize = GST_BUFFER_SIZE (buf) - 3; + return FALSE; + } + + /* possible frame header, but not at offset 0? skip bytes before sync */ + if (G_UNLIKELY (off > 0)) { + *skipsize = off; + return FALSE; + } + + /* note: initial start code is assumed at offset 0 by subsequent code */ + + /* examine start code, see if it looks like an initial start code */ + if (gst_mpegv_parse_process_sc (mpvparse, buf, 0)) { + /* found sc */ + mpvparse->last_sc = 0; + } else { + off++; + goto retry; + } + +next: + /* start is fine as of now */ + *skipsize = 0; + /* position a bit further than last sc */ + off++; + /* so now we have start code at start of data; locate next start code */ + off = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffff00, 0x00000100, + off, GST_BUFFER_SIZE (buf) - off); + + GST_LOG_OBJECT (mpvparse, "next start code at %d", off); + if (off < 0) { + /* if draining, take all */ + if (GST_BASE_PARSE_DRAINING (parse)) { + off = GST_BUFFER_SIZE (buf); + ret = TRUE; + } else { + /* resume scan where we left it */ + mpvparse->last_sc = GST_BUFFER_SIZE (buf) - 4; + /* request best next available */ + *framesize = G_MAXUINT; + return FALSE; + } + } else { + /* decide whether this startcode ends a frame */ + ret = gst_mpegv_parse_process_sc (mpvparse, buf, off); + } + + if (ret) { + *framesize = off; + } else { + goto next; + } + + return ret; +} + +static void +gst_mpegv_parse_update_src_caps (GstMpegvParse * mpvparse) +{ + GstCaps *caps = NULL; + + /* only update if no src caps yet or explicitly triggered */ + if (G_LIKELY (GST_PAD_CAPS (GST_BASE_PARSE_SRC_PAD (mpvparse)) && + !mpvparse->update_caps)) + return; + + /* carry over input caps as much as possible; override with our own stuff */ + caps = GST_PAD_CAPS (GST_BASE_PARSE_SINK_PAD (mpvparse)); + if (caps) { + caps = gst_caps_copy (caps); + } else { + caps = gst_caps_new_simple ("video/mpeg", NULL); + } + + /* typically we don't output buffers until we have properly parsed some + * config data, so we should at least know about version. + * If not, it means it has been requested not to drop data, and + * upstream and/or app must know what they are doing ... */ + if (G_LIKELY (mpvparse->params.mpeg_version)) + gst_caps_set_simple (caps, + "mpegversion", G_TYPE_INT, mpvparse->params.mpeg_version, NULL); + + gst_caps_set_simple (caps, "systemstream", G_TYPE_BOOLEAN, FALSE, + "parsed", G_TYPE_BOOLEAN, TRUE, NULL); + + if (mpvparse->params.width > 0 && mpvparse->params.height > 0) { + gst_caps_set_simple (caps, "width", G_TYPE_INT, mpvparse->params.width, + "height", G_TYPE_INT, mpvparse->params.height, NULL); + } + + /* perhaps we have a framerate */ + if (mpvparse->params.fps_n > 0 && mpvparse->params.fps_d > 0) { + gint fps_num = mpvparse->params.fps_n; + gint fps_den = mpvparse->params.fps_d; + GstClockTime latency = gst_util_uint64_scale (GST_SECOND, fps_den, fps_num); + + gst_caps_set_simple (caps, "framerate", + GST_TYPE_FRACTION, fps_num, fps_den, NULL); + gst_base_parse_set_frame_rate (GST_BASE_PARSE (mpvparse), + fps_num, fps_den, 0, 0); + gst_base_parse_set_latency (GST_BASE_PARSE (mpvparse), latency, latency); + } + + /* or pixel-aspect-ratio */ + if (mpvparse->params.par_w && mpvparse->params.par_h > 0) { + gst_caps_set_simple (caps, "pixel-aspect-ratio", GST_TYPE_FRACTION, + mpvparse->params.par_w, mpvparse->params.par_h, NULL); + } + + if (mpvparse->config != NULL) { + gst_caps_set_simple (caps, "codec_data", + GST_TYPE_BUFFER, mpvparse->config, NULL); + } + + if (mpvparse->params.mpeg_version == 2) { + const guint profile_c = mpvparse->params.profile; + const guint level_c = mpvparse->params.level; + const gchar *profile = NULL, *level = NULL; + /* + * Profile indication - 1 => High, 2 => Spatially Scalable, + * 3 => SNR Scalable, 4 => Main, 5 => Simple + * 4:2:2 and Multi-view have profile = 0, with the escape bit set to 1 + */ + const gchar *profiles[] = { "high", "spatial", "snr", "main", "simple" }; + /* + * Level indication - 4 => High, 6 => High-1440, 8 => Main, 10 => Low, + * except in the case of profile = 0 + */ + const gchar *levels[] = { "high", "high-1440", "main", "low" }; + + if (profile_c > 0 && profile_c < 6) + profile = profiles[profile_c - 1]; + + if ((level_c > 3) && (level_c < 11) && (level_c % 2 == 0)) + level = levels[(level_c >> 1) - 1]; + + if (profile_c == 8) { + /* Non-hierarchical profile */ + switch (level_c) { + case 2: + level = levels[0]; + case 5: + level = levels[2]; + profile = "4:2:2"; + break; + case 10: + level = levels[0]; + case 11: + level = levels[1]; + case 13: + level = levels[2]; + case 14: + level = levels[3]; + profile = "multiview"; + break; + default: + break; + } + } + + /* FIXME does it make sense to expose profile/level in the caps ? */ + + if (profile) + gst_caps_set_simple (caps, "profile", G_TYPE_STRING, profile, NULL); + else + GST_DEBUG_OBJECT (mpvparse, "Invalid profile - %u", profile_c); + + if (level) + gst_caps_set_simple (caps, "level", G_TYPE_STRING, level, NULL); + else + GST_DEBUG_OBJECT (mpvparse, "Invalid level - %u", level_c); + } + + gst_pad_set_caps (GST_BASE_PARSE_SRC_PAD (mpvparse), caps); + gst_caps_unref (caps); +} + +static GstFlowReturn +gst_mpegv_parse_parse_frame (GstBaseParse * parse, GstBaseParseFrame * frame) +{ + GstMpegvParse *mpvparse = GST_MPEGVIDEO_PARSE (parse); + GstBuffer *buffer = frame->buffer; + + gst_mpegv_parse_update_src_caps (mpvparse); + + if (G_UNLIKELY (mpvparse->intra_frame)) + GST_BUFFER_FLAG_UNSET (buffer, GST_BUFFER_FLAG_DELTA_UNIT); + else + GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT); + + /* maybe only sequence in this buffer, though not recommended, + * so mark it as such and force 0 duration */ + if (G_UNLIKELY (mpvparse->pic_offset < 0)) { + GST_DEBUG_OBJECT (mpvparse, "frame holds no picture data"); + frame->flags |= GST_BASE_PARSE_FRAME_FLAG_NO_FRAME; + GST_BUFFER_DURATION (buffer) = 0; + } + + if (G_UNLIKELY (mpvparse->drop && !mpvparse->config)) { + GST_DEBUG_OBJECT (mpvparse, "dropping frame as no config yet"); + return GST_BASE_PARSE_FLOW_DROPPED; + } else + return GST_FLOW_OK; +} + +static gboolean +gst_mpegv_parse_set_caps (GstBaseParse * parse, GstCaps * caps) +{ + GstMpegvParse *mpvparse = GST_MPEGVIDEO_PARSE (parse); + GstStructure *s; + const GValue *value; + GstBuffer *buf; + + GST_DEBUG_OBJECT (parse, "setcaps called with %" GST_PTR_FORMAT, caps); + + s = gst_caps_get_structure (caps, 0); + + if ((value = gst_structure_get_value (s, "codec_data")) != NULL + && (buf = gst_value_get_buffer (value))) { + /* best possible parse attempt, + * src caps are based on sink caps so it will end up in there + * whether sucessful or not */ + gst_mpegv_parse_process_config (mpvparse, GST_BUFFER_DATA (buf), + GST_BUFFER_SIZE (buf)); + } + + /* let's not interfere and accept regardless of config parsing success */ + return TRUE; +} diff --git a/gst/videoparsers/gstmpegvideoparse.h b/gst/videoparsers/gstmpegvideoparse.h new file mode 100644 index 0000000000..a3706a41a4 --- /dev/null +++ b/gst/videoparsers/gstmpegvideoparse.h @@ -0,0 +1,75 @@ +/* GStreamer + * Copyright (C) <2007> Jan Schmidt + * Copyright (C) <2011> Mark Nauwelaerts + * Copyright (C) <2011> Collabora Multimedia + * Copyright (C) <2011> Nokia Corporation + * + * 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_MPEGVIDEO_PARSE_H__ +#define __GST_MPEGVIDEO_PARSE_H__ + +#include +#include + +#include "mpegvideoparse.h" + +G_BEGIN_DECLS + +#define GST_TYPE_MPEGVIDEO_PARSE (gst_mpegv_parse_get_type()) +#define GST_MPEGVIDEO_PARSE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),\ + GST_TYPE_MPEGVIDEO_PARSE, GstMpegvParse)) +#define GST_MPEGVIDEO_PARSE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),\ + GST_TYPE_MPEGVIDEO_PARSE, GstMpegvParseClass)) +#define GST_MPEGVIDEO_PARSE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),\ + GST_TYPE_MPEGVIDEO_PARSE, GstMpegvParseClass)) +#define GST_IS_MPEGVIDEO_PARSE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),\ + GST_TYPE_MPEGVIDEO_PARSE)) +#define GST_IS_MPEGVIDEO_PARSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),\ + GST_TYPE_MPEGVIDEO_PARSE)) + +typedef struct _GstMpegvParse GstMpegvParse; +typedef struct _GstMpegvParseClass GstMpegvParseClass; + +struct _GstMpegvParse { + GstBaseParse element; + + /* parse state */ + gint last_sc; + gint seq_offset; + gint pic_offset; + gboolean intra_frame; + gboolean update_caps; + + GstBuffer *config; + guint8 profile; + MPEGVParams params; + + /* properties */ + gboolean drop; + gboolean gop_split; +}; + +struct _GstMpegvParseClass { + GstBaseParseClass parent_class; +}; + +GType gst_mpegv_parse_get_type (void); + +G_END_DECLS + +#endif /* __GST_MPEGVIDEO_PARSE_H__ */ diff --git a/gst/videoparsers/mpegvideoparse.c b/gst/videoparsers/mpegvideoparse.c new file mode 100644 index 0000000000..45f8dd306c --- /dev/null +++ b/gst/videoparsers/mpegvideoparse.c @@ -0,0 +1,270 @@ +/* GStreamer + * Copyright (C) <2007> Jan Schmidt + * + * 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 "mpegvideoparse.h" + +#include +#include + +GST_DEBUG_CATEGORY_EXTERN (mpegv_parse_debug); +#define GST_CAT_DEFAULT mpegv_parse_debug + + +#define GET_BITS(b, num, bits) G_STMT_START { \ + if (!gst_bit_reader_get_bits_uint32(b, bits, num)) \ + goto failed; \ + GST_TRACE ("parsed %d bits: %d", num, *(bits)); \ +} G_STMT_END + +#define MARKER_BIT(b) G_STMT_START { \ + guint32 i; \ + GET_BITS(b, 1, &i); \ + if (i != 0x1) \ + goto failed; \ +} G_STMT_END + +static inline gboolean +find_start_code (GstBitReader * b) +{ + guint32 bits; + + /* 0 bits until byte aligned */ + while (b->bit != 0) { + GET_BITS (b, 1, &bits); + } + + /* 0 bytes until startcode */ + while (gst_bit_reader_peek_bits_uint32 (b, &bits, 32)) { + if (bits >> 8 == 0x1) { + return TRUE; + } else { + gst_bit_reader_skip (b, 8); + } + } + + return FALSE; + +failed: + return FALSE; +} + +static gboolean +gst_mpeg_video_params_parse_extension (MPEGVParams * params, GstBitReader * br) +{ + guint32 bits; + + /* double-check */ + GET_BITS (br, 32, &bits); + if (bits != 0x100 + MPEG_PACKET_EXTENSION) + goto failed; + + /* extension_start_code identifier */ + GET_BITS (br, 4, &bits); + + /* profile_and_level_indication */ + GET_BITS (br, 4, &bits); + params->profile = bits; + GET_BITS (br, 4, &bits); + params->level = bits; + + /* progressive_sequence */ + GET_BITS (br, 1, &bits); + params->progressive = bits; + + /* chroma_format */ + GET_BITS (br, 2, &bits); + + /* horizontal_size_extension */ + GET_BITS (br, 2, &bits); + params->width += (bits << 12); + /* vertical_size_extension */ + GET_BITS (br, 2, &bits); + params->height += (bits << 12); + + /* bit_rate_extension */ + GET_BITS (br, 12, &bits); + if (params->bitrate) + params->bitrate += (bits << 18) * 400; + /* marker_bit */ + MARKER_BIT (br); + /* vbv_buffer_size_extension */ + GET_BITS (br, 8, &bits); + /* low_delay */ + GET_BITS (br, 1, &bits); + + /* frame_rate_extension_n */ + GET_BITS (br, 2, &bits); + params->fps_n *= bits + 1; + /* frame_rate_extension_d */ + GET_BITS (br, 5, &bits); + params->fps_d *= bits + 1; + + return TRUE; + + /* ERRORS */ +failed: + { + GST_WARNING ("Failed to parse sequence extension"); + return FALSE; + } +} + +/* Set the Pixel Aspect Ratio in our hdr from a DAR code in the data */ +static void +set_par_from_dar (MPEGVParams * params, guint8 asr_code) +{ + /* Pixel_width = DAR_width * display_vertical_size */ + /* Pixel_height = DAR_height * display_horizontal_size */ + switch (asr_code) { + case 0x02: /* 3:4 DAR = 4:3 pixels */ + params->par_w = 4 * params->height; + params->par_h = 3 * params->width; + break; + case 0x03: /* 9:16 DAR */ + params->par_w = 16 * params->height; + params->par_h = 9 * params->width; + break; + case 0x04: /* 1:2.21 DAR */ + params->par_w = 221 * params->height; + params->par_h = 100 * params->width; + break; + case 0x01: /* Square pixels */ + params->par_w = params->par_h = 1; + break; + default: + GST_DEBUG ("unknown/invalid aspect_ratio_information %d", asr_code); + break; + } +} + +static void +set_fps_from_code (MPEGVParams * params, guint8 fps_code) +{ + const gint framerates[][2] = { + {30, 1}, {24000, 1001}, {24, 1}, {25, 1}, + {30000, 1001}, {30, 1}, {50, 1}, {60000, 1001}, + {60, 1}, {30, 1} + }; + + if (fps_code && fps_code < 10) { + params->fps_n = framerates[fps_code][0]; + params->fps_d = framerates[fps_code][1]; + } else { + GST_DEBUG ("unknown/invalid frame_rate_code %d", fps_code); + /* Force a valid framerate */ + /* FIXME or should this be kept unknown ?? */ + params->fps_n = 30000; + params->fps_d = 1001; + } +} + +static gboolean +gst_mpeg_video_params_parse_sequence (MPEGVParams * params, GstBitReader * br) +{ + guint32 bits; + + GET_BITS (br, 32, &bits); + if (bits != 0x100 + MPEG_PACKET_SEQUENCE) + goto failed; + + /* assume MPEG-1 till otherwise discovered */ + params->mpeg_version = 1; + + GET_BITS (br, 12, &bits); + params->width = bits; + GET_BITS (br, 12, &bits); + params->height = bits; + + GET_BITS (br, 4, &bits); + set_par_from_dar (params, bits); + GET_BITS (br, 4, &bits); + set_fps_from_code (params, bits); + + GET_BITS (br, 18, &bits); + if (bits == 0x3ffff) { + /* VBR stream */ + params->bitrate = 0; + } else { + /* Value in header is in units of 400 bps */ + params->bitrate *= 400; + } + + /* constrained_parameters_flag */ + GET_BITS (br, 1, &bits); + + /* load_intra_quantiser_matrix */ + GET_BITS (br, 1, &bits); + if (bits) { + if (!gst_bit_reader_skip (br, 8 * 64)) + goto failed; + } + + /* load_non_intra_quantiser_matrix */ + GET_BITS (br, 1, &bits); + if (bits) { + if (!gst_bit_reader_skip (br, 8 * 64)) + goto failed; + } + + /* check for MPEG-2 sequence extension */ + while (find_start_code (br)) { + gst_bit_reader_peek_bits_uint32 (br, &bits, 32); + if (bits == 0x100 + MPEG_PACKET_EXTENSION) { + if (!gst_mpeg_video_params_parse_extension (params, br)) + goto failed; + params->mpeg_version = 2; + } + } + + /* dump some info */ + GST_LOG ("width x height: %d x %d", params->width, params->height); + GST_LOG ("fps: %d/%d", params->fps_n, params->fps_d); + GST_LOG ("par: %d/%d", params->par_w, params->par_h); + GST_LOG ("profile/level: %d/%d", params->profile, params->level); + GST_LOG ("bitrate/progressive: %d/%d", params->bitrate, params->progressive); + + return TRUE; + + /* ERRORS */ +failed: + { + GST_WARNING ("Failed to parse sequence header"); + /* clear out stuff */ + memset (params, 0, sizeof (*params)); + return FALSE; + } +} + +gboolean +gst_mpeg_video_params_parse_config (MPEGVParams * params, const guint8 * data, + guint size) +{ + GstBitReader br; + + if (size < 4) + return FALSE; + + gst_bit_reader_init (&br, data, size); + + return gst_mpeg_video_params_parse_sequence (params, &br); +} diff --git a/gst/videoparsers/mpegvideoparse.h b/gst/videoparsers/mpegvideoparse.h new file mode 100644 index 0000000000..f0092b7137 --- /dev/null +++ b/gst/videoparsers/mpegvideoparse.h @@ -0,0 +1,77 @@ +/* GStreamer + * Copyright (C) <2007> Jan Schmidt + * + * 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_MPEGVIDEO_PARAMS_H__ +#define __GST_MPEGVIDEO_PARAMS_H__ + +#include + +G_BEGIN_DECLS + +/* Packet ID codes for different packet types we + * care about */ +#define MPEG_PACKET_PICTURE 0x00 +#define MPEG_PACKET_SLICE_MIN 0x01 +#define MPEG_PACKET_SLICE_MAX 0xaf +#define MPEG_PACKET_SEQUENCE 0xb3 +#define MPEG_PACKET_EXTENSION 0xb5 +#define MPEG_PACKET_SEQUENCE_END 0xb7 +#define MPEG_PACKET_GOP 0xb8 +#define MPEG_PACKET_NONE 0xff + +/* Extension codes we care about */ +#define MPEG_PACKET_EXT_SEQUENCE 0x01 +#define MPEG_PACKET_EXT_SEQUENCE_DISPLAY 0x02 +#define MPEG_PACKET_EXT_QUANT_MATRIX 0x03 + +/* Flags indicating what type of packets are in this block, some are mutually + * exclusive though - ie, sequence packs are accumulated separately. GOP & + * Picture may occur together or separately */ +#define MPEG_BLOCK_FLAG_SEQUENCE 0x01 +#define MPEG_BLOCK_FLAG_PICTURE 0x02 +#define MPEG_BLOCK_FLAG_GOP 0x04 + +#define MPEG_PICTURE_TYPE_I 0x01 +#define MPEG_PICTURE_TYPE_P 0x02 +#define MPEG_PICTURE_TYPE_B 0x03 +#define MPEG_PICTURE_TYPE_D 0x04 + +typedef struct _MPEGVParams MPEGVParams; + +struct _MPEGVParams +{ + gint mpeg_version; + + gint profile; + gint level; + + gint width, height; + gint par_w, par_h; + gint fps_n, fps_d; + + gint bitrate; + gboolean progressive; +}; + +GstFlowReturn gst_mpeg_video_params_parse_config (MPEGVParams * params, + const guint8 * data, guint size); + +G_END_DECLS + +#endif diff --git a/gst/videoparsers/plugin.c b/gst/videoparsers/plugin.c index cfd8a48285..a6db91d357 100644 --- a/gst/videoparsers/plugin.c +++ b/gst/videoparsers/plugin.c @@ -25,6 +25,7 @@ #include "gsth263parse.h" #include "gsth264parse.h" #include "gstdiracparse.h" +#include "gstmpegvideoparse.h" static gboolean plugin_init (GstPlugin * plugin) @@ -37,6 +38,8 @@ plugin_init (GstPlugin * plugin) GST_RANK_NONE, GST_TYPE_H264_PARSE); ret = gst_element_register (plugin, "diracparse", GST_RANK_NONE, GST_TYPE_DIRAC_PARSE); + ret = gst_element_register (plugin, "mpegvideoparse", + GST_RANK_NONE, GST_TYPE_MPEGVIDEO_PARSE); return ret; }