mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-07-03 21:25:54 +00:00
Code Issues 1 Projects Releases Wiki Activity

rawparse: Remove old parser code and wrap new parsers in old elements

Browse source 
https://bugzilla.gnome.org/show_bug.cgi?id=767011
This commit is contained in:
Carlos Rafael Giani 2016-07-25 17:54:09 +02:00 committed by Sebastian Dröge
parent d555f34562
commit 403499a0c0
7 changed files with 382 additions and 1891 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
gst/rawparse/Makefile.am
View file

@ -2,7 +2,6 @@
plugin_LTLIBRARIES = libgstrawparse.la
libgstrawparse_la_SOURCES = \
gstrawparse.c \
gstunalignedaudioparse.c \
gstunalignedvideoparse.c \
gstaudioparse.c \
@ -29,7 +28,6 @@ noinst_HEADERS = \
gstunalignedaudioparse.h \
gstunalignedvideoparse.h \
gstaudioparse.h \
gstrawparse.h \
gstvideoparse.h \
gstrawbaseparse.h \
gstrawaudioparse.h \

443
gst/rawparse/gstaudioparse.c
View file

@ -22,6 +22,8 @@
* SECTION:element-audioparse
*
* Converts a byte stream into audio frames.
*
* <note>This element is deprecated. Use #GstRawAudioParse instead.</note>
*/
#ifdef HAVE_CONFIG_H
@ -32,11 +34,34 @@
* for now with newer GLib versions (>= 2.31.0) */
#define GLIB_DISABLE_DEPRECATION_WARNINGS
#include <gst/gst.h>
#include <gst/audio/audio.h>
#include "gstaudioparse.h"
#include "gstrawaudioparse.h"
#include "unalignedaudio.h"
#include <string.h>
static GstStaticPadTemplate static_sink_template =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY);
static GstStaticPadTemplate static_src_template =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (GST_AUDIO_CAPS_MAKE (GST_AUDIO_FORMATS_ALL)
", layout = (string) { interleaved, non-interleaved }; "
GST_UNALIGNED_RAW_AUDIO_CAPS "; "
"audio/x-alaw, rate=(int)[1,MAX], channels=(int)[1,MAX]; "
"audio/x-mulaw, rate=(int)[1,MAX], channels=(int)[1,MAX]")
);
typedef enum
{
GST_AUDIO_PARSE_FORMAT_RAW,
@ -44,21 +69,10 @@ typedef enum
GST_AUDIO_PARSE_FORMAT_ALAW
} GstAudioParseFormat;
typedef enum
{
GST_AUDIO_PARSE_ENDIANNESS_LITTLE = 1234,
GST_AUDIO_PARSE_ENDIANNESS_BIG = 4321
} GstAudioParseEndianness;
static void gst_audio_parse_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_audio_parse_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void gst_audio_parse_finalize (GObject * object);
static GstCaps *gst_audio_parse_get_caps (GstRawParse * rp);
static void gst_audio_parse_update_frame_size (GstAudioParse * ap);
GST_DEBUG_CATEGORY_STATIC (gst_audio_parse_debug);
#define GST_CAT_DEFAULT gst_audio_parse_debug
@ -97,21 +111,16 @@ gst_audio_parse_format_get_type (void)
#define gst_audio_parse_parent_class parent_class
G_DEFINE_TYPE (GstAudioParse, gst_audio_parse, GST_TYPE_RAW_PARSE);
G_DEFINE_TYPE (GstAudioParse, gst_audio_parse, GST_TYPE_BIN);
static void
gst_audio_parse_class_init (GstAudioParseClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
GstRawParseClass *rp_class = GST_RAW_PARSE_CLASS (klass);
GstCaps *caps;
gobject_class->set_property = gst_audio_parse_set_property;
gobject_class->get_property = gst_audio_parse_get_property;
gobject_class->finalize = gst_audio_parse_finalize;
rp_class->get_caps = gst_audio_parse_get_caps;
g_object_class_install_property (gobject_class, PROP_FORMAT,
g_param_spec_enum ("format", "Format",
@ -155,18 +164,13 @@ gst_audio_parse_class_init (GstAudioParseClass * klass)
gst_element_class_set_static_metadata (gstelement_class, "Audio Parse",
"Filter/Audio",
"Converts stream into audio frames",
"Converts stream into audio frames (deprecated: use rawaudioparse instead)",
"Sebastian Dröge <sebastian.droege@collabora.co.uk>");
caps = gst_caps_from_string (GST_AUDIO_CAPS_MAKE (GST_AUDIO_FORMATS_ALL)
", layout = (string) { interleaved, non-interleaved }; "
GST_UNALIGNED_RAW_AUDIO_CAPS "; "
"audio/x-alaw, rate=(int)[1,MAX], channels=(int)[1,MAX]; "
"audio/x-mulaw, rate=(int)[1,MAX], channels=(int)[1,MAX]");
gst_raw_parse_class_set_src_pad_template (rp_class, caps);
gst_raw_parse_class_set_multiple_frames_per_buffer (rp_class, TRUE);
gst_caps_unref (caps);
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&static_sink_template));
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&static_src_template));
GST_DEBUG_CATEGORY_INIT (gst_audio_parse_debug, "audioparse", 0,
"audioparse element");
@ -175,13 +179,28 @@ gst_audio_parse_class_init (GstAudioParseClass * klass)
static void
gst_audio_parse_init (GstAudioParse * ap)
{
ap->format = GST_AUDIO_PARSE_FORMAT_RAW;
ap->raw_format = GST_AUDIO_FORMAT_S16;
ap->channels = 2;
ap->interleaved = TRUE;
GstPad *inner_pad;
GstPad *ghostpad;
gst_audio_parse_update_frame_size (ap);
gst_raw_parse_set_fps (GST_RAW_PARSE (ap), 44100, 1);
ap->rawaudioparse =
gst_element_factory_make ("rawaudioparse", "inner_rawaudioparse");
g_assert (ap->rawaudioparse != NULL);
gst_bin_add (GST_BIN (ap), ap->rawaudioparse);
inner_pad = gst_element_get_static_pad (ap->rawaudioparse, "sink");
ghostpad =
gst_ghost_pad_new_from_template ("sink", inner_pad,
gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (ap), "sink"));
gst_element_add_pad (GST_ELEMENT (ap), ghostpad);
gst_object_unref (GST_OBJECT (inner_pad));
inner_pad = gst_element_get_static_pad (ap->rawaudioparse, "src");
ghostpad =
gst_ghost_pad_new_from_template ("src", inner_pad,
gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (ap), "src"));
gst_element_add_pad (GST_ELEMENT (ap), ghostpad);
gst_object_unref (GST_OBJECT (inner_pad));
}
static void
@ -190,39 +209,68 @@ gst_audio_parse_set_property (GObject * object, guint prop_id,
{
GstAudioParse *ap = GST_AUDIO_PARSE (object);
g_return_if_fail (!gst_raw_parse_is_negotiated (GST_RAW_PARSE (ap)));
switch (prop_id) {
case PROP_FORMAT:
ap->format = g_value_get_enum (value);
break;
case PROP_RAW_FORMAT:
ap->raw_format = g_value_get_enum (value);
break;
case PROP_RATE:
gst_raw_parse_set_fps (GST_RAW_PARSE (ap), g_value_get_int (value), 1);
break;
case PROP_CHANNELS:
ap->channels = g_value_get_int (value);
break;
case PROP_INTERLEAVED:
ap->interleaved = g_value_get_boolean (value);
break;
case PROP_CHANNEL_POSITIONS:
if (ap->channel_positions)
g_value_array_free (ap->channel_positions);
case PROP_FORMAT:{
GstRawAudioParseFormat raw_parse_format;
switch (g_value_get_enum (value)) {
case GST_AUDIO_PARSE_FORMAT_RAW:
raw_parse_format = GST_RAW_AUDIO_PARSE_FORMAT_PCM;
break;
case GST_AUDIO_PARSE_FORMAT_MULAW:
raw_parse_format = GST_RAW_AUDIO_PARSE_FORMAT_MULAW;
break;
case GST_AUDIO_PARSE_FORMAT_ALAW:
raw_parse_format = GST_RAW_AUDIO_PARSE_FORMAT_ALAW;
break;
default:
g_assert_not_reached ();
break;
}
g_object_set (G_OBJECT (ap->rawaudioparse), "format", raw_parse_format,
NULL);
ap->channel_positions = g_value_dup_boxed (value);
break;
}
case PROP_RAW_FORMAT:
g_object_set (G_OBJECT (ap->rawaudioparse), "pcm-format",
g_value_get_enum (value), NULL);
break;
case PROP_RATE:
g_object_set (G_OBJECT (ap->rawaudioparse), "sample-rate",
g_value_get_int (value), NULL);
break;
case PROP_CHANNELS:
g_object_set (G_OBJECT (ap->rawaudioparse), "num-channels",
g_value_get_int (value), NULL);
break;
case PROP_INTERLEAVED:
g_object_set (G_OBJECT (ap->rawaudioparse), "interleaved",
g_value_get_boolean (value), NULL);
break;
case PROP_CHANNEL_POSITIONS:
g_object_set (G_OBJECT (ap->rawaudioparse), "channel-positions",
g_value_get_boxed (value), NULL);
break;
case PROP_USE_SINK_CAPS:
ap->use_sink_caps = g_value_get_boolean (value);
g_object_set (G_OBJECT (ap->rawaudioparse), "use-sink-caps",
g_value_get_boolean (value), NULL);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
gst_audio_parse_update_frame_size (ap);
}
static void
@ -232,226 +280,85 @@ gst_audio_parse_get_property (GObject * object, guint prop_id, GValue * value,
GstAudioParse *ap = GST_AUDIO_PARSE (object);
switch (prop_id) {
case PROP_FORMAT:
g_value_set_enum (value, ap->format);
break;
case PROP_RAW_FORMAT:
g_value_set_enum (value, ap->raw_format);
break;
case PROP_RATE:{
gint fps_n, fps_d;
case PROP_FORMAT:{
GstRawAudioParseFormat raw_parse_format;
GstAudioParseFormat format;
g_object_get (G_OBJECT (ap->rawaudioparse), "format", &raw_parse_format,
NULL);
switch (raw_parse_format) {
case GST_RAW_AUDIO_PARSE_FORMAT_PCM:
format = GST_AUDIO_PARSE_FORMAT_RAW;
break;
case GST_RAW_AUDIO_PARSE_FORMAT_MULAW:
format = GST_AUDIO_PARSE_FORMAT_MULAW;
break;
case GST_RAW_AUDIO_PARSE_FORMAT_ALAW:
format = GST_AUDIO_PARSE_FORMAT_ALAW;
break;
default:
g_assert_not_reached ();
break;
}
g_value_set_enum (value, format);
gst_raw_parse_get_fps (GST_RAW_PARSE (ap), &fps_n, &fps_d);
g_value_set_int (value, fps_n);
break;
}
case PROP_CHANNELS:
g_value_set_int (value, ap->channels);
case PROP_RAW_FORMAT:{
GstAudioFormat format;
g_object_get (G_OBJECT (ap->rawaudioparse), "pcm-format", &format, NULL);
g_value_set_enum (value, format);
break;
case PROP_INTERLEAVED:
g_value_set_boolean (value, ap->interleaved);
}
case PROP_RATE:{
gint sample_rate;
g_object_get (G_OBJECT (ap->rawaudioparse), "sample-rate", &sample_rate,
NULL);
g_value_set_int (value, sample_rate);
break;
case PROP_CHANNEL_POSITIONS:
g_value_set_boxed (value, ap->channel_positions);
}
case PROP_CHANNELS:{
gint num_channels;
g_object_get (G_OBJECT (ap->rawaudioparse), "num-channels", &num_channels,
NULL);
g_value_set_int (value, num_channels);
break;
case PROP_USE_SINK_CAPS:
g_value_set_boolean (value, ap->use_sink_caps);
}
case PROP_INTERLEAVED:{
gboolean interleaved;
g_object_get (G_OBJECT (ap->rawaudioparse), "interleaved", &interleaved,
NULL);
g_value_set_boolean (value, interleaved);
break;
}
case PROP_CHANNEL_POSITIONS:{
gpointer channel_positions;
g_object_get (G_OBJECT (ap->rawaudioparse), "channel-positions",
&channel_positions, NULL);
g_value_set_boxed (value, channel_positions);
break;
}
case PROP_USE_SINK_CAPS:{
gboolean use_sink_caps;
g_object_get (G_OBJECT (ap->rawaudioparse), "use-sink-caps",
&use_sink_caps, NULL);
g_value_set_boolean (value, use_sink_caps);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_audio_parse_finalize (GObject * object)
{
GstAudioParse *ap = GST_AUDIO_PARSE (object);
if (ap->channel_positions) {
g_value_array_free (ap->channel_positions);
ap->channel_positions = NULL;
}
g_free (ap->channel_pos);
g_free (ap->channel_order);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
void
gst_audio_parse_update_frame_size (GstAudioParse * ap)
{
gint framesize, width;
switch (ap->format) {
case GST_AUDIO_PARSE_FORMAT_ALAW:
case GST_AUDIO_PARSE_FORMAT_MULAW:
width = 8;
break;
case GST_AUDIO_PARSE_FORMAT_RAW:
default:
{
GstAudioInfo info;
gst_audio_info_init (&info);
/* rate, etc do not really matter here */
gst_audio_info_set_format (&info, ap->raw_format, 44100, ap->channels,
NULL);
width = GST_AUDIO_INFO_WIDTH (&info);
break;
}
}
framesize = (width / 8) * ap->channels;
gst_raw_parse_set_framesize (GST_RAW_PARSE (ap), framesize);
}
static GstAudioChannelPosition *
gst_audio_parse_get_channel_positions (GValueArray * positions)
{
gint i;
guint channels;
GstAudioChannelPosition *pos;
channels = positions->n_values;
pos = g_new (GstAudioChannelPosition, positions->n_values);
for (i = 0; i < channels; i++) {
GValue *v = g_value_array_get_nth (positions, i);
pos[i] = g_value_get_enum (v);
}
return pos;
}
static void
gst_audio_parse_setup_channel_positions (GstAudioParse * ap)
{
GstAudioChannelPosition *pos, *to;
g_free (ap->channel_pos);
g_free (ap->channel_order);
ap->channel_pos = NULL;
ap->channel_order = NULL;
if (!ap->channel_positions) {
GST_DEBUG_OBJECT (ap, "no channel positions");
/* implicit mapping for 1- and 2-channel audio is okay */
/* will come up with one in other cases also */
return;
}
pos = gst_audio_parse_get_channel_positions (ap->channel_positions);
if (ap->channels != ap->channel_positions->n_values ||
!gst_audio_check_valid_channel_positions (pos, ap->channels, FALSE)) {
GST_DEBUG_OBJECT (ap, "invalid channel position");
g_free (pos);
return;
}
/* ok, got something we can work with now */
to = g_new (GstAudioChannelPosition, ap->channels);
memcpy (to, pos, ap->channels * sizeof (to[0]));
gst_audio_channel_positions_to_valid_order (to, ap->channels);
ap->channel_pos = pos;
ap->channel_order = to;
}
static GstCaps *
gst_audio_parse_get_caps (GstRawParse * rp)
{
GstAudioParse *ap = GST_AUDIO_PARSE (rp);
GstCaps *caps, *ncaps;
GstAudioInfo info;
gint fps_n, fps_d;
const GValue *val;
if (ap->use_sink_caps) {
gint rate;
GstCaps *caps = gst_pad_get_current_caps (rp->sinkpad);
GstStructure *structure;
if (!caps) {
GST_WARNING_OBJECT (ap,
"Sink pad has no caps, but we were asked to use its caps");
return NULL;
}
/* For unaligned raw data, the output caps stay the same,
* except that audio/x-unaligned-raw becomes audio/x-raw,
* since audioparse aligns the sample data */
structure = gst_caps_get_structure (caps, 0);
if (gst_structure_has_name (structure, "audio/x-unaligned-raw")) {
caps = gst_caps_make_writable (caps);
structure = gst_caps_get_structure (caps, 0);
gst_structure_set_name (structure, "audio/x-raw");
}
if (!gst_audio_info_from_caps (&info, caps)) {
GST_WARNING_OBJECT (ap, "Failed to parse caps %" GST_PTR_FORMAT, caps);
gst_caps_unref (caps);
return NULL;
}
ap->format = GST_AUDIO_PARSE_FORMAT_RAW;
ap->raw_format = GST_AUDIO_INFO_FORMAT (&info);
ap->channels = GST_AUDIO_INFO_CHANNELS (&info);
ap->interleaved = info.layout == GST_AUDIO_LAYOUT_INTERLEAVED;
rate = GST_AUDIO_INFO_RATE (&info);
gst_raw_parse_set_fps (GST_RAW_PARSE (ap), rate, 1);
gst_audio_parse_update_frame_size (ap);
return caps;
}
gst_raw_parse_get_fps (rp, &fps_n, &fps_d);
gst_audio_parse_setup_channel_positions (ap);
/* yes, even when format not raw */
gst_audio_info_init (&info);
gst_audio_info_set_format (&info, ap->raw_format, fps_n, ap->channels,
ap->channel_order);
info.layout = ap->interleaved ? GST_AUDIO_LAYOUT_INTERLEAVED :
GST_AUDIO_LAYOUT_NON_INTERLEAVED;
caps = gst_audio_info_to_caps (&info);
switch (ap->format) {
case GST_AUDIO_PARSE_FORMAT_RAW:
break;
case GST_AUDIO_PARSE_FORMAT_ALAW:
ncaps = gst_caps_new_simple ("audio/x-alaw",
"rate", G_TYPE_INT, fps_n,
"channels", G_TYPE_INT, ap->channels, NULL);
/* pick mask stuff from faked raw format */
val = gst_structure_get_value (gst_caps_get_structure (caps, 0),
"channel-mask");
if (val)
gst_caps_set_value (ncaps, "channel-mask", val);
gst_caps_unref (caps);
caps = ncaps;
break;
case GST_AUDIO_PARSE_FORMAT_MULAW:
ncaps = gst_caps_new_simple ("audio/x-mulaw",
"rate", G_TYPE_INT, fps_n,
"channels", G_TYPE_INT, ap->channels, NULL);
/* pick mask stuff from faked raw format */
val = gst_structure_get_value (gst_caps_get_structure (caps, 0),
"channel-mask");
if (val)
gst_caps_set_value (ncaps, "channel-mask", val);
gst_caps_unref (caps);
caps = ncaps;
break;
default:
caps = gst_caps_new_empty ();
GST_ERROR_OBJECT (rp, "unexpected format %d", ap->format);
break;
}
return caps;
}

21
gst/rawparse/gstaudioparse.h
View file

@ -23,11 +23,6 @@
#define __GST_AUDIO_PARSE_H__
#include <gst/gst.h>
#include <gst/base/gstbasetransform.h>
#include <gst/base/gstadapter.h>
#include <gst/audio/audio.h>
#include "gstrawparse.h"
#define GST_TYPE_AUDIO_PARSE \
(gst_audio_parse_get_type())
@ -45,23 +40,13 @@ typedef struct _GstAudioParseClass GstAudioParseClass;
struct _GstAudioParse
{
GstRawParse parent;
/* properties */
gboolean use_sink_caps;
gint format;
GstAudioFormat raw_format;
gint channels;
gboolean interleaved;
GValueArray *channel_positions;
GstAudioChannelPosition *channel_pos;
GstAudioChannelPosition *channel_order;
GstBin parent;
GstElement *rawaudioparse;
};
struct _GstAudioParseClass
{
GstRawParseClass parent_class;
GstBinClass parent_class;
};

1105
gst/rawparse/gstrawparse.c
View file

File diff suppressed because it is too large Load diff

98
gst/rawparse/gstrawparse.h
View file

@ -1,98 +0,0 @@
/* GStreamer
* Copyright (C) 2006 David A. Schleef <ds@schleef.org>
* Copyright (C) 2007 Sebastian Dröge <slomo@circular-chaos.org>
*
* gstrawparse.h:
*
* 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., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __GST_RAW_PARSE_H__
#define __GST_RAW_PARSE_H__
#include <gst/gst.h>
#include <gst/base/gstbasetransform.h>
#include <gst/base/gstadapter.h>
G_BEGIN_DECLS
#define GST_TYPE_RAW_PARSE \
(gst_raw_parse_get_type())
#define GST_RAW_PARSE(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RAW_PARSE,GstRawParse))
#define GST_RAW_PARSE_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RAW_PARSE,GstRawParseClass))
#define GST_RAW_PARSE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),GST_TYPE_RAW_PARSE,GstRawParseClass))
#define GST_IS_RAW_PARSE(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RAW_PARSE))
#define GST_IS_RAW_PARSE_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RAW_PARSE))
typedef struct _GstRawParse GstRawParse;
typedef struct _GstRawParseClass GstRawParseClass;
struct _GstRawParse
{
GstElement parent;
/* <private> */
GstPad *sinkpad;
GstPad *srcpad;
GstPadMode mode;
GstAdapter *adapter;
gint framesize;
gint fps_d;
gint fps_n;
gboolean discont;
guint64 n_frames;
gint64 upstream_length;
gint64 offset;
GstSegment segment;
GstEvent *start_segment;
gboolean negotiated;
gboolean push_stream_start;
};
struct _GstRawParseClass
{
GstElementClass parent_class;
GstCaps * (*get_caps) (GstRawParse *rp);
void (*pre_push_buffer) (GstRawParse *rp, GstBuffer *buffer);
void (*decide_allocation) (GstRawParse *rp, GstQuery *query);
gboolean multiple_frames_per_buffer;
};
GType gst_raw_parse_get_type (void);
void gst_raw_parse_class_set_src_pad_template (GstRawParseClass *klass, const GstCaps * allowed_caps);
void gst_raw_parse_class_set_multiple_frames_per_buffer (GstRawParseClass *klass, gboolean multiple_frames);
void gst_raw_parse_set_framesize (GstRawParse *rp, int framesize);
void gst_raw_parse_set_fps (GstRawParse *rp, int fps_n, int fps_d);
void gst_raw_parse_get_fps (GstRawParse *rp, int *fps_n, int *fps_d);
gboolean gst_raw_parse_is_negotiated (GstRawParse *rp);
G_END_DECLS
#endif /* __GST_RAW_PARSE_H__ */

577
gst/rawparse/gstvideoparse.c
View file

@ -23,28 +23,47 @@
* SECTION:element-videoparse
*
* Converts a byte stream into video frames.
*
* <note>This element is deprecated. Use #GstRawVideoParse instead.</note>
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
/* FIXME 0.11: suppress warnings for deprecated API such as g_value_array stuff
* for now with newer GLib versions (>= 2.31.0) */
#define GLIB_DISABLE_DEPRECATION_WARNINGS
#include <gst/gst.h>
#include <gst/audio/audio.h>
#include "gstvideoparse.h"
#include "gstrawvideoparse.h"
static GstStaticPadTemplate static_sink_template =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY);
static GstStaticPadTemplate static_src_template =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("video/x-raw")
);
static void gst_video_parse_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_video_parse_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static GstCaps *gst_video_parse_get_caps (GstRawParse * rp);
static void gst_video_parse_pre_push_buffer (GstRawParse * rp,
GstBuffer * buffer);
static void gst_video_parse_decide_allocation (GstRawParse * rp,
GstQuery * query);
static void gst_video_parse_update_info (GstVideoParse * vp);
static gboolean gst_video_parse_deserialize_int_array (const gchar * str,
gint * dest, guint n_values);
static GValueArray *gst_video_parse_int_valarray_from_string (const gchar *
str);
static gchar *gst_video_parse_int_valarray_to_string (GValueArray * valarray);
GST_DEBUG_CATEGORY_STATIC (gst_video_parse_debug);
#define GST_CAT_DEFAULT gst_video_parse_debug
@ -65,23 +84,17 @@ enum
};
#define gst_video_parse_parent_class parent_class
G_DEFINE_TYPE (GstVideoParse, gst_video_parse, GST_TYPE_RAW_PARSE);
G_DEFINE_TYPE (GstVideoParse, gst_video_parse, GST_TYPE_BIN);
static void
gst_video_parse_class_init (GstVideoParseClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
GstRawParseClass *rp_class = GST_RAW_PARSE_CLASS (klass);
GstCaps *caps;
gobject_class->set_property = gst_video_parse_set_property;
gobject_class->get_property = gst_video_parse_get_property;
rp_class->get_caps = gst_video_parse_get_caps;
rp_class->pre_push_buffer = gst_video_parse_pre_push_buffer;
rp_class->decide_allocation = gst_video_parse_decide_allocation;
g_object_class_install_property (gobject_class, PROP_FORMAT,
g_param_spec_enum ("format", "Format", "Format of images in raw stream",
GST_TYPE_VIDEO_FORMAT, GST_VIDEO_FORMAT_I420,
@ -123,15 +136,14 @@ gst_video_parse_class_init (GstVideoParseClass * klass)
gst_element_class_set_static_metadata (gstelement_class, "Video Parse",
"Filter/Video",
"Converts stream into video frames",
"Converts stream into video frames (deprecated: use rawvideoparse instead)",
"David Schleef <ds@schleef.org>, "
"Sebastian Dröge <sebastian.droege@collabora.co.uk>");
caps = gst_caps_from_string ("video/x-raw; video/x-bayer");
gst_raw_parse_class_set_src_pad_template (rp_class, caps);
gst_raw_parse_class_set_multiple_frames_per_buffer (rp_class, FALSE);
gst_caps_unref (caps);
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&static_sink_template));
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&static_src_template));
GST_DEBUG_CATEGORY_INIT (gst_video_parse_debug, "videoparse", 0,
"videoparse element");
@ -140,14 +152,28 @@ gst_video_parse_class_init (GstVideoParseClass * klass)
static void
gst_video_parse_init (GstVideoParse * vp)
{
vp->width = 320;
vp->height = 240;
vp->format = GST_VIDEO_FORMAT_I420;
vp->par_n = 1;
vp->par_d = 1;
GstPad *inner_pad;
GstPad *ghostpad;
gst_raw_parse_set_fps (GST_RAW_PARSE (vp), 25, 1);
gst_video_parse_update_info (vp);
vp->rawvideoparse =
gst_element_factory_make ("rawvideoparse", "inner_rawvideoparse");
g_assert (vp->rawvideoparse != NULL);
gst_bin_add (GST_BIN (vp), vp->rawvideoparse);
inner_pad = gst_element_get_static_pad (vp->rawvideoparse, "sink");
ghostpad =
gst_ghost_pad_new_from_template ("sink", inner_pad,
gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (vp), "sink"));
gst_element_add_pad (GST_ELEMENT (vp), ghostpad);
gst_object_unref (GST_OBJECT (inner_pad));
inner_pad = gst_element_get_static_pad (vp->rawvideoparse, "src");
ghostpad =
gst_ghost_pad_new_from_template ("src", inner_pad,
gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (vp), "src"));
gst_element_add_pad (GST_ELEMENT (vp), ghostpad);
gst_object_unref (GST_OBJECT (inner_pad));
}
static void
@ -156,62 +182,83 @@ gst_video_parse_set_property (GObject * object, guint prop_id,
{
GstVideoParse *vp = GST_VIDEO_PARSE (object);
g_return_if_fail (!gst_raw_parse_is_negotiated (GST_RAW_PARSE (vp)));
switch (prop_id) {
case PROP_FORMAT:
vp->format = g_value_get_enum (value);
g_object_set (G_OBJECT (vp->rawvideoparse), "format",
g_value_get_enum (value), NULL);
break;
case PROP_WIDTH:
vp->width = g_value_get_int (value);
g_object_set (G_OBJECT (vp->rawvideoparse), "width",
g_value_get_int (value), NULL);
break;
case PROP_HEIGHT:
vp->height = g_value_get_int (value);
g_object_set (G_OBJECT (vp->rawvideoparse), "height",
g_value_get_int (value), NULL);
break;
case PROP_FRAMERATE:
gst_raw_parse_set_fps (GST_RAW_PARSE (vp),
g_object_set (G_OBJECT (vp->rawvideoparse), "framerate",
gst_value_get_fraction_numerator (value),
gst_value_get_fraction_denominator (value));
gst_value_get_fraction_denominator (value), NULL);
break;
case PROP_PAR:
vp->par_n = gst_value_get_fraction_numerator (value);
vp->par_d = gst_value_get_fraction_denominator (value);
g_object_set (G_OBJECT (vp->rawvideoparse), "pixel-aspect-ratio",
gst_value_get_fraction_numerator (value),
gst_value_get_fraction_denominator (value), NULL);
break;
case PROP_INTERLACED:
vp->interlaced = g_value_get_boolean (value);
g_object_set (G_OBJECT (vp->rawvideoparse), "interlaced",
g_value_get_boolean (value), NULL);
break;
case PROP_TOP_FIELD_FIRST:
vp->top_field_first = g_value_get_boolean (value);
g_object_set (G_OBJECT (vp->rawvideoparse), "top-field-first",
g_value_get_boolean (value), NULL);
break;
case PROP_STRIDES:
if (gst_video_parse_deserialize_int_array (g_value_get_string (value),
vp->stride, GST_VIDEO_MAX_PLANES)) {
vp->stride_set = TRUE;
case PROP_STRIDES:{
GValueArray *valarray =
gst_video_parse_int_valarray_from_string (g_value_get_string (value));
if (valarray != NULL) {
g_object_set (G_OBJECT (vp->rawvideoparse), "plane-strides",
valarray, NULL);
g_value_array_free (valarray);
} else {
GST_WARNING_OBJECT (vp, "failed to deserialize given strides");
vp->stride_set = FALSE;
}
break;
case PROP_OFFSETS:
if (gst_video_parse_deserialize_int_array (g_value_get_string (value),
vp->offset, GST_VIDEO_MAX_PLANES)) {
vp->offset_set = TRUE;
}
case PROP_OFFSETS:{
GValueArray *valarray =
gst_video_parse_int_valarray_from_string (g_value_get_string (value));
if (valarray != NULL) {
g_object_set (G_OBJECT (vp->rawvideoparse), "plane-offsets",
valarray, NULL);
g_value_array_free (valarray);
} else {
GST_WARNING_OBJECT (vp, "failed to deserialized given offsets");
vp->offset_set = FALSE;
GST_WARNING_OBJECT (vp, "failed to deserialize given offsets");
}
break;
}
case PROP_FRAMESIZE:
vp->framesize = g_value_get_uint (value);
g_object_set (G_OBJECT (vp->rawvideoparse), "frame-stride",
g_value_get_uint (value), NULL);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
gst_video_parse_update_info (vp);
}
static void
@ -221,377 +268,155 @@ gst_video_parse_get_property (GObject * object, guint prop_id, GValue * value,
GstVideoParse *vp = GST_VIDEO_PARSE (object);
switch (prop_id) {
case PROP_FORMAT:
g_value_set_enum (value, vp->format);
case PROP_FORMAT:{
GstVideoFormat format;
g_object_get (G_OBJECT (vp->rawvideoparse), "format", &format, NULL);
g_value_set_enum (value, format);
break;
case PROP_WIDTH:
g_value_set_int (value, vp->width);
}
case PROP_WIDTH:{
gint width;
g_object_get (G_OBJECT (vp->rawvideoparse), "width", &width, NULL);
g_value_set_int (value, width);
break;
case PROP_HEIGHT:
g_value_set_int (value, vp->height);
}
case PROP_HEIGHT:{
gint height;
g_object_get (G_OBJECT (vp->rawvideoparse), "height", &height, NULL);
g_value_set_int (value, height);
break;
}
case PROP_FRAMERATE:{
gint fps_n, fps_d;
gst_raw_parse_get_fps (GST_RAW_PARSE (vp), &fps_n, &fps_d);
g_object_get (G_OBJECT (vp->rawvideoparse), "framerate", &fps_n, &fps_d,
NULL);
gst_value_set_fraction (value, fps_n, fps_d);
break;
}
case PROP_PAR:
gst_value_set_fraction (value, vp->par_n, vp->par_d);
break;
case PROP_INTERLACED:
g_value_set_boolean (value, vp->interlaced);
break;
case PROP_TOP_FIELD_FIRST:
g_value_set_boolean (value, vp->top_field_first);
break;
case PROP_STRIDES:
{
gchar *tmp;
tmp = g_strdup_printf ("%d,%d,%d,%d", vp->info.stride[0],
vp->info.stride[1], vp->info.stride[2], vp->info.stride[3]);
g_value_set_string (value, tmp);
g_free (tmp);
case PROP_PAR:{
gint par_n, par_d;
g_object_get (G_OBJECT (vp->rawvideoparse), "pixel-aspect-ratio", &par_n,
&par_d, NULL);
gst_value_set_fraction (value, par_n, par_d);
break;
}
case PROP_OFFSETS:
{
gchar *tmp;
tmp = g_strdup_printf ("%" G_GSIZE_FORMAT ",%" G_GSIZE_FORMAT
",%" G_GSIZE_FORMAT ",%" G_GSIZE_FORMAT, vp->info.offset[0],
vp->info.offset[1], vp->info.offset[2], vp->info.offset[3]);
g_value_set_string (value, tmp);
g_free (tmp);
case PROP_INTERLACED:{
gboolean interlaced;
g_object_get (G_OBJECT (vp->rawvideoparse), "interlaced", &interlaced,
NULL);
g_value_set_boolean (value, interlaced);
break;
}
case PROP_FRAMESIZE:
g_value_set_uint (value, vp->info.size);
case PROP_TOP_FIELD_FIRST:{
gboolean top_field_first;
g_object_get (G_OBJECT (vp->rawvideoparse), "top-field-first",
&top_field_first, NULL);
g_value_set_boolean (value, top_field_first);
break;
}
case PROP_STRIDES:{
GValueArray *array;
g_object_get (G_OBJECT (vp->rawvideoparse), "plane-strides", &array,
NULL);
g_value_take_string (value,
gst_video_parse_int_valarray_to_string (array));
break;
}
case PROP_OFFSETS:{
GValueArray *array;
g_object_get (G_OBJECT (vp->rawvideoparse), "plane-offsets", &array,
NULL);
g_value_take_string (value,
gst_video_parse_int_valarray_to_string (array));
break;
}
case PROP_FRAMESIZE:{
guint frame_stride;
g_object_get (G_OBJECT (vp->rawvideoparse), "frame-stride", &frame_stride,
NULL);
g_value_set_uint (value, frame_stride);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_video_parse_deserialize_int_array (const gchar * str, gint * dest,
guint n_values)
static GValueArray *
gst_video_parse_int_valarray_from_string (const gchar * str)
{
gchar **strv;
guint length;
guint i;
GValueArray *valarray;
GValue gvalue = G_VALUE_INIT;
strv = g_strsplit (str, ",", n_values);
if (str == NULL)
return NULL;
strv = g_strsplit (str, ",", GST_VIDEO_MAX_PLANES);
if (strv == NULL)
return FALSE;
return NULL;
length = g_strv_length (strv);
valarray = g_value_array_new (length);
g_value_init (&gvalue, G_TYPE_UINT);
for (i = 0; i < length; i++) {
gint64 val;
val = g_ascii_strtoll (strv[i], NULL, 10);
if (val < G_MININT || val > G_MAXINT) {
g_strfreev (strv);
return FALSE;
goto error;
}
dest[i] = val;
g_value_set_uint (&gvalue, val);
g_value_array_insert (valarray, i, &gvalue);
}
/* fill remaining values with 0 */
for (i = length; i < n_values; i++)
dest[i] = 0;
finish:
g_strfreev (strv);
return valarray;
return TRUE;
error:
g_value_array_free (valarray);
valarray = NULL;
goto finish;
}
static inline gsize
gst_video_parse_get_plane_size (GstVideoInfo * info, guint plane)
static gchar *
gst_video_parse_int_valarray_to_string (GValueArray * valarray)
{
gsize size = 0;
if (GST_VIDEO_FORMAT_INFO_IS_TILED (info->finfo)) {
gint tile_width, tile_height, x_tiles, y_tiles;
tile_width = 1 << GST_VIDEO_FORMAT_INFO_TILE_WS (info->finfo);
tile_height = 1 << GST_VIDEO_FORMAT_INFO_TILE_HS (info->finfo);
x_tiles = GST_VIDEO_TILE_X_TILES (info->stride[plane]);
y_tiles = GST_VIDEO_TILE_Y_TILES (info->stride[plane]);
/* plane size is the size of one tile multiplied by the number of tiles */
size = tile_width * tile_height * x_tiles * y_tiles;
} else {
size = info->stride[plane] *
GST_VIDEO_FORMAT_INFO_SCALE_HEIGHT (info->finfo, plane, info->height);
}
return size;
}
static gboolean
gst_video_parse_update_stride (GstVideoParse * vp)
{
GstVideoInfo *info = &vp->info;
/* holds a 64-bit number as string, which can have max. 20 digits
* (with extra char for nullbyte) */
gchar stride_str[21];
gchar *str = NULL;
guint i;
/* 1. check that provided strides are greater than the default ones */
for (i = 0; i < GST_VIDEO_INFO_N_PLANES (info); i++) {
if (GST_VIDEO_FORMAT_INFO_IS_TILED (info->finfo)) {
/* for tiled format, make sure there is more tiles than default */
gint default_x_tiles, default_y_tiles, x_tiles, y_tiles;
for (i = 0; i < valarray->n_values; i++) {
GValue *gvalue = g_value_array_get_nth (valarray, i);
guint val = g_value_get_uint (gvalue);
g_snprintf (stride_str, sizeof (stride_str), "%u", val);
x_tiles = GST_VIDEO_TILE_X_TILES (vp->stride[i]);
y_tiles = GST_VIDEO_TILE_Y_TILES (vp->stride[i]);
default_x_tiles = GST_VIDEO_TILE_X_TILES (info->stride[i]);
default_y_tiles = GST_VIDEO_TILE_Y_TILES (info->stride[i]);
if (x_tiles < default_x_tiles) {
GST_WARNING_OBJECT (vp,
"x_tiles for plane %u is too small: got %d, min %d", i, x_tiles,
default_x_tiles);
return FALSE;
}
if (y_tiles < default_y_tiles) {
GST_WARNING_OBJECT (vp,
"y_tiles for plane %u is too small: got %d, min %d", i, y_tiles,
default_y_tiles);
return FALSE;
}
if (str == NULL) {
str = g_strdup (stride_str);
} else {
if (vp->stride[i] < info->stride[i]) {
GST_WARNING_OBJECT (vp,
"stride for plane %u is too small: got %d, min %d", i,
vp->stride[i], info->stride[i]);
return FALSE;
}
gchar *new_str = g_strdup_printf ("%s,%s", str, stride_str);
g_free (str);
str = new_str;
}
}
/* 2. update stride and plane offsets */
for (i = 0; i < GST_VIDEO_INFO_N_PLANES (info); i++) {
if (vp->stride[i] != info->stride[i]) {
info->stride[i] = vp->stride[i];
if (i > 0) {
/* update offset to reflect stride change for plane > 0 */
info->offset[i] = info->offset[i - 1] +
gst_video_parse_get_plane_size (info, i - 1);
}
vp->need_videometa = TRUE;
}
}
return TRUE;
}
static gboolean
gst_video_parse_update_offset (GstVideoParse * vp)
{
GstVideoInfo *info = &vp->info;
guint i;
/* 1. check that provided offsets are greaters than the default ones and are
* consistent with plane size */
for (i = 0; i < GST_VIDEO_INFO_N_PLANES (info); i++) {
gsize min_offset = info->offset[i];
if (i > 0)
min_offset = MAX (min_offset,
vp->offset[i - 1] + gst_video_parse_get_plane_size (info, i - 1));
if (vp->offset[i] < min_offset) {
GST_WARNING_OBJECT (vp,
"offset for plane %u is too small: got %d, min %" G_GSIZE_FORMAT, i,
vp->offset[i], min_offset);
return FALSE;
}
}
/* 2. update offsets */
for (i = 0; i < GST_VIDEO_INFO_N_PLANES (info); i++) {
if (vp->offset[i] != info->offset[i]) {
info->offset[i] = vp->offset[i];
vp->need_videometa = TRUE;
}
}
return TRUE;
}
static void
gst_video_parse_update_info (GstVideoParse * vp)
{
GstVideoInfo *info = &vp->info;
gint fps_n, fps_d;
gint framesize;
guint i;
gboolean update_size = FALSE;
gst_raw_parse_get_fps (GST_RAW_PARSE (vp), &fps_n, &fps_d);
gst_video_info_init (info);
gst_video_info_set_format (info, vp->format, vp->width, vp->height);
info->fps_n = fps_n;
info->fps_d = fps_d;
info->par_n = vp->par_n;
info->par_d = vp->par_d;
info->interlace_mode = vp->interlaced ?
GST_VIDEO_INTERLACE_MODE_INTERLEAVED :
GST_VIDEO_INTERLACE_MODE_PROGRESSIVE;
vp->need_videometa = FALSE;
if (vp->stride_set) {
if (gst_video_parse_update_stride (vp))
update_size = TRUE;
else
GST_WARNING_OBJECT (vp, "invalid strides set, use default ones");
}
if (vp->offset_set) {
if (gst_video_parse_update_offset (vp))
update_size = TRUE;
else
GST_WARNING_OBJECT (vp, "invalid offsets set, use default ones");
}
if (update_size) {
framesize = 0;
for (i = 0; i < GST_VIDEO_INFO_N_PLANES (info); i++) {
gint planesize = info->offset[i];
planesize += gst_video_parse_get_plane_size (info, i);
if (planesize > framesize)
framesize = planesize;
}
info->size = framesize;
}
if (vp->framesize) {
/* user requires a specific framesize, just make sure it's bigger than
* the current one */
if (vp->framesize > vp->info.size)
vp->info.size = vp->framesize;
else
GST_WARNING_OBJECT (vp, "invalid framesize set: got %u, min: %"
G_GSIZE_FORMAT, vp->framesize, vp->info.size);
}
GST_DEBUG_OBJECT (vp, "video info: %ux%u, format %s, size %" G_GSIZE_FORMAT
", stride {%d,%d,%d,%d}, offset {%" G_GSIZE_FORMAT ",%" G_GSIZE_FORMAT
",%" G_GSIZE_FORMAT ",%" G_GSIZE_FORMAT "}",
GST_VIDEO_INFO_WIDTH (info), GST_VIDEO_INFO_HEIGHT (info),
GST_VIDEO_INFO_NAME (info), GST_VIDEO_INFO_SIZE (info),
info->stride[0], info->stride[1], info->stride[2], info->stride[3],
info->offset[0], info->offset[1], info->offset[2], info->offset[3]);
/* update base class framesize */
framesize = GST_VIDEO_INFO_SIZE (info);
gst_raw_parse_set_framesize (GST_RAW_PARSE (vp), framesize);
}
static GstCaps *
gst_video_parse_get_caps (GstRawParse * rp)
{
GstVideoParse *vp = GST_VIDEO_PARSE (rp);
return gst_video_info_to_caps (&vp->info);
}
static gboolean
gst_video_parse_copy_frame (GstVideoParse * vp, GstBuffer * dest,
GstVideoInfo * dest_info, GstBuffer * src, GstVideoInfo * src_info)
{
GstVideoFrame src_frame;
GstVideoFrame dest_frame;
gboolean ret;
if (!gst_video_frame_map (&src_frame, src_info, src, GST_MAP_READ)) {
GST_ERROR_OBJECT (vp, "failed to map src frame");
return FALSE;
}
if (!gst_video_frame_map (&dest_frame, dest_info, dest, GST_MAP_WRITE)) {
GST_ERROR_OBJECT (vp, "failed to map dest frame");
gst_video_frame_unmap (&src_frame);
return FALSE;
}
ret = gst_video_frame_copy (&dest_frame, &src_frame);
gst_video_frame_unmap (&src_frame);
gst_video_frame_unmap (&dest_frame);
return ret;
}
static void
gst_video_parse_pre_push_buffer (GstRawParse * rp, GstBuffer * buffer)
{
GstVideoParse *vp = GST_VIDEO_PARSE (rp);
if (vp->do_copy) {
GstVideoInfo info;
GstBuffer *outbuf;
gst_video_info_init (&info);
gst_video_info_set_format (&info, vp->format, vp->width, vp->height);
GST_DEBUG_OBJECT (vp, "copying frame to remove padding");
outbuf = gst_buffer_new_allocate (NULL, GST_VIDEO_INFO_SIZE (&info), NULL);
if (!gst_video_parse_copy_frame (vp, outbuf, &info, buffer, &vp->info))
GST_WARNING_OBJECT (vp, "failed to copy frame");
gst_buffer_replace_all_memory (buffer, gst_buffer_get_all_memory (outbuf));
gst_buffer_unref (outbuf);
} else {
GstVideoInfo *info = &vp->info;
GstVideoFrameFlags flags = GST_VIDEO_FRAME_FLAG_NONE;
if (vp->interlaced && vp->top_field_first)
flags = GST_VIDEO_FRAME_FLAG_TFF;
gst_buffer_add_video_meta_full (buffer, flags, GST_VIDEO_INFO_FORMAT (info),
GST_VIDEO_INFO_WIDTH (info), GST_VIDEO_INFO_HEIGHT (info),
GST_VIDEO_INFO_N_PLANES (info), info->offset, info->stride);
}
if (vp->interlaced) {
if (vp->top_field_first) {
GST_BUFFER_FLAG_SET (buffer, GST_VIDEO_BUFFER_FLAG_TFF);
} else {
GST_BUFFER_FLAG_UNSET (buffer, GST_VIDEO_BUFFER_FLAG_TFF);
}
}
}
static void
gst_video_parse_decide_allocation (GstRawParse * rp, GstQuery * query)
{
GstVideoParse *vp = GST_VIDEO_PARSE (rp);
gboolean has_videometa;
has_videometa = gst_query_find_allocation_meta (query,
GST_VIDEO_META_API_TYPE, NULL);
/* no need to copy if downstream supports videometa or if we don't need
* them */
if (has_videometa || !vp->need_videometa)
return;
vp->do_copy = TRUE;
return str;
}

27
gst/rawparse/gstvideoparse.h
View file

@ -24,11 +24,6 @@
#define __GST_VIDEO_PARSE_H__
#include <gst/gst.h>
#include <gst/base/gstbasetransform.h>
#include <gst/base/gstadapter.h>
#include <gst/video/video.h>
#include "gstrawparse.h"
#define GST_TYPE_VIDEO_PARSE \
(gst_video_parse_get_type())
@ -46,29 +41,13 @@ typedef struct _GstVideoParseClass GstVideoParseClass;
struct _GstVideoParse
{
GstRawParse parent;
GstVideoInfo info;
gboolean do_copy;
gboolean need_videometa;
gboolean stride_set;
gboolean offset_set;
/* properties */
GstVideoFormat format;
gint width;
gint height;
gint par_n, par_d;
gboolean interlaced;
gboolean top_field_first;
gint stride[GST_VIDEO_MAX_PLANES];
gint offset[GST_VIDEO_MAX_PLANES];
guint framesize;
GstBin parent;
GstElement *rawvideoparse;
};
struct _GstVideoParseClass
{
GstRawParseClass parent_class;
GstBinClass parent_class;
};