mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-22 00:06:36 +00:00
Code Issues 1 Projects Releases Wiki Activity

sys/glsink/: Use new GstVideoFormat checked into -base. Add new glupload element to upload raw video into a GLXPixbu...

Browse source 
Original commit message from CVS:
* sys/glsink/Makefile.am:
* sys/glsink/glimagesink.c:
* sys/glsink/glimagesink.h:
* sys/glsink/glvideo.c:
* sys/glsink/glvideo.h:
* sys/glsink/gstopengl.c:
* sys/glsink/gstglupload.c:
Use new GstVideoFormat checked into -base.  Add new glupload
element to upload raw video into a GLXPixbuf.  Untested.  Will
likely crash your motorcycle if you try it.
* sys/glsink/gstvideo-common.c:
* sys/glsink/gstvideo-common.h:
Remove.
This commit is contained in:
David Schleef 2007-12-18 01:25:58 +00:00
parent 45e90efd1b
commit 4625e68226
11 changed files with 236 additions and 666 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
ChangeLog
View file

@ -1,3 +1,19 @@
2007-12-17 David Schleef <ds@schleef.org>
* sys/glsink/Makefile.am:
* sys/glsink/glimagesink.c:
* sys/glsink/glimagesink.h:
* sys/glsink/glvideo.c:
* sys/glsink/glvideo.h:
* sys/glsink/gstopengl.c:
* sys/glsink/gstglupload.c:
Use new GstVideoFormat checked into -base. Add new glupload
element to upload raw video into a GLXPixbuf. Untested. Will
likely crash your motorcycle if you try it.
* sys/glsink/gstvideo-common.c:
* sys/glsink/gstvideo-common.h:
Remove.
2007-12-17 David Schleef <ds@schleef.org>
* gst/multifile/gstmultifilesrc.c:

2
common

@ -1 +1 @@
Subproject commit 208ef72f86e944e6ba6941c68e57ffcea8d2a8f4
Subproject commit 67b8f4e3c576945f4d778c9040876af3a5a0756e

9
sys/glsink/Makefile.am
View file

@ -5,8 +5,9 @@ libgstglimagesink_la_SOURCES = \
glimagesink.c \
glvideo.c \
gstopengl.c \
gstvideo-common.c \
glextensions.c
glextensions.c \
gstglbuffer.c \
gstglupload.c
libgstglimagesink_la_CFLAGS = $(GST_CFLAGS) $(X_CFLAGS) $(GST_BASE_CFLAGS) \
$(GST_PLUGINS_BASE_CFLAGS)
libgstglimagesink_la_LIBADD = $(X_LIBS) $(XSHM_LIBS) -lGL \
@ -16,6 +17,6 @@ libgstglimagesink_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
noinst_HEADERS = \
glimagesink.h \
gstvideo-common.h \
glvideo.h \
glextensions.h
glextensions.h \
gstglbuffer.h

2
sys/glsink/glimagesink.c
View file

@ -402,7 +402,7 @@ gst_glimage_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
gst_caps_unref (intersection);
ok = gst_video_parse_caps (caps, &format, &width, &height);
ok = gst_video_format_parse_caps (caps, &format, &width, &height);
ok &= gst_video_parse_caps_framerate (caps, &fps_n, &fps_d);
ok &= gst_video_parse_caps_pixel_aspect_ratio (caps, &par_n, &par_d);

1
sys/glsink/glimagesink.h
View file

@ -27,7 +27,6 @@
#include <gst/video/video.h>
#include "glvideo.h"
#include <gstvideo-common.h>
GST_DEBUG_CATEGORY_EXTERN (gst_debug_glimage_sink);

12
sys/glsink/glvideo.c
View file

@ -182,6 +182,18 @@ gst_gl_display_free (GstGLDisplay * display)
g_free (display);
}
void
gst_gl_display_lock (GstGLDisplay * display)
{
g_mutex_lock (display->lock);
}
void
gst_gl_display_unlock (GstGLDisplay * display)
{
g_mutex_unlock (display->lock);
}
/* drawable */

2
sys/glsink/glvideo.h
View file

@ -53,6 +53,8 @@ GstGLDisplay *gst_gl_display_new (const char *display_name);
gboolean gst_gl_display_can_handle_type (GstGLDisplay *display,
GstGLImageType type);
void gst_gl_display_free (GstGLDisplay *display);
void gst_gl_display_lock (GstGLDisplay *display);
void gst_gl_display_unlock (GstGLDisplay *display);
/* drawable */

186
sys/glsink/gstglupload.c Normal file
View file

@ -0,0 +1,186 @@
/*
* GStreamer
* Copyright (C) 2007 David Schleef <ds@schleef.org>
*
* 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 <gst/gst.h>
#include <gst/video/video.h>
#include <gstglbuffer.h>
#define GST_CAT_DEFAULT gst_gl_upload_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
#define GST_TYPE_GL_UPLOAD (gst_gl_upload_get_type())
#define GST_GL_UPLOAD(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GL_UPLOAD,GstGLUpload))
#define GST_IS_GL_UPLOAD(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_GL_UPLOAD))
#define GST_GL_UPLOAD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass) ,GST_TYPE_GL_UPLOAD,GstGLUploadClass))
#define GST_IS_GL_UPLOAD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass) ,GST_TYPE_GL_UPLOAD))
#define GST_GL_UPLOAD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj) ,GST_TYPE_GL_UPLOAD,GstGLUploadClass))
typedef struct _GstGLUpload GstGLUpload;
typedef struct _GstGLUploadClass GstGLUploadClass;
typedef void (*GstGLUploadProcessFunc) (GstGLUpload *, guint8 *, guint);
struct _GstGLUpload
{
GstElement element;
GstPad *srcpad;
GstPad *sinkpad;
/* < private > */
GstGLDisplay *display;
GstVideoFormat format;
int width;
int height;
};
struct _GstGLUploadClass
{
GstElementClass element_class;
};
static const GstElementDetails element_details = GST_ELEMENT_DETAILS ("FIXME",
"Filter/Effect",
"FIXME example filter",
"FIXME <fixme@fixme.com>");
#define GST_GL_VIDEO_CAPS "video/x-raw-gl"
static GstStaticPadTemplate gst_gl_upload_src_pad_template =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (GST_GL_VIDEO_CAPS)
);
static GstStaticPadTemplate gst_gl_upload_sink_pad_template =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (GST_VIDEO_CAPS_RGBx)
);
enum
{
PROP_0
};
#define DEBUG_INIT(bla) \
GST_DEBUG_CATEGORY_INIT (gst_gl_upload_debug, "glupload", 0, "glupload element");
GST_BOILERPLATE_FULL (GstGLUpload, gst_gl_upload, GstElement,
GST_TYPE_ELEMENT, DEBUG_INIT);
static void gst_gl_upload_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_gl_upload_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static GstFlowReturn gst_gl_upload_chain (GstPad * pad, GstBuffer * buf);
static void gst_gl_upload_reset (GstGLUpload * upload);
static void
gst_gl_upload_base_init (gpointer klass)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
gst_element_class_set_details (element_class, &element_details);
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&gst_gl_upload_src_pad_template));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&gst_gl_upload_sink_pad_template));
}
static void
gst_gl_upload_class_init (GstGLUploadClass * klass)
{
GObjectClass *gobject_class;
gobject_class = (GObjectClass *) klass;
gobject_class->set_property = gst_gl_upload_set_property;
gobject_class->get_property = gst_gl_upload_get_property;
}
static void
gst_gl_upload_init (GstGLUpload * upload, GstGLUploadClass * klass)
{
gst_pad_set_chain_function (upload->sinkpad, gst_gl_upload_chain);
gst_gl_upload_reset (upload);
}
static void
gst_gl_upload_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
//GstGLUpload *upload = GST_GL_UPLOAD (object);
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_gl_upload_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
//GstGLUpload *upload = GST_GL_UPLOAD (object);
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_gl_upload_reset (GstGLUpload * upload)
{
}
static GstFlowReturn
gst_gl_upload_chain (GstPad * pad, GstBuffer * buf)
{
GstGLUpload *upload;
GstGLBuffer *outbuf;
upload = GST_GL_UPLOAD (gst_pad_get_parent (pad));
outbuf = gst_gl_buffer_new (upload->display, upload->format,
upload->width, upload->height);
gst_buffer_copy_metadata (GST_BUFFER (outbuf), buf,
GST_BUFFER_COPY_TIMESTAMPS | GST_BUFFER_COPY_FLAGS);
gst_gl_buffer_upload (outbuf, GST_BUFFER_DATA (buf));
gst_pad_push (upload->srcpad, GST_BUFFER (outbuf));
gst_object_unref (upload);
return GST_FLOW_OK;
}

13
sys/glsink/gstopengl.c
View file

@ -32,6 +32,9 @@
#include <glimagesink.h>
GType gst_gl_upload_get_type (void);
static gboolean
plugin_init (GstPlugin * plugin)
{
@ -42,6 +45,16 @@ plugin_init (GstPlugin * plugin)
GST_RANK_MARGINAL, GST_TYPE_GLIMAGE_SINK)) {
return FALSE;
}
if (!gst_element_register (plugin, "glupload",
GST_RANK_MARGINAL, gst_gl_upload_get_type ())) {
return FALSE;
}
#if 0
if (!gst_element_register (plugin, "gldownload",
GST_RANK_MARGINAL, GST_TYPE_GL_DOWNLOAD)) {
return FALSE;
}
#endif
return TRUE;
}

604
sys/glsink/gstvideo-common.c
View file

@ -1,604 +0,0 @@
/* gstvideo-common.c
* Copyright (C) 2007 David A. Schleef <ds@schleef.org>
*
* 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 <gstvideo-common.h>
gboolean
gst_video_parse_caps (GstCaps * caps, GstVideoFormat * format, int *width,
int *height)
{
GstStructure *structure;
gboolean ok = TRUE;
if (!gst_caps_is_fixed (caps))
return FALSE;
structure = gst_caps_get_structure (caps, 0);
if (format) {
if (gst_structure_has_name (structure, "video/x-raw-yuv")) {
guint32 fourcc;
ok &= gst_structure_get_fourcc (structure, "format", &fourcc);
*format = gst_video_fourcc_to_format (fourcc);
if (*format == GST_VIDEO_FORMAT_UNKNOWN) {
ok = FALSE;
}
} else if (gst_structure_has_name (structure, "video/x-raw-rgb")) {
int depth;
int bpp;
int endianness;
int red_mask;
int green_mask;
int blue_mask;
ok &= gst_structure_get_int (structure, "depth", &depth);
ok &= gst_structure_get_int (structure, "bpp", &bpp);
ok &= gst_structure_get_int (structure, "endianness", &endianness);
ok &= gst_structure_get_int (structure, "red_mask", &red_mask);
ok &= gst_structure_get_int (structure, "green_mask", &green_mask);
ok &= gst_structure_get_int (structure, "blue_mask", &blue_mask);
if (depth != 24 || bpp != 32 || endianness != G_BIG_ENDIAN) {
ok = FALSE;
} else {
*format = gst_video_rgb32_masks_to_format (red_mask, green_mask,
blue_mask);
if (*format == GST_VIDEO_FORMAT_UNKNOWN) {
ok = FALSE;
}
}
} else {
ok = FALSE;
}
}
if (width) {
ok &= gst_structure_get_int (structure, "width", width);
}
if (height) {
ok &= gst_structure_get_int (structure, "height", height);
}
return ok;
}
gboolean
gst_video_parse_caps_framerate (GstCaps * caps, int *fps_n, int *fps_d)
{
GstStructure *structure;
if (!gst_caps_is_fixed (caps))
return FALSE;
structure = gst_caps_get_structure (caps, 0);
return gst_structure_get_fraction (structure, "framerate", fps_n, fps_d);
}
gboolean
gst_video_parse_caps_pixel_aspect_ratio (GstCaps * caps, int *par_n, int *par_d)
{
GstStructure *structure;
if (!gst_caps_is_fixed (caps))
return FALSE;
structure = gst_caps_get_structure (caps, 0);
if (!gst_structure_get_fraction (structure, "pixel-aspect-ratio",
par_n, par_d)) {
*par_n = 1;
*par_d = 1;
}
return TRUE;
}
GstCaps *
gst_video_create_caps (GstVideoFormat format, int width, int height,
int framerate_n, int framerate_d, int par_n, int par_d)
{
if (gst_video_format_is_yuv (format)) {
return gst_caps_new_simple ("video/x-raw-yuv",
"format", GST_TYPE_FOURCC, gst_video_format_to_fourcc (format),
"width", G_TYPE_INT, width,
"height", G_TYPE_INT, height,
"framerate", GST_TYPE_FRACTION, framerate_n, framerate_d,
"pixel-aspect-ratio", GST_TYPE_FRACTION, par_n, par_d, NULL);
}
if (gst_video_format_is_rgb (format)) {
int red_mask;
int blue_mask;
int green_mask;
red_mask =
0xff000000U >> gst_video_format_get_component_offset (format, 0, width,
height);
green_mask =
0xff000000U >> gst_video_format_get_component_offset (format, 1, width,
height);
blue_mask =
0xff000000U >> gst_video_format_get_component_offset (format, 2, width,
height);
return gst_caps_new_simple ("video/x-raw-rgb",
"bpp", G_TYPE_INT, 32,
"depth", G_TYPE_INT, 24,
"endianness", G_TYPE_INT, G_BIG_ENDIAN,
"red_mask", G_TYPE_INT, red_mask,
"green_mask", G_TYPE_INT, green_mask,
"blue_mask", G_TYPE_INT, blue_mask,
"width", G_TYPE_INT, width,
"height", G_TYPE_INT, height,
"framerate", GST_TYPE_FRACTION, framerate_n, framerate_d,
"pixel-aspect-ratio", GST_TYPE_FRACTION, par_n, par_d, NULL);
}
return NULL;
}
GstVideoFormat
gst_video_fourcc_to_format (guint32 fourcc)
{
switch (fourcc) {
case GST_MAKE_FOURCC ('I', '4', '2', '0'):
return GST_VIDEO_FORMAT_I420;
case GST_MAKE_FOURCC ('Y', 'V', '1', '2'):
return GST_VIDEO_FORMAT_YV12;
case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
return GST_VIDEO_FORMAT_YUY2;
case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'):
return GST_VIDEO_FORMAT_UYVY;
case GST_MAKE_FOURCC ('A', 'Y', 'U', 'V'):
return GST_VIDEO_FORMAT_AYUV;
default:
return GST_VIDEO_FORMAT_UNKNOWN;
}
}
guint32
gst_video_format_to_fourcc (GstVideoFormat format)
{
switch (format) {
case GST_VIDEO_FORMAT_I420:
return GST_MAKE_FOURCC ('I', '4', '2', '0');
case GST_VIDEO_FORMAT_YV12:
return GST_MAKE_FOURCC ('Y', 'V', '1', '2');
case GST_VIDEO_FORMAT_YUY2:
return GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');
case GST_VIDEO_FORMAT_UYVY:
return GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y');
case GST_VIDEO_FORMAT_AYUV:
return GST_MAKE_FOURCC ('A', 'Y', 'U', 'V');
default:
return 0;
}
}
GstVideoFormat
gst_video_rgb32_masks_to_format (int red_mask, int green_mask, int blue_mask)
{
if (red_mask == 0xff000000 && green_mask == 0x00ff0000 &&
blue_mask == 0x0000ff00) {
return GST_VIDEO_FORMAT_RGBx;
}
if (red_mask == 0x0000ff00 && green_mask == 0x00ff0000 &&
blue_mask == 0xff000000) {
return GST_VIDEO_FORMAT_BGRx;
}
if (red_mask == 0x00ff0000 && green_mask == 0x0000ff00 &&
blue_mask == 0x000000ff) {
return GST_VIDEO_FORMAT_xRGB;
}
if (red_mask == 0x000000ff && green_mask == 0x0000ff00 &&
blue_mask == 0x00ff0000) {
return GST_VIDEO_FORMAT_xBGR;
}
return GST_VIDEO_FORMAT_UNKNOWN;
}
gboolean
gst_video_format_is_rgb (GstVideoFormat format)
{
switch (format) {
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
case GST_VIDEO_FORMAT_AYUV:
return FALSE;
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
return TRUE;
default:
return FALSE;
}
}
gboolean
gst_video_format_is_yuv (GstVideoFormat format)
{
switch (format) {
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
case GST_VIDEO_FORMAT_AYUV:
return TRUE;
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
return FALSE;
default:
return FALSE;
}
}
gboolean
gst_video_format_has_alpha (GstVideoFormat format)
{
switch (format) {
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
return FALSE;
case GST_VIDEO_FORMAT_AYUV:
return TRUE;
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
return FALSE;
default:
return FALSE;
}
}
int
gst_video_format_get_row_stride (GstVideoFormat format, int component,
int width)
{
switch (format) {
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
if (component == 0) {
return GST_ROUND_UP_4 (width);
} else {
return GST_ROUND_UP_4 (GST_ROUND_UP_2 (width) / 2);
}
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
return GST_ROUND_UP_4 (width * 2);
case GST_VIDEO_FORMAT_AYUV:
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
return width * 4;
default:
return 0;
}
}
int
gst_video_format_get_pixel_stride (GstVideoFormat format, int component)
{
switch (format) {
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
return 1;
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
if (component == 0) {
return 2;
} else {
return 4;
}
case GST_VIDEO_FORMAT_AYUV:
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
return 4;
default:
return 0;
}
}
int
gst_video_format_get_component_width (GstVideoFormat format, int component,
int width)
{
switch (format) {
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
if (component == 0) {
return width;
} else {
return GST_ROUND_UP_2 (width) / 2;
}
case GST_VIDEO_FORMAT_AYUV:
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
return width;
default:
return 0;
}
}
int
gst_video_format_get_component_height (GstVideoFormat format, int component,
int height)
{
switch (format) {
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
if (component == 0) {
return height;
} else {
return GST_ROUND_UP_2 (height) / 2;
}
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
case GST_VIDEO_FORMAT_AYUV:
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
return height;
default:
return 0;
}
}
int
gst_video_format_get_component_offset (GstVideoFormat format, int component,
int width, int height)
{
switch (format) {
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
if (component == 0) {
return 0;
} else {
int offset;
offset = GST_ROUND_UP_4 (width) * GST_ROUND_UP_2 (height);
if (component == 2) {
offset += GST_ROUND_UP_4 (GST_ROUND_UP_2 (width) / 2) *
(GST_ROUND_UP_2 (height) / 2);
}
return offset;
}
case GST_VIDEO_FORMAT_YUY2:
if (component == 0)
return 0;
if (component == 1)
return 1;
if (component == 2)
return 3;
return 0;
case GST_VIDEO_FORMAT_UYVY:
if (component == 0)
return 1;
if (component == 1)
return 0;
if (component == 2)
return 2;
return 0;
case GST_VIDEO_FORMAT_AYUV:
if (component == 0)
return 1;
if (component == 1)
return 2;
if (component == 2)
return 3;
if (component == 3)
return 0;
return 0;
case GST_VIDEO_FORMAT_RGBx:
if (component == 0)
return 0;
if (component == 1)
return 1;
if (component == 2)
return 2;
if (component == 3)
return 3;
return 0;
case GST_VIDEO_FORMAT_BGRx:
if (component == 0)
return 2;
if (component == 1)
return 1;
if (component == 2)
return 0;
if (component == 3)
return 3;
return 0;
case GST_VIDEO_FORMAT_xRGB:
if (component == 0)
return 1;
if (component == 1)
return 2;
if (component == 2)
return 3;
if (component == 3)
return 0;
return 0;
case GST_VIDEO_FORMAT_xBGR:
if (component == 0)
return 3;
if (component == 1)
return 2;
if (component == 2)
return 1;
if (component == 3)
return 0;
return 0;
default:
return 0;
}
}
int
gst_video_format_get_size (GstVideoFormat format, int width, int height)
{
int size;
switch (format) {
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
size = GST_ROUND_UP_4 (width) * GST_ROUND_UP_2 (height);
size += GST_ROUND_UP_4 (GST_ROUND_UP_2 (width) / 2) *
(GST_ROUND_UP_2 (height) / 2) * 2;
return size;
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
return GST_ROUND_UP_4 (width * 2) * height;
case GST_VIDEO_FORMAT_AYUV:
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
return width * 4 * height;
default:
return 0;
}
}
gboolean
gst_video_convert (GstVideoFormat format, int width, int height,
int fps_n, int fps_d,
GstFormat src_format, gint64 src_value,
GstFormat dest_format, gint64 * dest_value)
{
gboolean ret = FALSE;
int size;
size = gst_video_format_get_size (format, width, height);
GST_DEBUG ("converting value %" G_GINT64_FORMAT " from %s to %s",
src_value, gst_format_get_name (src_format),
gst_format_get_name (dest_format));
if (src_format == dest_format) {
*dest_value = src_value;
ret = TRUE;
goto done;
}
if (src_value == -1) {
*dest_value = -1;
ret = TRUE;
goto done;
}
/* bytes to frames */
if (src_format == GST_FORMAT_BYTES && dest_format == GST_FORMAT_DEFAULT) {
if (size != 0) {
*dest_value = gst_util_uint64_scale_int (src_value, 1, size);
} else {
GST_ERROR ("blocksize is 0");
*dest_value = 0;
}
ret = TRUE;
goto done;
}
/* frames to bytes */
if (src_format == GST_FORMAT_DEFAULT && dest_format == GST_FORMAT_BYTES) {
*dest_value = gst_util_uint64_scale_int (src_value, size, 1);
ret = TRUE;
goto done;
}
/* time to frames */
if (src_format == GST_FORMAT_TIME && dest_format == GST_FORMAT_DEFAULT) {
if (fps_d != 0) {
*dest_value = gst_util_uint64_scale (src_value,
fps_n, GST_SECOND * fps_d);
} else {
GST_ERROR ("framerate denominator is 0");
*dest_value = 0;
}
ret = TRUE;
goto done;
}
/* frames to time */
if (src_format == GST_FORMAT_DEFAULT && dest_format == GST_FORMAT_TIME) {
if (fps_n != 0) {
*dest_value = gst_util_uint64_scale (src_value,
GST_SECOND * fps_d, fps_n);
} else {
GST_ERROR ("framerate numerator is 0");
*dest_value = 0;
}
ret = TRUE;
goto done;
}
/* time to bytes */
if (src_format == GST_FORMAT_TIME && dest_format == GST_FORMAT_BYTES) {
if (fps_d != 0) {
*dest_value = gst_util_uint64_scale (src_value,
fps_n * size, GST_SECOND * fps_d);
} else {
GST_ERROR ("framerate denominator is 0");
*dest_value = 0;
}
ret = TRUE;
goto done;
}
/* bytes to time */
if (src_format == GST_FORMAT_BYTES && dest_format == GST_FORMAT_TIME) {
if (fps_n != 0 && size != 0) {
*dest_value = gst_util_uint64_scale (src_value,
GST_SECOND * fps_d, fps_n * size);
} else {
GST_ERROR ("framerate denominator and/or blocksize is 0");
*dest_value = 0;
}
ret = TRUE;
}
done:
GST_DEBUG ("ret=%d result %" G_GINT64_FORMAT, ret, *dest_value);
return ret;
}

55
sys/glsink/gstvideo-common.h
View file

@ -1,55 +0,0 @@
#ifndef __GST_VIDEO_COMMON_H__
#define __GST_VIDEO_COMMON_H__
#include <gst/gst.h>
#include <gst/video/video.h>
typedef enum {
GST_VIDEO_FORMAT_UNKNOWN,
GST_VIDEO_FORMAT_I420,
GST_VIDEO_FORMAT_YV12,
GST_VIDEO_FORMAT_YUY2,
GST_VIDEO_FORMAT_UYVY,
GST_VIDEO_FORMAT_AYUV,
GST_VIDEO_FORMAT_RGBx,
GST_VIDEO_FORMAT_BGRx,
GST_VIDEO_FORMAT_xRGB,
GST_VIDEO_FORMAT_xBGR
} GstVideoFormat;
gboolean gst_video_parse_caps (GstCaps *caps, GstVideoFormat *format,
int *width, int *height);
gboolean gst_video_parse_caps_framerate (GstCaps *caps,
int *fps_n, int *fps_d);
gboolean gst_video_parse_caps_pixel_aspect_ratio (GstCaps *caps,
int *par_n, int *par_d);
GstCaps * gst_video_create_caps (GstVideoFormat format,
int width, int height, int framerate_n, int framerate_d,
int par_n, int par_d);
GstVideoFormat gst_video_fourcc_to_format (guint32 fourcc);
guint32 gst_video_format_to_fourcc (GstVideoFormat format);
GstVideoFormat gst_video_rgb32_masks_to_format (int red_mask, int green_mask, int blue_mask);
gboolean gst_video_format_is_rgb (GstVideoFormat format);
gboolean gst_video_format_is_yuv (GstVideoFormat format);
gboolean gst_video_format_has_alpha (GstVideoFormat format);
int gst_video_format_get_row_stride (GstVideoFormat format, int component,
int width);
int gst_video_format_get_pixel_stride (GstVideoFormat format, int component);
int gst_video_format_get_component_width (GstVideoFormat format, int component,
int width);
int gst_video_format_get_component_height (GstVideoFormat format, int component,
int height);
int gst_video_format_get_component_offset (GstVideoFormat format, int component,
int width, int height);
int gst_video_format_get_size (GstVideoFormat format, int width, int height);
gboolean gst_video_convert (GstVideoFormat format, int width, int height,
int fps_n, int fps_d,
GstFormat src_format, gint64 src_value,
GstFormat dest_format, gint64 * dest_value);
#endif