FaSTTUBe/GST-Tensordecoder-ov_ep
37
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

ext/xvid/: xvid plugin to support more capabilities of XviD codec.

Browse Source 
Original commit message from CVS:
Patch by: Mark Nauwelaerts <manauw at skynet dot be>
* ext/xvid/gstxvid.c: (gst_xvid_init), (gst_xvid_structure_to_csp),
(gst_xvid_csp_to_caps), (gst_xvid_image_get_size),
(gst_xvid_image_fill):
* ext/xvid/gstxvid.h:
* ext/xvid/gstxviddec.c: (gst_xviddec_class_init),
(gst_xviddec_init), (gst_xviddec_reset), (gst_xviddec_unset),
(gst_xviddec_handle_sink_event), (gst_xviddec_setup),
(gst_xviddec_add_par), (gst_xviddec_negotiate),
(gst_xviddec_decode), (gst_xviddec_chain),
(gst_xviddec_flush_buffers), (gst_xviddec_src_getcaps),
(gst_xviddec_src_link), (gst_xviddec_setcaps),
(gst_xviddec_change_state):
* ext/xvid/gstxviddec.h:
* ext/xvid/gstxvidenc.c: (gst_xvidenc_profile_get_type),
(gst_xvidenc_quant_type_get_type), (gst_xvidenc_pass_get_type),
(gst_xvidenc_get_type), (gst_xvidenc_base_init),
(gst_xvidenc_class_init), (gst_xvidenc_init),
(gst_xvidenc_finalize), (gst_xvidenc_handle_sink_event),
(gst_xvidenc_setup), (gst_xvidenc_setcaps), (gst_xvidenc_encode),
(gst_xvidenc_chain), (gst_xvidenc_flush_buffers),
(gst_xvidenc_set_property), (gst_xvidenc_get_property),
(gst_xvidenc_change_state):
* ext/xvid/gstxvidenc.h:
xvid plugin to support more capabilities of XviD codec.
Fixes #339462.
Some more cleanups here and there.
This commit is contained in:
Mark Nauwelaerts 2006-05-12 09:28:15 +00:00 committed by Wim Taymans
parent d7195fba1e
commit 39f82f2f19
7 changed files with 1500 additions and 426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
ChangeLog
View File

@ -1,3 +1,34 @@
2006-05-12 Wim Taymans <wim@fluendo.com>
Patch by: Mark Nauwelaerts <manauw at skynet dot be>
* ext/xvid/gstxvid.c: (gst_xvid_init), (gst_xvid_structure_to_csp),
(gst_xvid_csp_to_caps), (gst_xvid_image_get_size),
(gst_xvid_image_fill):
* ext/xvid/gstxvid.h:
* ext/xvid/gstxviddec.c: (gst_xviddec_class_init),
(gst_xviddec_init), (gst_xviddec_reset), (gst_xviddec_unset),
(gst_xviddec_handle_sink_event), (gst_xviddec_setup),
(gst_xviddec_add_par), (gst_xviddec_negotiate),
(gst_xviddec_decode), (gst_xviddec_chain),
(gst_xviddec_flush_buffers), (gst_xviddec_src_getcaps),
(gst_xviddec_src_link), (gst_xviddec_setcaps),
(gst_xviddec_change_state):
* ext/xvid/gstxviddec.h:
* ext/xvid/gstxvidenc.c: (gst_xvidenc_profile_get_type),
(gst_xvidenc_quant_type_get_type), (gst_xvidenc_pass_get_type),
(gst_xvidenc_get_type), (gst_xvidenc_base_init),
(gst_xvidenc_class_init), (gst_xvidenc_init),
(gst_xvidenc_finalize), (gst_xvidenc_handle_sink_event),
(gst_xvidenc_setup), (gst_xvidenc_setcaps), (gst_xvidenc_encode),
(gst_xvidenc_chain), (gst_xvidenc_flush_buffers),
(gst_xvidenc_set_property), (gst_xvidenc_get_property),
(gst_xvidenc_change_state):
* ext/xvid/gstxvidenc.h:
xvid plugin to support more capabilities of XviD codec.
Fixes #339462.
Some more cleanups here and there.
2006-05-11 Edgard Lima <edgard.lima@indt.org.br> 2006-05-11 Edgard Lima <edgard.lima@indt.org.br>
* sys/v4l2/Makefile.am: * sys/v4l2/Makefile.am:

110
ext/xvid/gstxvid.c
View File

@ -42,6 +42,7 @@ gst_xvid_init (void)
/* set up xvid initially (function pointers, CPU flags) */ /* set up xvid initially (function pointers, CPU flags) */
gst_xvid_init_struct (xinit); gst_xvid_init_struct (xinit);
if ((ret = xvid_global (NULL, XVID_GBL_INIT, &xinit, NULL)) < 0) { if ((ret = xvid_global (NULL, XVID_GBL_INIT, &xinit, NULL)) < 0) {
g_warning ("Failed to initialize XviD: %s (%d)", gst_xvid_error (ret), ret); g_warning ("Failed to initialize XviD: %s (%d)", gst_xvid_error (ret), ret);
return FALSE; return FALSE;
@ -87,11 +88,10 @@ gst_xvid_error (int errorcode)
} }
gint gint
gst_xvid_structure_to_csp (GstStructure * structure, gst_xvid_structure_to_csp (GstStructure * structure)
gint w, gint * _stride, gint * _bpp)
{ {
const gchar *mime = gst_structure_get_name (structure); const gchar *mime = gst_structure_get_name (structure);
gint xvid_cs = -1, stride = -1, bpp = -1; gint xvid_cs = -1;
if (!strcmp (mime, "video/x-raw-yuv")) { if (!strcmp (mime, "video/x-raw-yuv")) {
guint32 fourcc; guint32 fourcc;
@ -100,32 +100,22 @@ gst_xvid_structure_to_csp (GstStructure * structure,
switch (fourcc) { switch (fourcc) {
case GST_MAKE_FOURCC ('I', '4', '2', '0'): case GST_MAKE_FOURCC ('I', '4', '2', '0'):
xvid_cs = XVID_CSP_I420; xvid_cs = XVID_CSP_I420;
stride = w;
bpp = 12;
break; break;
case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'): case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
xvid_cs = XVID_CSP_YUY2; xvid_cs = XVID_CSP_YUY2;
stride = w * 2;
bpp = 16;
break; break;
case GST_MAKE_FOURCC ('Y', 'V', '1', '2'): case GST_MAKE_FOURCC ('Y', 'V', '1', '2'):
xvid_cs = XVID_CSP_YV12; xvid_cs = XVID_CSP_YV12;
stride = w;
bpp = 12;
break; break;
case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'): case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'):
xvid_cs = XVID_CSP_UYVY; xvid_cs = XVID_CSP_UYVY;
stride = w * 2;
bpp = 16;
break; break;
case GST_MAKE_FOURCC ('Y', 'V', 'Y', 'U'): case GST_MAKE_FOURCC ('Y', 'V', 'Y', 'U'):
xvid_cs = XVID_CSP_YVYU; xvid_cs = XVID_CSP_YVYU;
stride = w * 2;
bpp = 16;
break; break;
} }
} else { } else {
gint depth, r_mask; gint depth, bpp, r_mask;
gst_structure_get_int (structure, "depth", &depth); gst_structure_get_int (structure, "depth", &depth);
gst_structure_get_int (structure, "bpp", &bpp); gst_structure_get_int (structure, "bpp", &bpp);
@ -164,20 +154,15 @@ gst_xvid_structure_to_csp (GstStructure * structure,
break; break;
} }
stride = w * bpp / 8;
} }
if (_stride)
*_stride = stride;
if (_bpp)
*_bpp = bpp;
return xvid_cs; return xvid_cs;
} }
GstCaps * GstCaps *
gst_xvid_csp_to_caps (gint csp, gint w, gint h, gint fps_n, gint fps_d) gst_xvid_csp_to_caps (gint csp, gint w, gint h)
{ {
GstCaps *caps = NULL; GstStructure *structure = NULL;
switch (csp) { switch (csp) {
case XVID_CSP_RGB555: case XVID_CSP_RGB555:
@ -253,7 +238,7 @@ gst_xvid_csp_to_caps (gint csp, gint w, gint h, gint fps_n, gint fps_d)
break; break;
} }
caps = gst_caps_new_simple ("video/x-raw-rgb", structure = gst_structure_new ("video/x-raw-rgb",
"width", G_TYPE_INT, w, "width", G_TYPE_INT, w,
"height", G_TYPE_INT, h, "height", G_TYPE_INT, h,
"depth", G_TYPE_INT, depth, "depth", G_TYPE_INT, depth,
@ -261,8 +246,7 @@ gst_xvid_csp_to_caps (gint csp, gint w, gint h, gint fps_n, gint fps_d)
"endianness", G_TYPE_INT, endianness, "endianness", G_TYPE_INT, endianness,
"red_mask", G_TYPE_INT, r_mask, "red_mask", G_TYPE_INT, r_mask,
"green_mask", G_TYPE_INT, g_mask, "green_mask", G_TYPE_INT, g_mask,
"blue_mask", G_TYPE_INT, b_mask, "blue_mask", G_TYPE_INT, b_mask, NULL);
"framerate", GST_TYPE_FRACTION, fps_n, fps_d, NULL);
break; break;
} }
@ -290,19 +274,87 @@ gst_xvid_csp_to_caps (gint csp, gint w, gint h, gint fps_n, gint fps_d)
fourcc = GST_MAKE_FOURCC ('Y', 'V', '1', '2'); fourcc = GST_MAKE_FOURCC ('Y', 'V', '1', '2');
break; break;
} }
caps = gst_caps_new_simple ("video/x-raw-yuv",
structure = gst_structure_new ("video/x-raw-yuv",
"width", G_TYPE_INT, w, "width", G_TYPE_INT, w,
"height", G_TYPE_INT, h, "height", G_TYPE_INT, h, "format", GST_TYPE_FOURCC, fourcc, NULL);
"format", GST_TYPE_FOURCC, fourcc,
"framerate", GST_TYPE_FRACTION, fps_n, fps_d, NULL);
break; break;
} }
} }
return caps; return gst_caps_new_full (structure, NULL);
} }
gint
gst_xvid_image_get_size (gint csp, gint width, gint height)
{
xvid_image_t dummy_im;
return gst_xvid_image_fill (&dummy_im, NULL, csp, width, height);
}
gint
gst_xvid_image_fill (xvid_image_t * im, void *ptr, gint csp,
gint width, gint height)
{
gint stride, h2, size = 0;
im->csp = csp;
switch (csp) {
case XVID_CSP_I420:
case XVID_CSP_YV12:
/* planar */
/* luma */
stride = GST_ROUND_UP_4 (width);
h2 = GST_ROUND_UP_2 (height);
im->stride[0] = stride;
im->plane[0] = ptr;
/* chroma */
im->plane[1] = im->plane[0] + (stride * h2);
size += stride * height;
stride = GST_ROUND_UP_8 (width) / 2;
h2 = GST_ROUND_UP_2 (height) / 2;
im->stride[1] = stride;
im->plane[2] = im->plane[1] + (stride * h2);
im->stride[2] = stride;
size += 2 * (stride * height);
break;
case XVID_CSP_RGB555:
case XVID_CSP_RGB565:
case XVID_CSP_YUY2:
case XVID_CSP_UYVY:
case XVID_CSP_YVYU:
/* packed */
stride = GST_ROUND_UP_4 (width * 2);
im->plane[0] = ptr;
im->stride[0] = stride;
size = stride * height;
break;
case XVID_CSP_BGR:
stride = GST_ROUND_UP_4 (width * 3);
im->plane[0] = ptr;
im->stride[0] = stride;
size = stride * height * 2;
break;
case XVID_CSP_ABGR:
case XVID_CSP_BGRA:
case XVID_CSP_RGBA:
#ifdef XVID_CSP_ARGB
case XVID_CSP_ARGB:
#endif
stride = width * 4;
im->plane[0] = ptr;
im->stride[0] = stride;
size = stride * height;
break;
}
return size;
}
static gboolean static gboolean
plugin_init (GstPlugin * plugin) plugin_init (GstPlugin * plugin)
{ {

12
ext/xvid/gstxvid.h
View File

@ -34,7 +34,7 @@ G_BEGIN_DECLS
"video/x-raw-rgb, " \ "video/x-raw-rgb, " \
"width = (int) [ 0, MAX ], " \ "width = (int) [ 0, MAX ], " \
"height = (int) [ 0, MAX], " \ "height = (int) [ 0, MAX], " \
"framerate = (double) [ 0.0, MAX], " \ "framerate = (fraction) [ 0, MAX], " \
"depth = (int) 24, " \ "depth = (int) 24, " \
"bpp = (int) " G_STRINGIFY (bpp) ", " \ "bpp = (int) " G_STRINGIFY (bpp) ", " \
"endianness = (int) BIG_ENDIAN, " \ "endianness = (int) BIG_ENDIAN, " \
@ -45,10 +45,12 @@ G_BEGIN_DECLS
extern gchar * gst_xvid_error (int errorcode); extern gchar * gst_xvid_error (int errorcode);
extern gboolean gst_xvid_init (void); extern gboolean gst_xvid_init (void);
extern gint gst_xvid_structure_to_csp (GstStructure *structure, extern gint gst_xvid_structure_to_csp (GstStructure *structure);
gint w, gint *stride, gint *bpp); extern GstCaps *gst_xvid_csp_to_caps (gint csp, gint w, gint h);
extern GstCaps *gst_xvid_csp_to_caps (gint csp, gint w, gint h, extern gint gst_xvid_image_get_size (gint csp,
gint fps_n, gint fps_d); gint width, gint height);
extern gint gst_xvid_image_fill (xvid_image_t * im, void * ptr, gint csp,
gint width, gint height);
G_END_DECLS G_END_DECLS

545
ext/xvid/gstxviddec.c
View File

@ -1,5 +1,6 @@
/* GStreamer xvid decoder plugin /* GStreamer xvid decoder plugin
* Copyright (C) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net> * Copyright (C) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
* (C) 2006 Mark Nauwelaerts <manauw@skynet.be>
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public * modify it under the terms of the GNU Library General Public
@ -17,6 +18,7 @@
* Boston, MA 02111-1307, USA. * Boston, MA 02111-1307, USA.
*/ */
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
#include "config.h" #include "config.h"
#endif #endif
@ -68,19 +70,32 @@ enum
/* FILL ME */ /* FILL ME */
}; };
GST_DEBUG_CATEGORY_STATIC (xviddec_debug);
#define GST_CAT_DEFAULT xviddec_debug
static void gst_xviddec_base_init (GstXvidDecClass * klass); static void gst_xviddec_base_init (GstXvidDecClass * klass);
static void gst_xviddec_class_init (GstXvidDecClass * klass); static void gst_xviddec_class_init (GstXvidDecClass * klass);
static void gst_xviddec_init (GstXvidDec * xviddec); static void gst_xviddec_init (GstXvidDec * xviddec);
static void gst_xviddec_reset (GstXvidDec * xviddec);
static gboolean gst_xviddec_handle_sink_event (GstPad * pad, GstEvent * event);
static GstFlowReturn gst_xviddec_chain (GstPad * pad, GstBuffer * buf); static GstFlowReturn gst_xviddec_chain (GstPad * pad, GstBuffer * buf);
static gboolean gst_xviddec_setcaps (GstPad * pad, GstCaps * caps); static gboolean gst_xviddec_setcaps (GstPad * pad, GstCaps * caps);
static gboolean gst_xviddec_negotiate (GstXvidDec * xviddec); static void gst_xviddec_flush_buffers (GstXvidDec * xviddec, gboolean send);
#if 0
static GstPadLinkReturn
gst_xviddec_src_link (GstPad * pad, const GstCaps * vscapslist);
*/static GstCaps *gst_xviddec_src_getcaps (GstPad * pad);
#endif
static GstStateChangeReturn gst_xviddec_change_state (GstElement * element, static GstStateChangeReturn gst_xviddec_change_state (GstElement * element,
GstStateChange transition); GstStateChange transition);
static GstElementClass *parent_class = NULL; static GstElementClass *parent_class = NULL;
/* static guint gst_xviddec_signals[LAST_SIGNAL] = { 0 }; */ /* static guint gst_xviddec_signals[LAST_SIGNAL] = { 0 }; */
GType GType
gst_xviddec_get_type (void) gst_xviddec_get_type (void)
{ {
@ -121,25 +136,31 @@ gst_xviddec_base_init (GstXvidDecClass * klass)
static void static void
gst_xviddec_class_init (GstXvidDecClass * klass) gst_xviddec_class_init (GstXvidDecClass * klass)
{ {
GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass); GstElementClass *gstelement_class = (GstElementClass *) klass;
parent_class = g_type_class_peek_parent (klass); parent_class = g_type_class_peek_parent (klass);
gstelement_class->change_state = gst_xviddec_change_state; GST_DEBUG_CATEGORY_INIT (xviddec_debug, "xviddec", 0, "XviD decoder");
gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_xviddec_change_state);
} }
static void static void
gst_xviddec_init (GstXvidDec * xviddec) gst_xviddec_init (GstXvidDec * xviddec)
{ {
gst_xvid_init ();
/* create the sink pad */ /* create the sink pad */
xviddec->sinkpad = xviddec->sinkpad =
gst_pad_new_from_template (gst_static_pad_template_get (&sink_template), gst_pad_new_from_template (gst_static_pad_template_get (&sink_template),
"sink"); "sink");
gst_element_add_pad (GST_ELEMENT (xviddec), xviddec->sinkpad); gst_element_add_pad (GST_ELEMENT (xviddec), xviddec->sinkpad);
gst_pad_set_chain_function (xviddec->sinkpad, gst_xviddec_chain);
gst_pad_set_setcaps_function (xviddec->sinkpad, gst_xviddec_setcaps); gst_pad_set_chain_function (xviddec->sinkpad,
GST_DEBUG_FUNCPTR (gst_xviddec_chain));
gst_pad_set_setcaps_function (xviddec->sinkpad,
GST_DEBUG_FUNCPTR (gst_xviddec_setcaps));
gst_pad_set_event_function (xviddec->sinkpad,
GST_DEBUG_FUNCPTR (gst_xviddec_handle_sink_event));
/* create the src pad */ /* create the src pad */
xviddec->srcpad = xviddec->srcpad =
@ -148,129 +169,380 @@ gst_xviddec_init (GstXvidDec * xviddec)
gst_element_add_pad (GST_ELEMENT (xviddec), xviddec->srcpad); gst_element_add_pad (GST_ELEMENT (xviddec), xviddec->srcpad);
gst_pad_use_fixed_caps (xviddec->srcpad); gst_pad_use_fixed_caps (xviddec->srcpad);
gst_xviddec_reset (xviddec);
}
static void
gst_xviddec_reset (GstXvidDec * xviddec)
{
/* size, etc. */ /* size, etc. */
xviddec->width = xviddec->height = xviddec->csp = -1; xviddec->width = xviddec->height = xviddec->csp = -1;
xviddec->fps_n = xviddec->par_n = -1;
xviddec->fps_d = xviddec->par_d = 1;
xviddec->next_ts = xviddec->next_dur = GST_CLOCK_TIME_NONE;
/* set xvid handle to NULL */ /* set xvid handle to NULL */
xviddec->handle = NULL; xviddec->handle = NULL;
/* no delayed timestamp to start with */
xviddec->have_ts = FALSE;
/* need keyframe to get going */
xviddec->waiting_for_key = TRUE;
} }
static void static void
gst_xviddec_unset (GstXvidDec * xviddec) gst_xviddec_unset (GstXvidDec * xviddec)
{ {
/* unref this instance */ /* release XviD decoder */
xvid_decore (xviddec->handle, XVID_DEC_DESTROY, NULL, NULL); xvid_decore (xviddec->handle, XVID_DEC_DESTROY, NULL, NULL);
xviddec->handle = NULL; xviddec->handle = NULL;
} }
static gboolean
gst_xviddec_handle_sink_event (GstPad * pad, GstEvent * event)
{
GstXvidDec *xviddec = GST_XVIDDEC (GST_PAD_PARENT (pad));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
gst_xviddec_flush_buffers (xviddec, TRUE);
break;
case GST_EVENT_FLUSH_STOP:
gst_xviddec_flush_buffers (xviddec, FALSE);
break;
case GST_EVENT_NEWSEGMENT:
/* don't really mind about the actual segment info,
* but we do need to recover from this possible jump */
/* FIXME, NEWSEGMENT is not a discontinuity. A decoder
* should clip the output to the segment boundaries.
* Also the rate field of the segment can be used to
* optimize the decoding, like skipping B frames when
* playing at double speed.
* The DISCONT flag on buffers should be used to detect
* discontinuities.
*/
xviddec->waiting_for_key = TRUE;
break;
default:
break;
}
return gst_pad_push_event (xviddec->srcpad, event);
}
static gboolean static gboolean
gst_xviddec_setup (GstXvidDec * xviddec) gst_xviddec_setup (GstXvidDec * xviddec)
{ {
xvid_dec_create_t xdec; xvid_dec_create_t xdec;
int ret; gint ret;
/* initialise parameters, see xvid documentation */ /* initialise parameters, see xvid documentation */
gst_xvid_init_struct (xdec); gst_xvid_init_struct (xdec);
xdec.width = xviddec->width; /* let the decoder handle this, don't trust the container */
xdec.height = xviddec->height; xdec.width = 0;
xdec.height = 0;
xdec.handle = NULL; xdec.handle = NULL;
if ((ret = xvid_decore (NULL, XVID_DEC_CREATE, &xdec, NULL)) < 0) { if ((ret = xvid_decore (NULL, XVID_DEC_CREATE, &xdec, NULL)) < 0) {
GST_ELEMENT_ERROR (xviddec, LIBRARY, SETTINGS, (NULL), GST_DEBUG_OBJECT (xviddec,
("Setting parameters %dx%d@%d failed: %s (%d)", "Initializing xvid decoder with parameters %dx%d@%d failed: %s (%d)",
xviddec->width, xviddec->height, xviddec->csp, xviddec->width, xviddec->height, xviddec->csp,
gst_xvid_error (ret), ret)); gst_xvid_error (ret), ret);
return FALSE; return FALSE;
} }
xviddec->handle = xdec.handle; xviddec->handle = xdec.handle;
return TRUE; return TRUE;
} }
static void
gst_xviddec_add_par (GstStructure * structure,
gint mux_par_n, gint mux_par_d, gint dec_par_n, gint dec_par_d)
{
/* muxer wins if decoder has nothing interesting to offer */
if (dec_par_n == dec_par_d) {
gst_structure_set (structure, "pixel-aspect-ratio", GST_TYPE_FRACTION,
mux_par_n, mux_par_d, NULL);
} else {
gst_structure_set (structure, "pixel-aspect-ratio", GST_TYPE_FRACTION,
dec_par_n, dec_par_d, NULL);
}
}
/* based on the decoder info, if provided, and xviddec info,
construct a caps and send on to src pad */
static gboolean
gst_xviddec_negotiate (GstXvidDec * xviddec, xvid_dec_stats_t * xstats)
{
gint par_width, par_height;
GstCaps *caps;
/* note: setcaps call with no xstats info,
so definitely need to negotiate then */
if (xstats && (xstats->type != XVID_TYPE_VOL
|| (xstats->type == XVID_TYPE_VOL
&& xviddec->width == xstats->data.vol.width
&& xviddec->height == xstats->data.vol.height)))
return TRUE;
switch (xstats ? xstats->data.vol.par : XVID_PAR_11_VGA) {
case XVID_PAR_11_VGA:
par_width = par_height = 1;
break;
case XVID_PAR_43_PAL:
case XVID_PAR_43_NTSC:
par_width = 4;
par_height = 3;
break;
case XVID_PAR_169_PAL:
case XVID_PAR_169_NTSC:
par_width = 16;
par_height = 9;
break;
case XVID_PAR_EXT:
default:
par_width = xstats->data.vol.par_width;
par_height = xstats->data.vol.par_height;
}
caps = gst_xvid_csp_to_caps (xviddec->csp, xviddec->width, xviddec->height);
/* can only provide framerate if we received one */
if (xviddec->fps_n != -1) {
gst_structure_set (gst_caps_get_structure (caps, 0), "framerate",
GST_TYPE_FRACTION, xviddec->fps_n, xviddec->fps_d, NULL);
}
gst_xviddec_add_par (gst_caps_get_structure (caps, 0),
xviddec->par_n, xviddec->par_d, par_width, par_height);
return gst_pad_set_caps (xviddec->srcpad, caps);
}
/* decodes frame according to info in xframe;
- outbuf must not be NULL
- xstats can be NULL, if not, it has been init'ed
- output placed in outbuf, which is also allocated if NULL,
caller must unref when needed
- xvid stats placed in xstats, if not NULL
- xvid return code is returned, which is usually the size of the output frame
*/
static gint
gst_xviddec_decode (GstXvidDec * xviddec, xvid_dec_frame_t xframe,
GstBuffer ** outbuf, xvid_dec_stats_t * xstats)
{
g_return_val_if_fail (outbuf, -1);
if (!*outbuf) {
gint size = gst_xvid_image_get_size (xviddec->csp,
xviddec->width, xviddec->height);
gst_pad_alloc_buffer (xviddec->srcpad, GST_BUFFER_OFFSET_NONE, size,
GST_PAD_CAPS (xviddec->srcpad), outbuf);
}
gst_xvid_image_fill (&xframe.output, GST_BUFFER_DATA (*outbuf),
xviddec->csp, xviddec->width, xviddec->height);
GST_DEBUG_OBJECT (xviddec, "decoding into buffer %" GST_PTR_FORMAT
", data %" GST_PTR_FORMAT ", %" GST_PTR_FORMAT, *outbuf,
GST_BUFFER_MALLOCDATA (*outbuf), GST_BUFFER_DATA (*outbuf));
return xvid_decore (xviddec->handle, XVID_DEC_DECODE, &xframe, xstats);
}
static GstFlowReturn static GstFlowReturn
gst_xviddec_chain (GstPad * pad, GstBuffer * buf) gst_xviddec_chain (GstPad * pad, GstBuffer * buf)
{ {
GstXvidDec *xviddec = GST_XVIDDEC (gst_pad_get_parent (pad)); GstXvidDec *xviddec;
GstBuffer *outbuf = NULL; GstBuffer *outbuf = NULL;
xvid_dec_frame_t xframe; xvid_dec_frame_t xframe;
GstFlowReturn ret = GST_FLOW_OK; xvid_dec_stats_t xstats;
guint bufsize; gint ret;
int error = 0; guint8 *data;
guint size;
GstFlowReturn fret;
if (xviddec->handle == NULL) { xviddec = GST_XVIDDEC (GST_OBJECT_PARENT (pad));
if (!gst_xviddec_negotiate (xviddec))
if (!xviddec->handle)
goto not_negotiated; goto not_negotiated;
}
bufsize = (xviddec->width * xviddec->height * xviddec->bpp / 8); fret = GST_FLOW_OK;
outbuf = gst_buffer_new_and_alloc (bufsize); GST_DEBUG_OBJECT (xviddec,
"Received buffer of time %" GST_TIME_FORMAT ", size %d",
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)), GST_BUFFER_SIZE (buf));
GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf); data = GST_BUFFER_DATA (buf);
GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buf); size = GST_BUFFER_SIZE (buf);
GST_BUFFER_SIZE (outbuf) = bufsize;
do { /* loop needed because xvidcore may return vol information */
/* decode and so ... */ /* decode and so ... */
gst_xvid_init_struct (xframe); gst_xvid_init_struct (xframe);
xframe.general = XVID_LOWDELAY; xframe.general = XVID_LOWDELAY;
xframe.bitstream = (void *) GST_BUFFER_DATA (buf); xframe.bitstream = (void *) data;
xframe.length = GST_BUFFER_SIZE (buf); xframe.length = size;
xframe.output.csp = xviddec->csp;
if (xviddec->width == xviddec->stride) { gst_xvid_init_struct (xstats);
xframe.output.plane[0] = GST_BUFFER_DATA (outbuf);
xframe.output.plane[1] = if ((ret = gst_xviddec_decode (xviddec, xframe, &outbuf, &xstats)) < 0)
xframe.output.plane[0] + (xviddec->width * xviddec->height); goto decode_error;
xframe.output.plane[2] =
xframe.output.plane[1] + (xviddec->width * xviddec->height / 4); GST_DEBUG_OBJECT (xviddec, "xvid produced output, type %d, consumed %d",
xframe.output.stride[0] = xviddec->width; xstats.type, ret);
xframe.output.stride[1] = xviddec->width / 2;
xframe.output.stride[2] = xviddec->width / 2; if (xstats.type == XVID_TYPE_VOL)
gst_xviddec_negotiate (xviddec, &xstats);
data += ret;
size -= ret;
} while (xstats.type <= 0 && size > 0);
if (size > 1) /* 1 byte is frequently left over */
GST_WARNING_OBJECT (xviddec,
"xvid decoder returned frame without consuming all input");
/* FIXME, reflow the multiple return exit points */
if (xstats.type > 0) { /* some real output was produced */
if (G_UNLIKELY (xviddec->waiting_for_key)) {
if (xstats.type != XVID_TYPE_IVOP)
goto dropping;
xviddec->waiting_for_key = FALSE;
}
/* bframes can cause a delay in frames being returned
non keyframe timestamps can permute a bit between
encode and display order, but should match for keyframes */
if (xviddec->have_ts) {
GST_BUFFER_TIMESTAMP (outbuf) = xviddec->next_ts;
GST_BUFFER_DURATION (outbuf) = xviddec->next_dur;
xviddec->next_ts = GST_BUFFER_TIMESTAMP (buf);
xviddec->next_dur = GST_BUFFER_DURATION (buf);
} else { } else {
xframe.output.plane[0] = GST_BUFFER_DATA (outbuf); GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf);
xframe.output.stride[0] = xviddec->stride; GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buf);
} }
if ((error =
xvid_decore (xviddec->handle, XVID_DEC_DECODE, &xframe, NULL)) < 0) {
goto not_decoding;
}
gst_buffer_set_caps (outbuf, GST_PAD_CAPS (xviddec->srcpad)); gst_buffer_set_caps (outbuf, GST_PAD_CAPS (xviddec->srcpad));
ret = gst_pad_push (xviddec->srcpad, outbuf);
goto cleanup; fret = gst_pad_push (xviddec->srcpad, outbuf);
} else { /* no real output yet, delay in frames being returned */
if (G_UNLIKELY (xviddec->have_ts)) {
GST_WARNING_OBJECT (xviddec,
"xvid decoder produced no output, but timestamp %" GST_TIME_FORMAT
" already queued", GST_TIME_ARGS (xviddec->next_ts));
} else {
xviddec->have_ts = TRUE;
xviddec->next_ts = GST_BUFFER_TIMESTAMP (buf);
xviddec->next_dur = GST_BUFFER_TIMESTAMP (buf);
}
gst_buffer_unref (outbuf);
}
done:
gst_buffer_unref (buf);
return fret;
/* ERRORS */
not_negotiated: not_negotiated:
{ {
GST_ELEMENT_ERROR (xviddec, CORE, NEGOTIATION, (NULL), GST_ELEMENT_ERROR (xviddec, CORE, NEGOTIATION, (NULL),
("format wasn't negotiated before chain function")); ("format wasn't negotiated before chain function"));
ret = GST_FLOW_NOT_NEGOTIATED; fret = GST_FLOW_NOT_NEGOTIATED;
goto cleanup; goto done;
} }
decode_error:
not_decoding:
{ {
GST_ELEMENT_ERROR (xviddec, STREAM, DECODE, (NULL), GST_ELEMENT_WARNING (xviddec, STREAM, DECODE, (NULL),
("Error decoding xvid frame: %s (%d)\n", gst_xvid_error (error), ("Error decoding xvid frame: %s (%d)", gst_xvid_error (ret), ret));
error)); if (outbuf)
gst_buffer_unref (outbuf); gst_buffer_unref (outbuf);
ret = GST_FLOW_ERROR; goto done;
goto cleanup;
} }
dropping:
cleanup:
gst_buffer_unref (buf);
gst_object_unref (xviddec);
return ret;
}
static gboolean
gst_xviddec_negotiate (GstXvidDec * xviddec)
{ {
GST_WARNING_OBJECT (xviddec, "Dropping non-keyframe (seek/init)");
if (outbuf)
gst_buffer_unref (outbuf);
goto done;
}
}
/* flush xvid encoder buffers caused by bframe usage;
not well tested */
static void
gst_xviddec_flush_buffers (GstXvidDec * xviddec, gboolean send)
{
#if 0
gint ret;
GstBuffer *outbuf = NULL;
xvid_dec_frame_t xframe;
xvid_dec_stats_t xstats;
#endif
GST_DEBUG_OBJECT (xviddec, "flushing buffers with send %d, have_ts %d",
send, xviddec->have_ts);
/* no need to flush if there is no delayed time-stamp */
if (!xviddec->have_ts)
return;
/* flushing must reset the timestamp keeping */
xviddec->have_ts = FALSE;
/* also no need to flush if no handle */
if (!xviddec->handle)
return;
/* unlike encoder, decoder does not seem to like flushing, disable for now */
#if 0
gst_xvid_init_struct (xframe);
gst_xvid_init_struct (xstats);
/* init a fake frame to force flushing */
xframe.bitstream = NULL;
xframe.length = -1;
ret = gst_xviddec_decode (xviddec, xframe, &outbuf, &xstats);
GST_DEBUG_OBJECT (xviddec, "received frame when flushing, type %d, size %d",
xstats.type, ret);
if (ret > 0 && send) {
/* we have some valid return frame, give it the delayed timestamp and send */
GST_BUFFER_TIMESTAMP (outbuf) = xviddec->next_ts;
GST_BUFFER_DURATION (outbuf) = xviddec->next_dur;
gst_buffer_set_caps (outbuf, GST_PAD_CAPS (xviddec->srcpad));
gst_pad_push (xviddec->srcpad, outbuf);
return;
}
if (outbuf)
gst_buffer_unref (outbuf);
#else
return;
#endif
}
#if 0
static GstCaps *
gst_xviddec_src_getcaps (GstPad * pad)
{
GstXvidDec *xviddec = GST_XVIDDEC (GST_PAD_PARENT (pad));
GstCaps *caps;
gint csp[] = { gint csp[] = {
XVID_CSP_I420, XVID_CSP_I420,
XVID_CSP_YV12, XVID_CSP_YV12,
@ -289,75 +561,125 @@ gst_xviddec_negotiate (GstXvidDec * xviddec)
0 0
}, i; }, i;
if (!GST_PAD_CAPS (xviddec->sinkpad)) {
GstPadTemplate *templ = gst_static_pad_template_get (&src_template);
return gst_caps_copy (gst_pad_template_get_caps (templ));
}
caps = gst_caps_new_empty ();
for (i = 0; csp[i] != 0; i++) { for (i = 0; csp[i] != 0; i++) {
GstCaps *one = gst_xvid_csp_to_caps (csp[i], xviddec->width, GstCaps *one = gst_xvid_csp_to_caps (csp[i], xviddec->width,
xviddec->height, xviddec->fps_n, xviddec->fps_d); xviddec->height, xviddec->fps, xviddec->par);
if (one) { gst_caps_append (caps, one);
if (gst_pad_set_caps (xviddec->srcpad, one)) {
GstStructure *structure = gst_caps_get_structure (one, 0);
xviddec->csp = gst_xvid_structure_to_csp (structure, xviddec->width,
&xviddec->stride, &xviddec->bpp);
if (xviddec->csp < 0) {
return FALSE;
} }
break; return caps;
} }
gst_caps_unref (one);
} static GstPadLinkReturn
gst_xviddec_src_link (GstPad * pad, const GstCaps * vscaps)
{
GstXvidDec *xviddec = GST_XVIDDEC (gst_pad_get_parent (pad));
GstStructure *structure = gst_caps_get_structure (vscaps, 0);
} if (!GST_PAD_CAPS (xviddec->sinkpad))
return GST_PAD_LINK_DELAYED;
gst_xviddec_setup (xviddec); /* if there's something old around, remove it */
return TRUE; if (xviddec->handle) {
gst_xviddec_unset (xviddec);
} }
xviddec->csp = gst_xvid_structure_to_csp (structure);
if (xviddec->csp < 0)
return GST_PAD_LINK_REFUSED;
if (!gst_xviddec_setup (xviddec))
return GST_PAD_LINK_REFUSED;
return GST_PAD_LINK_OK;
}
#endif
static gboolean static gboolean
gst_xviddec_setcaps (GstPad * pad, GstCaps * caps) gst_xviddec_setcaps (GstPad * pad, GstCaps * caps)
{ {
GstXvidDec *xviddec = GST_XVIDDEC (gst_pad_get_parent (pad)); GstXvidDec *xviddec = GST_XVIDDEC (GST_PAD_PARENT (pad));
GstStructure *structure; GstStructure *structure;
const GValue *fps; const GValue *val;
gboolean ret = FALSE;
GST_DEBUG ("setcaps called");
/* if there's something old around, remove it */ /* if there's something old around, remove it */
if (xviddec->handle) { if (xviddec->handle) {
gst_xviddec_unset (xviddec); gst_xviddec_unset (xviddec);
} }
if (!gst_pad_set_caps (xviddec->srcpad, caps)) {
ret = FALSE;
goto done;
}
/* if we get here, we know the input is xvid. we
* only need to bother with the output colorspace,
* which the src_link function takes care of. */
structure = gst_caps_get_structure (caps, 0); structure = gst_caps_get_structure (caps, 0);
gst_structure_get_int (structure, "width", &xviddec->width); gst_structure_get_int (structure, "width", &xviddec->width);
gst_structure_get_int (structure, "height", &xviddec->height); gst_structure_get_int (structure, "height", &xviddec->height);
fps = gst_structure_get_value (structure, "framerate"); /* perhaps some fps info */
if (fps != NULL) { val = gst_structure_get_value (structure, "framerate");
xviddec->fps_n = gst_value_get_fraction_numerator (fps); if ((val != NULL) && GST_VALUE_HOLDS_FRACTION (val)) {
xviddec->fps_d = gst_value_get_fraction_denominator (fps); xviddec->fps_n = gst_value_get_fraction_numerator (val);
xviddec->fps_d = gst_value_get_fraction_denominator (val);
} else { } else {
xviddec->fps_n = -1; xviddec->fps_n = -1;
xviddec->fps_d = 1;
} }
ret = gst_xviddec_negotiate (xviddec); /* perhaps some par info */
val = gst_structure_get_value (structure, "pixel-aspect-ratio");
if ((val != NULL) && GST_VALUE_HOLDS_FRACTION (val)) {
xviddec->par_n = gst_value_get_fraction_numerator (val);
xviddec->par_d = gst_value_get_fraction_denominator (val);
} else {
xviddec->par_n = 1;
xviddec->par_d = 1;
}
done: if (gst_xviddec_setup (xviddec)) {
gst_object_unref (xviddec); GstCaps *allowed_caps;
return ret; /* we try to find the preferred/accept csp */
allowed_caps = gst_pad_get_allowed_caps (xviddec->srcpad);
if (!allowed_caps) {
GST_DEBUG_OBJECT (xviddec, "... but no peer, using template caps");
/* need to copy because get_allowed_caps returns a ref,
and get_pad_template_caps doesn't */
allowed_caps =
gst_caps_copy (gst_pad_get_pad_template_caps (xviddec->srcpad));
}
/* pick the first one ... */
structure = gst_caps_get_structure (allowed_caps, 0);
val = gst_structure_get_value (structure, "format");
if (G_VALUE_TYPE (val) == GST_TYPE_LIST) {
GValue temp = { 0 };
gst_value_init_and_copy (&temp, gst_value_list_get_value (val, 0));
gst_structure_set_value (structure, "format", &temp);
g_value_unset (&temp);
}
/* ... and use its info to get the csp */
xviddec->csp = gst_xvid_structure_to_csp (structure);
if (xviddec->csp == -1) {
gchar *sstr = gst_structure_to_string (structure);
GST_INFO_OBJECT (xviddec,
"failed to decide upon csp from caps %s, trying I420", sstr);
g_free (sstr);
xviddec->csp = XVID_CSP_I420;
}
gst_caps_unref (allowed_caps);
return gst_xviddec_negotiate (xviddec, NULL);
} else /* setup did not work out */
return FALSE;
} }
static GstStateChangeReturn static GstStateChangeReturn
@ -368,28 +690,29 @@ gst_xviddec_change_state (GstElement * element, GstStateChange transition)
switch (transition) { switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY: case GST_STATE_CHANGE_NULL_TO_READY:
break; if (!gst_xvid_init ())
case GST_STATE_CHANGE_PAUSED_TO_PLAYING: return GST_STATE_CHANGE_FAILURE;
break; break;
default: default:
break; break;
} }
ret = parent_class->change_state (element, transition); ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (ret == GST_STATE_CHANGE_FAILURE)
goto done;
switch (transition) { switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY: case GST_STATE_CHANGE_PAUSED_TO_READY:
gst_xviddec_flush_buffers (xviddec, FALSE);
if (xviddec->handle) { if (xviddec->handle) {
gst_xviddec_unset (xviddec); gst_xviddec_unset (xviddec);
} }
break; gst_xviddec_reset (xviddec);
case GST_STATE_CHANGE_READY_TO_NULL:
break; break;
default: default:
break; break;
} }
done:
return ret; return ret;
} }

20
ext/xvid/gstxviddec.h
View File

@ -23,10 +23,7 @@
#include <gst/gst.h> #include <gst/gst.h>
#include "gstxvid.h" #include "gstxvid.h"
#ifdef __cplusplus G_BEGIN_DECLS
extern "C" {
#endif /* __cplusplus */
#define GST_TYPE_XVIDDEC \ #define GST_TYPE_XVIDDEC \
(gst_xviddec_get_type()) (gst_xviddec_get_type())
@ -52,9 +49,16 @@ struct _GstXvidDec {
void *handle; void *handle;
/* video (output) settings */ /* video (output) settings */
gint csp, bpp, stride; gint csp;
gint width, height; gint width, height;
gint fps_n, fps_d; gint fps_n, fps_d, par_n, par_d;
/* whether in need for keyframe */
gboolean waiting_for_key;
/* retain some info on delayed frame */
gboolean have_ts;
GstClockTime next_ts, next_dur;
}; };
struct _GstXvidDecClass { struct _GstXvidDecClass {
@ -63,8 +67,6 @@ struct _GstXvidDecClass {
GType gst_xviddec_get_type(void); GType gst_xviddec_get_type(void);
#ifdef __cplusplus G_END_DECLS
}
#endif /* __cplusplus */
#endif /* __GST_XVIDDEC_H__ */ #endif /* __GST_XVIDDEC_H__ */

1075
ext/xvid/gstxvidenc.c
View File

File diff suppressed because it is too large Load Diff

89
ext/xvid/gstxvidenc.h
View File

@ -23,10 +23,7 @@
#include <gst/gst.h> #include <gst/gst.h>
#include "gstxvid.h" #include "gstxvid.h"
#ifdef __cplusplus G_BEGIN_DECLS
extern "C" {
#endif /* __cplusplus */
#define GST_TYPE_XVIDENC \ #define GST_TYPE_XVIDENC \
(gst_xvidenc_get_type()) (gst_xvidenc_get_type())
@ -48,24 +45,84 @@ struct _GstXvidEnc {
/* pads */ /* pads */
GstPad *sinkpad, *srcpad; GstPad *sinkpad, *srcpad;
/* xvid handle */
void *handle;
/* cache in place */
xvid_enc_frame_t *xframe_cache;
/* caps information */
gint csp;
gint width, height;
gint fbase;
gint fincr;
gint par_width;
gint par_height;
/* delayed buffers if bframe usage */
GQueue *delay;
/* encoding profile */ /* encoding profile */
gint profile; gint profile;
/* quantizer type; h263, MPEG */
gint quant_type;
/* encoding type; cbr, vbr, quant */
gint pass;
/* quality of encoded image */ /* quality of encoded image */
gint bitrate; gint bitrate;
gint buffer_size; gint quant;
/* max number of B frames between I/P */ /* gop */
gint max_b_frames;
/* max key interval */
gint max_key_interval; gint max_key_interval;
gboolean closed_gop;
/* xvid handle */ /* motion estimation */
void *handle; gint motion;
gint csp; gboolean me_chroma;
gint width, height, stride; gint me_vhq;
gint fps_n, fps_d; gboolean me_quarterpel;
/* lumimasking */
gboolean lumimasking;
/* b-frames */
gint max_bframes;
gint bquant_ratio;
gint bquant_offset;
gint bframe_threshold;
/* misc */
gboolean gmc;
gboolean trellis;
gboolean interlaced;
gboolean cartoon;
gboolean greyscale;
gboolean hqacpred;
/* quantizer ranges */
gint max_iquant, min_iquant;
gint max_pquant, min_pquant;
gint max_bquant, min_bquant;
/* cbr (single pass) encoding */
gint reaction_delay_factor;
gint averaging_period;
gint buffer;
/* vbr (2pass) encoding */
gchar *filename;
gint keyframe_boost;
gint curve_compression_high;
gint curve_compression_low;
gint overflow_control_strength;
gint max_overflow_improvement;
gint max_overflow_degradation;
gint kfreduction;
gint kfthreshold;
gint container_frame_overhead;
}; };
struct _GstXvidEncClass { struct _GstXvidEncClass {
@ -77,8 +134,6 @@ struct _GstXvidEncClass {
GType gst_xvidenc_get_type(void); GType gst_xvidenc_get_type(void);
#ifdef __cplusplus G_END_DECLS
}
#endif /* __cplusplus */
#endif /* __GST_XVIDENC_H__ */ #endif /* __GST_XVIDENC_H__ */