mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2025-02-17 03:35:21 +00:00
videoparsers: add new mpegvideoparse
This commit is contained in:
Mark Nauwelaerts
parent
9c0547b15c
commit
6f5a3ecfa7
6 changed files with 1085 additions and 2 deletions
|
|
@ -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 \
|
||||
|
|
|
|||
656
gst/videoparsers/gstmpegvideoparse.c
Normal file
656
gst/videoparsers/gstmpegvideoparse.c
Normal file
|
|
@ -0,0 +1,656 @@
|
|||
/* GStreamer
|
||||
* Copyright (C) <2007> Jan Schmidt <thaytan@mad.scientist.com>
|
||||
* Copyright (C) <2011> Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>
|
||||
* 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 <string.h>
|
||||
#include <gst/base/gstbytereader.h>
|
||||
|
||||
#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 <wim.taymans@ccollabora.co.uk>, "
|
||||
"Jan Schmidt <thaytan@mad.scientist.com>, "
|
||||
"Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>");
|
||||
|
||||
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;
|
||||
}
|
||||
75
gst/videoparsers/gstmpegvideoparse.h
Normal file
75
gst/videoparsers/gstmpegvideoparse.h
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
/* GStreamer
|
||||
* Copyright (C) <2007> Jan Schmidt <thaytan@mad.scientist.com>
|
||||
* Copyright (C) <2011> Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>
|
||||
* 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 <gst/gst.h>
|
||||
#include <gst/base/gstbaseparse.h>
|
||||
|
||||
#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__ */
|
||||
270
gst/videoparsers/mpegvideoparse.c
Normal file
270
gst/videoparsers/mpegvideoparse.c
Normal file
|
|
@ -0,0 +1,270 @@
|
|||
/* GStreamer
|
||||
* Copyright (C) <2007> Jan Schmidt <thaytan@mad.scientist.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif
|
||||
|
||||
#include "mpegvideoparse.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <gst/base/gstbitreader.h>
|
||||
|
||||
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);
|
||||
}
|
||||
77
gst/videoparsers/mpegvideoparse.h
Normal file
77
gst/videoparsers/mpegvideoparse.h
Normal file
|
|
@ -0,0 +1,77 @@
|
|||
/* GStreamer
|
||||
* Copyright (C) <2007> Jan Schmidt <thaytan@mad.scientist.com>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __GST_MPEGVIDEO_PARAMS_H__
|
||||
#define __GST_MPEGVIDEO_PARAMS_H__
|
||||
|
||||
#include <gst/gst.h>
|
||||
|
||||
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
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue