mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-06 01:19:38 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-base/gst-libs/gst/video/video-overlay-composition.c

1642 lines
54 KiB
C
Raw Blame History

/* GStreamer Video Overlay Composition
* Copyright (C) 2011 Intel Corporation
* Copyright (C) 2011 Collabora Ltd.
* Copyright (C) 2011 Tim-Philipp Müller <tim centricular net>
*
* 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.
*/
/**
* SECTION:gstvideooverlaycomposition
* @title: GstVideoOverlayRectangle
* @short_description: Video Buffer Overlay Compositions (Subtitles, Logos)
*
* Functions to create and handle overlay compositions on video buffers.
*
* An overlay composition describes one or more overlay rectangles to be
* blended on top of a video buffer.
*
* This API serves two main purposes:
*
* * it can be used to attach overlay information (subtitles or logos)
* to non-raw video buffers such as GL/VAAPI/VDPAU surfaces. The actual
* blending of the overlay can then be done by e.g. the video sink that
* processes these non-raw buffers.
*
* * it can also be used to blend overlay rectangles on top of raw video
* buffers, thus consolidating blending functionality for raw video in
* one place.
*
* Together, this allows existing overlay elements to easily handle raw
* and non-raw video as input in without major changes (once the overlays
* have been put into a #GstVideoOverlayComposition object anyway) - for raw
* video the overlay can just use the blending function to blend the data
* on top of the video, and for surface buffers it can just attach them to
* the buffer and let the sink render the overlays.
*
*/
/* TODO:
* - provide accessors for seq_num and other fields (as needed)
* - allow overlay to set/get original pango markup string on/from rectangle
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "video-overlay-composition.h"
#include "video-blend.h"
#include "gstvideometa.h"
#include <string.h>
struct _GstVideoOverlayComposition
{
GstMiniObject parent;
guint num_rectangles;
GstVideoOverlayRectangle **rectangles;
/* lowest rectangle sequence number still used by the upstream
* overlay element. This way a renderer maintaining some kind of
* rectangles <-> surface cache can know when to free cached
* surfaces/rectangles. */
guint min_seq_num_used;
/* sequence number for the composition (same series as rectangles) */
guint seq_num;
};
struct _GstVideoOverlayRectangle
{
GstMiniObject parent;
/* Position on video frame and dimension of output rectangle in
* output frame terms (already adjusted for the PAR of the output
* frame). x/y can be negative (overlay will be clipped then) */
gint x, y;
guint render_width, render_height;
/* Info on overlay pixels (format, width, height) */
GstVideoInfo info;
/* The flags associated to this rectangle */
GstVideoOverlayFormatFlags flags;
/* Refcounted blob of memory, no caps or timestamps */
GstBuffer *pixels;
/* FIXME: how to express source like text or pango markup?
* (just add source type enum + source buffer with data)
*
* FOR 0.10: always send pixel blobs, but attach source data in
* addition (reason: if downstream changes, we can't renegotiate
* that properly, if we just do a query of supported formats from
* the start). Sink will just ignore pixels and use pango markup
* from source data if it supports that.
*
* FOR 0.11: overlay should query formats (pango markup, pixels)
* supported by downstream and then only send that. We can
* renegotiate via the reconfigure event.
*/
/* sequence number: useful for backends/renderers/sinks that want
* to maintain a cache of rectangles <-> surfaces. The value of
* the min_seq_num_used in the composition tells the renderer which
* rectangles have expired. */
guint seq_num;
/* global alpha: global alpha value of the rectangle. Each each per-pixel
* alpha value of image-data will be multiplied with the global alpha value
* during blending.
* Can be used for efficient fading in/out of overlay rectangles.
* GstElements that render OverlayCompositions and don't support global alpha
* should simply ignore it.*/
gfloat global_alpha;
/* track alpha-values already applied: */
gfloat applied_global_alpha;
/* store initial per-pixel alpha values: */
guint8 *initial_alpha;
/* FIXME: we may also need a (private) way to cache converted/scaled
* pixel blobs */
GMutex lock;
GList *scaled_rectangles;
};
#define GST_RECTANGLE_LOCK(rect) g_mutex_lock(&rect->lock)
#define GST_RECTANGLE_UNLOCK(rect) g_mutex_unlock(&rect->lock)
/* --------------------------- utility functions --------------------------- */
#ifndef GST_DISABLE_GST_DEBUG
#define GST_CAT_DEFAULT ensure_debug_category()
static GstDebugCategory *
ensure_debug_category (void)
{
static gsize cat_gonce = 0;
if (g_once_init_enter (&cat_gonce)) {
gsize cat_done;
cat_done = (gsize) _gst_debug_category_new ("video-composition", 0,
"video overlay composition");
g_once_init_leave (&cat_gonce, cat_done);
}
return (GstDebugCategory *) cat_gonce;
}
#else
#define ensure_debug_category() /* NOOP */
#endif /* GST_DISABLE_GST_DEBUG */
static guint
gst_video_overlay_get_seqnum (void)
{
static gint seqnum; /* 0 */
return (guint) g_atomic_int_add (&seqnum, 1);
}
static gboolean
gst_video_overlay_composition_meta_init (GstMeta * meta, gpointer params,
GstBuffer * buf)
{
GstVideoOverlayCompositionMeta *ometa;
ometa = (GstVideoOverlayCompositionMeta *) meta;
ometa->overlay = NULL;
return TRUE;
}
static void
gst_video_overlay_composition_meta_free (GstMeta * meta, GstBuffer * buf)
{
GstVideoOverlayCompositionMeta *ometa;
ometa = (GstVideoOverlayCompositionMeta *) meta;
if (ometa->overlay)
gst_video_overlay_composition_unref (ometa->overlay);
}
static gboolean
gst_video_overlay_composition_meta_transform (GstBuffer * dest, GstMeta * meta,
GstBuffer * buffer, GQuark type, gpointer data)
{
GstVideoOverlayCompositionMeta *dmeta, *smeta;
smeta = (GstVideoOverlayCompositionMeta *) meta;
if (GST_META_TRANSFORM_IS_COPY (type)) {
GstMetaTransformCopy *copy = data;
if (!copy->region) {
GST_DEBUG ("copy video overlay composition metadata");
/* only copy if the complete data is copied as well */
dmeta =
(GstVideoOverlayCompositionMeta *) gst_buffer_add_meta (dest,
GST_VIDEO_OVERLAY_COMPOSITION_META_INFO, NULL);
if (!dmeta)
return FALSE;
dmeta->overlay = gst_video_overlay_composition_ref (smeta->overlay);
}
} else {
/* return FALSE, if transform type is not supported */
return FALSE;
}
return TRUE;
}
GType
gst_video_overlay_composition_meta_api_get_type (void)
{
static GType type = 0;
static const gchar *tags[] = { NULL };
if (g_once_init_enter (&type)) {
GType _type =
gst_meta_api_type_register ("GstVideoOverlayCompositionMetaAPI", tags);
g_once_init_leave (&type, _type);
}
return type;
}
/* video overlay composition metadata */
const GstMetaInfo *
gst_video_overlay_composition_meta_get_info (void)
{
static const GstMetaInfo *video_overlay_composition_meta_info = NULL;
if (g_once_init_enter ((GstMetaInfo **) &
video_overlay_composition_meta_info)) {
const GstMetaInfo *meta =
gst_meta_register (GST_VIDEO_OVERLAY_COMPOSITION_META_API_TYPE,
"GstVideoOverlayCompositionMeta",
sizeof (GstVideoOverlayCompositionMeta),
(GstMetaInitFunction) gst_video_overlay_composition_meta_init,
(GstMetaFreeFunction) gst_video_overlay_composition_meta_free,
(GstMetaTransformFunction)
gst_video_overlay_composition_meta_transform);
g_once_init_leave ((GstMetaInfo **) & video_overlay_composition_meta_info,
(GstMetaInfo *) meta);
}
return video_overlay_composition_meta_info;
}
/**
* gst_buffer_add_video_overlay_composition_meta:
* @buf: a #GstBuffer
* @comp: (allow-none): a #GstVideoOverlayComposition
*
* Sets an overlay composition on a buffer. The buffer will obtain its own
* reference to the composition, meaning this function does not take ownership
* of @comp.
*
* Returns: (transfer none): a #GstVideoOverlayCompositionMeta
*/
GstVideoOverlayCompositionMeta *
gst_buffer_add_video_overlay_composition_meta (GstBuffer * buf,
GstVideoOverlayComposition * comp)
{
GstVideoOverlayCompositionMeta *ometa;
g_return_val_if_fail (gst_buffer_is_writable (buf), NULL);
ometa = (GstVideoOverlayCompositionMeta *)
gst_buffer_add_meta (buf, GST_VIDEO_OVERLAY_COMPOSITION_META_INFO, NULL);
ometa->overlay = gst_video_overlay_composition_ref (comp);
return ometa;
}
/* ------------------------------ composition ------------------------------ */
#define RECTANGLE_ARRAY_STEP 4 /* premature optimization */
GST_DEFINE_MINI_OBJECT_TYPE (GstVideoOverlayComposition,
gst_video_overlay_composition);
static void
gst_video_overlay_composition_free (GstMiniObject * mini_obj)
{
GstVideoOverlayComposition *comp = (GstVideoOverlayComposition *) mini_obj;
guint num;
num = comp->num_rectangles;
while (num > 0) {
gst_mini_object_remove_parent (GST_MINI_OBJECT_CAST (comp->rectangles[num -
1]), GST_MINI_OBJECT_CAST (comp));
gst_video_overlay_rectangle_unref (comp->rectangles[num - 1]);
--num;
}
g_free (comp->rectangles);
comp->rectangles = NULL;
comp->num_rectangles = 0;
g_slice_free (GstVideoOverlayComposition, comp);
}
/**
* gst_video_overlay_composition_new:
* @rectangle: (transfer none) (nullable): a #GstVideoOverlayRectangle to add to the
* composition
*
* Creates a new video overlay composition object to hold one or more
* overlay rectangles.
*
* Note that since 1.20 this allows to pass %NULL for @rectangle.
*
* Returns: (transfer full): a new #GstVideoOverlayComposition. Unref with
* gst_video_overlay_composition_unref() when no longer needed.
*/
GstVideoOverlayComposition *
gst_video_overlay_composition_new (GstVideoOverlayRectangle * rectangle)
{
GstVideoOverlayComposition *comp;
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle)
|| rectangle == NULL, NULL);
comp = g_slice_new0 (GstVideoOverlayComposition);
gst_mini_object_init (GST_MINI_OBJECT_CAST (comp), 0,
GST_TYPE_VIDEO_OVERLAY_COMPOSITION,
(GstMiniObjectCopyFunction) gst_video_overlay_composition_copy,
NULL, (GstMiniObjectFreeFunction) gst_video_overlay_composition_free);
comp->rectangles = g_new0 (GstVideoOverlayRectangle *, RECTANGLE_ARRAY_STEP);
comp->seq_num = gst_video_overlay_get_seqnum ();
comp->min_seq_num_used = comp->seq_num;
GST_LOG ("new composition %p: seq_num %u", comp, comp->seq_num);
if (rectangle) {
/* since the rectangle was created earlier, its seqnum is smaller than ours */
comp->min_seq_num_used = rectangle->seq_num;
gst_video_overlay_composition_add_rectangle (comp, rectangle);
}
return comp;
}
/**
* gst_video_overlay_composition_add_rectangle:
* @comp: a #GstVideoOverlayComposition
* @rectangle: (transfer none): a #GstVideoOverlayRectangle to add to the
* composition
*
* Adds an overlay rectangle to an existing overlay composition object. This
* must be done right after creating the overlay composition.
*/
void
gst_video_overlay_composition_add_rectangle (GstVideoOverlayComposition * comp,
GstVideoOverlayRectangle * rectangle)
{
g_return_if_fail (GST_IS_VIDEO_OVERLAY_COMPOSITION (comp));
g_return_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle));
g_return_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (comp)));
if (comp->num_rectangles % RECTANGLE_ARRAY_STEP == 0) {
comp->rectangles =
g_renew (GstVideoOverlayRectangle *, comp->rectangles,
comp->num_rectangles + RECTANGLE_ARRAY_STEP);
}
comp->rectangles[comp->num_rectangles] =
gst_video_overlay_rectangle_ref (rectangle);
gst_mini_object_add_parent (GST_MINI_OBJECT_CAST (rectangle),
GST_MINI_OBJECT_CAST (comp));
comp->num_rectangles += 1;
comp->min_seq_num_used = MIN (comp->min_seq_num_used, rectangle->seq_num);
GST_LOG ("composition %p: added rectangle %p", comp, rectangle);
}
/**
* gst_video_overlay_composition_n_rectangles:
* @comp: a #GstVideoOverlayComposition
*
* Returns the number of #GstVideoOverlayRectangle<!-- -->s contained in @comp.
*
* Returns: the number of rectangles
*/
guint
gst_video_overlay_composition_n_rectangles (GstVideoOverlayComposition * comp)
{
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_COMPOSITION (comp), 0);
return comp->num_rectangles;
}
/**
* gst_video_overlay_composition_get_rectangle:
* @comp: a #GstVideoOverlayComposition
* @n: number of the rectangle to get
*
* Returns the @n-th #GstVideoOverlayRectangle contained in @comp.
*
* Returns: (transfer none): the @n-th rectangle, or NULL if @n is out of
* bounds. Will not return a new reference, the caller will need to
* obtain her own reference using gst_video_overlay_rectangle_ref()
* if needed.
*/
GstVideoOverlayRectangle *
gst_video_overlay_composition_get_rectangle (GstVideoOverlayComposition * comp,
guint n)
{
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_COMPOSITION (comp), NULL);
if (n >= comp->num_rectangles)
return NULL;
return comp->rectangles[n];
}
static gboolean
gst_video_overlay_rectangle_needs_scaling (GstVideoOverlayRectangle * r)
{
return (GST_VIDEO_INFO_WIDTH (&r->info) != r->render_width ||
GST_VIDEO_INFO_HEIGHT (&r->info) != r->render_height);
}
/**
* gst_video_overlay_composition_blend:
* @comp: a #GstVideoOverlayComposition
* @video_buf: a #GstVideoFrame containing raw video data in a
* supported format. It should be mapped using GST_MAP_READWRITE
*
* Blends the overlay rectangles in @comp on top of the raw video data
* contained in @video_buf. The data in @video_buf must be writable and
* mapped appropriately.
*
* Since @video_buf data is read and will be modified, it ought be
* mapped with flag GST_MAP_READWRITE.
*/
/* FIXME: formats with more than 8 bit per component which get unpacked into
* ARGB64 or AYUV64 (such as v210, v216, UYVP, GRAY16_LE and GRAY16_BE)
* are not supported yet by the code in video-blend.c.
*/
gboolean
gst_video_overlay_composition_blend (GstVideoOverlayComposition * comp,
GstVideoFrame * video_buf)
{
GstVideoInfo scaled_info;
GstVideoInfo *vinfo;
GstVideoFrame rectangle_frame;
GstVideoFormat fmt;
GstBuffer *pixels = NULL;
gboolean ret = TRUE;
guint n, num;
int w, h;
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_COMPOSITION (comp), FALSE);
g_return_val_if_fail (video_buf != NULL, FALSE);
w = GST_VIDEO_FRAME_WIDTH (video_buf);
h = GST_VIDEO_FRAME_HEIGHT (video_buf);
fmt = GST_VIDEO_FRAME_FORMAT (video_buf);
num = comp->num_rectangles;
GST_LOG ("Blending composition %p with %u rectangles onto video buffer %p "
"(%ux%u, format %u)", comp, num, video_buf, w, h, fmt);
for (n = 0; n < num; ++n) {
GstVideoOverlayRectangle *rect;
gboolean needs_scaling;
rect = comp->rectangles[n];
GST_LOG (" rectangle %u %p: %ux%u, format %u", n, rect,
GST_VIDEO_INFO_WIDTH (&rect->info), GST_VIDEO_INFO_HEIGHT (&rect->info),
GST_VIDEO_INFO_FORMAT (&rect->info));
needs_scaling = gst_video_overlay_rectangle_needs_scaling (rect);
if (needs_scaling) {
gst_video_blend_scale_linear_RGBA (&rect->info, rect->pixels,
rect->render_height, rect->render_width, &scaled_info, &pixels);
vinfo = &scaled_info;
} else {
pixels = gst_buffer_ref (rect->pixels);
vinfo = &rect->info;
}
gst_video_frame_map (&rectangle_frame, vinfo, pixels, GST_MAP_READ);
ret = gst_video_blend (video_buf, &rectangle_frame, rect->x, rect->y,
rect->global_alpha);
gst_video_frame_unmap (&rectangle_frame);
if (!ret) {
GST_WARNING ("Could not blend overlay rectangle onto video buffer");
}
/* FIXME: should cache scaled pixels in the rectangle struct */
gst_buffer_unref (pixels);
}
return ret;
}
/**
* gst_video_overlay_composition_copy:
* @comp: (transfer none): a #GstVideoOverlayComposition to copy
*
* Makes a copy of @comp and all contained rectangles, so that it is possible
* to modify the composition and contained rectangles (e.g. add additional
* rectangles or change the render co-ordinates or render dimension). The
* actual overlay pixel data buffers contained in the rectangles are not
* copied.
*
* Returns: (transfer full): a new #GstVideoOverlayComposition equivalent
* to @comp.
*/
GstVideoOverlayComposition *
gst_video_overlay_composition_copy (GstVideoOverlayComposition * comp)
{
GstVideoOverlayComposition *copy;
GstVideoOverlayRectangle *rect;
guint n;
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_COMPOSITION (comp), NULL);
if (G_LIKELY (comp->num_rectangles == 0))
return gst_video_overlay_composition_new (NULL);
rect = gst_video_overlay_rectangle_copy (comp->rectangles[0]);
copy = gst_video_overlay_composition_new (rect);
gst_video_overlay_rectangle_unref (rect);
for (n = 1; n < comp->num_rectangles; ++n) {
rect = gst_video_overlay_rectangle_copy (comp->rectangles[n]);
gst_video_overlay_composition_add_rectangle (copy, rect);
gst_video_overlay_rectangle_unref (rect);
}
return copy;
}
/**
* gst_video_overlay_composition_make_writable:
* @comp: (transfer full): a #GstVideoOverlayComposition to copy
*
* Takes ownership of @comp and returns a version of @comp that is writable
* (i.e. can be modified). Will either return @comp right away, or create a
* new writable copy of @comp and unref @comp itself. All the contained
* rectangles will also be copied, but the actual overlay pixel data buffers
* contained in the rectangles are not copied.
*
* Returns: (transfer full): a writable #GstVideoOverlayComposition
* equivalent to @comp.
*/
GstVideoOverlayComposition *
gst_video_overlay_composition_make_writable (GstVideoOverlayComposition * comp)
{
GstVideoOverlayComposition *writable_comp;
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_COMPOSITION (comp), NULL);
if (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (comp))) {
guint n;
for (n = 0; n < comp->num_rectangles; ++n) {
if (!gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (comp->rectangles
[n])))
goto copy;
}
return comp;
}
copy:
writable_comp = gst_video_overlay_composition_copy (comp);
gst_video_overlay_composition_unref (comp);
return writable_comp;
}
/**
* gst_video_overlay_composition_get_seqnum:
* @comp: a #GstVideoOverlayComposition
*
* Returns the sequence number of this composition. Sequence numbers are
* monotonically increasing and unique for overlay compositions and rectangles
* (meaning there will never be a rectangle with the same sequence number as
* a composition).
*
* Returns: the sequence number of @comp
*/
guint
gst_video_overlay_composition_get_seqnum (GstVideoOverlayComposition * comp)
{
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_COMPOSITION (comp), 0);
return comp->seq_num;
}
/* ------------------------------ rectangles ------------------------------ -*/
GST_DEFINE_MINI_OBJECT_TYPE (GstVideoOverlayRectangle,
gst_video_overlay_rectangle);
static void
gst_video_overlay_rectangle_free (GstMiniObject * mini_obj)
{
GstVideoOverlayRectangle *rect = (GstVideoOverlayRectangle *) mini_obj;
gst_mini_object_remove_parent (GST_MINI_OBJECT_CAST (rect->pixels),
GST_MINI_OBJECT_CAST (rect));
gst_buffer_replace (&rect->pixels, NULL);
while (rect->scaled_rectangles != NULL) {
GstVideoOverlayRectangle *scaled_rect = rect->scaled_rectangles->data;
gst_video_overlay_rectangle_unref (scaled_rect);
rect->scaled_rectangles =
g_list_delete_link (rect->scaled_rectangles, rect->scaled_rectangles);
}
g_free (rect->initial_alpha);
g_mutex_clear (&rect->lock);
g_slice_free (GstVideoOverlayRectangle, rect);
}
static inline gboolean
gst_video_overlay_rectangle_check_flags (GstVideoOverlayFormatFlags flags)
{
/* Check flags only contains flags we know about */
return (flags & ~(GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA |
GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA)) == 0;
}
static gboolean
gst_video_overlay_rectangle_is_same_alpha_type (GstVideoOverlayFormatFlags
flags1, GstVideoOverlayFormatFlags flags2)
{
return ((flags1 ^ flags2) & GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA)
== 0;
}
/**
* gst_video_overlay_rectangle_new_raw:
* @pixels: (transfer none): a #GstBuffer pointing to the pixel memory
* @render_x: the X co-ordinate on the video where the top-left corner of this
* overlay rectangle should be rendered to
* @render_y: the Y co-ordinate on the video where the top-left corner of this
* overlay rectangle should be rendered to
* @render_width: the render width of this rectangle on the video
* @render_height: the render height of this rectangle on the video
* @flags: flags
*
* Creates a new video overlay rectangle with ARGB or AYUV pixel data.
* The layout in case of ARGB of the components in memory is B-G-R-A
* on little-endian platforms
* (corresponding to #GST_VIDEO_FORMAT_BGRA) and A-R-G-B on big-endian
* platforms (corresponding to #GST_VIDEO_FORMAT_ARGB). In other words,
* pixels are treated as 32-bit words and the lowest 8 bits then contain
* the blue component value and the highest 8 bits contain the alpha
* component value. Unless specified in the flags, the RGB values are
* non-premultiplied. This is the format that is used by most hardware,
* and also many rendering libraries such as Cairo, for example.
* The pixel data buffer must have #GstVideoMeta set.
*
* Returns: (transfer full): a new #GstVideoOverlayRectangle. Unref with
* gst_video_overlay_rectangle_unref() when no longer needed.
*/
GstVideoOverlayRectangle *
gst_video_overlay_rectangle_new_raw (GstBuffer * pixels,
gint render_x, gint render_y, guint render_width, guint render_height,
GstVideoOverlayFormatFlags flags)
{
GstVideoOverlayRectangle *rect;
GstVideoMeta *vmeta;
GstVideoFormat format;
guint width, height;
g_return_val_if_fail (GST_IS_BUFFER (pixels), NULL);
g_return_val_if_fail (render_height > 0 && render_width > 0, NULL);
g_return_val_if_fail (gst_video_overlay_rectangle_check_flags (flags), NULL);
/* buffer must have video meta with some expected settings */
vmeta = gst_buffer_get_video_meta (pixels);
g_return_val_if_fail (vmeta, NULL);
g_return_val_if_fail (vmeta->format ==
GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_RGB ||
vmeta->format == GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_YUV, NULL);
g_return_val_if_fail (vmeta->flags == GST_VIDEO_FRAME_FLAG_NONE, NULL);
format = vmeta->format;
width = vmeta->width;
height = vmeta->height;
/* technically ((height-1)*stride)+width might be okay too */
g_return_val_if_fail (gst_buffer_get_size (pixels) >= height * width * 4,
NULL);
g_return_val_if_fail (height > 0 && width > 0, NULL);
rect = g_slice_new0 (GstVideoOverlayRectangle);
gst_mini_object_init (GST_MINI_OBJECT_CAST (rect), 0,
GST_TYPE_VIDEO_OVERLAY_RECTANGLE,
(GstMiniObjectCopyFunction) gst_video_overlay_rectangle_copy,
NULL, (GstMiniObjectFreeFunction) gst_video_overlay_rectangle_free);
g_mutex_init (&rect->lock);
rect->pixels = gst_buffer_ref (pixels);
gst_mini_object_add_parent (GST_MINI_OBJECT_CAST (pixels),
GST_MINI_OBJECT_CAST (rect));
rect->scaled_rectangles = NULL;
gst_video_info_init (&rect->info);
if (!gst_video_info_set_format (&rect->info, format, width, height)) {
gst_mini_object_unref (GST_MINI_OBJECT_CAST (rect));
return NULL;
}
if (flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA)
rect->info.flags |= GST_VIDEO_FLAG_PREMULTIPLIED_ALPHA;
rect->x = render_x;
rect->y = render_y;
rect->render_width = render_width;
rect->render_height = render_height;
rect->global_alpha = 1.0;
rect->applied_global_alpha = 1.0;
rect->initial_alpha = NULL;
rect->flags = flags;
rect->seq_num = gst_video_overlay_get_seqnum ();
GST_LOG ("new rectangle %p: %ux%u => %ux%u @ %u,%u, seq_num %u, format %u, "
"flags %x, pixels %p, global_alpha=%f", rect, width, height, render_width,
render_height, render_x, render_y, rect->seq_num, format,
rect->flags, pixels, rect->global_alpha);
return rect;
}
/**
* gst_video_overlay_rectangle_get_render_rectangle:
* @rectangle: a #GstVideoOverlayRectangle
* @render_x: (out) (allow-none): address where to store the X render offset
* @render_y: (out) (allow-none): address where to store the Y render offset
* @render_width: (out) (allow-none): address where to store the render width
* @render_height: (out) (allow-none): address where to store the render height
*
* Retrieves the render position and render dimension of the overlay
* rectangle on the video.
*
* Returns: TRUE if valid render dimensions were retrieved.
*/
gboolean
gst_video_overlay_rectangle_get_render_rectangle (GstVideoOverlayRectangle *
rectangle, gint * render_x, gint * render_y, guint * render_width,
guint * render_height)
{
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle), FALSE);
if (render_x)
*render_x = rectangle->x;
if (render_y)
*render_y = rectangle->y;
if (render_width)
*render_width = rectangle->render_width;
if (render_height)
*render_height = rectangle->render_height;
return TRUE;
}
/**
* gst_video_overlay_rectangle_set_render_rectangle:
* @rectangle: a #GstVideoOverlayRectangle
* @render_x: render X position of rectangle on video
* @render_y: render Y position of rectangle on video
* @render_width: render width of rectangle
* @render_height: render height of rectangle
*
* Sets the render position and dimensions of the rectangle on the video.
* This function is mainly for elements that modify the size of the video
* in some way (e.g. through scaling or cropping) and need to adjust the
* details of any overlays to match the operation that changed the size.
*
* @rectangle must be writable, meaning its refcount must be 1. You can
* make the rectangles inside a #GstVideoOverlayComposition writable using
* gst_video_overlay_composition_make_writable() or
* gst_video_overlay_composition_copy().
*/
void
gst_video_overlay_rectangle_set_render_rectangle (GstVideoOverlayRectangle *
rectangle, gint render_x, gint render_y, guint render_width,
guint render_height)
{
g_return_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle));
g_return_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST
(rectangle)));
rectangle->x = render_x;
rectangle->y = render_y;
rectangle->render_width = render_width;
rectangle->render_height = render_height;
}
/* FIXME: orc-ify */
static void
gst_video_overlay_rectangle_premultiply_0 (GstVideoFrame * frame)
{
int i, j;
int width = GST_VIDEO_FRAME_WIDTH (frame);
int height = GST_VIDEO_FRAME_HEIGHT (frame);
int stride = GST_VIDEO_FRAME_PLANE_STRIDE (frame, 0);
guint8 *data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
for (j = 0; j < height; ++j) {
guint8 *line;
line = data;
line += stride * j;
for (i = 0; i < width; ++i) {
int a = line[0];
line[1] = line[1] * a / 255;
line[2] = line[2] * a / 255;
line[3] = line[3] * a / 255;
line += 4;
}
}
}
static void
gst_video_overlay_rectangle_premultiply_3 (GstVideoFrame * frame)
{
int i, j;
int width = GST_VIDEO_FRAME_WIDTH (frame);
int height = GST_VIDEO_FRAME_HEIGHT (frame);
int stride = GST_VIDEO_FRAME_PLANE_STRIDE (frame, 0);
guint8 *data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
for (j = 0; j < height; ++j) {
guint8 *line;
line = data;
line += stride * j;
for (i = 0; i < width; ++i) {
int a = line[3];
line[0] = line[0] * a / 255;
line[1] = line[1] * a / 255;
line[2] = line[2] * a / 255;
line += 4;
}
}
}
static void
gst_video_overlay_rectangle_premultiply (GstVideoFrame * frame)
{
gint alpha_offset;
alpha_offset = GST_VIDEO_FRAME_COMP_POFFSET (frame, 3);
switch (alpha_offset) {
case 0:
gst_video_overlay_rectangle_premultiply_0 (frame);
break;
case 3:
gst_video_overlay_rectangle_premultiply_3 (frame);
break;
default:
g_assert_not_reached ();
break;
}
}
/* FIXME: orc-ify */
static void
gst_video_overlay_rectangle_unpremultiply_0 (GstVideoFrame * frame)
{
int i, j;
int width = GST_VIDEO_FRAME_WIDTH (frame);
int height = GST_VIDEO_FRAME_HEIGHT (frame);
int stride = GST_VIDEO_FRAME_PLANE_STRIDE (frame, 0);
guint8 *data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
for (j = 0; j < height; ++j) {
guint8 *line;
line = data;
line += stride * j;
for (i = 0; i < width; ++i) {
int a = line[0];
if (a) {
line[1] = MIN ((line[1] * 255 + a / 2) / a, 255);
line[2] = MIN ((line[2] * 255 + a / 2) / a, 255);
line[3] = MIN ((line[3] * 255 + a / 2) / a, 255);
}
line += 4;
}
}
}
static void
gst_video_overlay_rectangle_unpremultiply_3 (GstVideoFrame * frame)
{
int i, j;
int width = GST_VIDEO_FRAME_WIDTH (frame);
int height = GST_VIDEO_FRAME_HEIGHT (frame);
int stride = GST_VIDEO_FRAME_PLANE_STRIDE (frame, 0);
guint8 *data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
for (j = 0; j < height; ++j) {
guint8 *line;
line = data;
line += stride * j;
for (i = 0; i < width; ++i) {
int a = line[3];
if (a) {
line[0] = MIN ((line[0] * 255 + a / 2) / a, 255);
line[1] = MIN ((line[1] * 255 + a / 2) / a, 255);
line[2] = MIN ((line[2] * 255 + a / 2) / a, 255);
}
line += 4;
}
}
}
static void
gst_video_overlay_rectangle_unpremultiply (GstVideoFrame * frame)
{
gint alpha_offset;
alpha_offset = GST_VIDEO_FRAME_COMP_POFFSET (frame, 3);
switch (alpha_offset) {
case 0:
gst_video_overlay_rectangle_unpremultiply_0 (frame);
break;
case 3:
gst_video_overlay_rectangle_unpremultiply_3 (frame);
break;
default:
g_assert_not_reached ();
break;
}
}
static void
gst_video_overlay_rectangle_extract_alpha (GstVideoOverlayRectangle * rect)
{
guint8 *src, *dst;
GstVideoFrame frame;
gint i, j, w, h, stride, alpha_offset;
alpha_offset = GST_VIDEO_INFO_COMP_POFFSET (&rect->info, 3);
g_return_if_fail (alpha_offset == 0 || alpha_offset == 3);
gst_video_frame_map (&frame, &rect->info, rect->pixels, GST_MAP_READ);
src = GST_VIDEO_FRAME_PLANE_DATA (&frame, 0);
w = GST_VIDEO_INFO_WIDTH (&rect->info);
h = GST_VIDEO_INFO_HEIGHT (&rect->info);
stride = GST_VIDEO_INFO_PLANE_STRIDE (&rect->info, 0);
g_free (rect->initial_alpha);
rect->initial_alpha = g_malloc (w * h);
dst = rect->initial_alpha;
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
*dst = src[alpha_offset];
dst++;
src += 4;
}
src += stride - 4 * w;
}
gst_video_frame_unmap (&frame);
}
static void
gst_video_overlay_rectangle_apply_global_alpha (GstVideoOverlayRectangle * rect,
float global_alpha)
{
guint8 *src, *dst;
GstVideoFrame frame;
gint i, j, w, h, stride;
gint argb_a, argb_r, argb_g, argb_b;
gint alpha_offset;
g_assert (!(rect->applied_global_alpha != 1.0
&& rect->initial_alpha == NULL));
alpha_offset = GST_VIDEO_INFO_COMP_POFFSET (&rect->info, 3);
g_return_if_fail (alpha_offset == 0 || alpha_offset == 3);
if (global_alpha == rect->applied_global_alpha)
return;
if (rect->initial_alpha == NULL)
gst_video_overlay_rectangle_extract_alpha (rect);
src = rect->initial_alpha;
if (!gst_buffer_is_writable (rect->pixels)) {
gst_mini_object_remove_parent (GST_MINI_OBJECT_CAST (rect->pixels),
GST_MINI_OBJECT_CAST (rect));
rect->pixels = gst_buffer_copy (rect->pixels);
gst_mini_object_add_parent (GST_MINI_OBJECT_CAST (rect->pixels),
GST_MINI_OBJECT_CAST (rect));
}
gst_video_frame_map (&frame, &rect->info, rect->pixels, GST_MAP_READ);
dst = GST_VIDEO_FRAME_PLANE_DATA (&frame, 0);
w = GST_VIDEO_INFO_WIDTH (&rect->info);
h = GST_VIDEO_INFO_HEIGHT (&rect->info);
stride = GST_VIDEO_INFO_PLANE_STRIDE (&rect->info, 0);
argb_a = GST_VIDEO_INFO_COMP_POFFSET (&rect->info, 3);
argb_r = (argb_a + 1) % 4;
argb_g = (argb_a + 2) % 4;
argb_b = (argb_a + 3) % 4;
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
guint8 na = (guint8) (*src * global_alpha);
if (! !(rect->flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA)) {
dst[argb_r] =
(guint8) ((double) (dst[argb_r] * 255) / (double) dst[argb_a]) *
na / 255;
dst[argb_g] =
(guint8) ((double) (dst[argb_g] * 255) / (double) dst[argb_a]) *
na / 255;
dst[argb_b] =
(guint8) ((double) (dst[argb_b] * 255) / (double) dst[argb_a]) *
na / 255;
}
dst[argb_a] = na;
src++;
dst += 4;
}
dst += stride - 4 * w;
}
gst_video_frame_unmap (&frame);
rect->applied_global_alpha = global_alpha;
}
static void
gst_video_overlay_rectangle_convert (const GstVideoInfo * src,
GstBuffer * src_buffer, GstVideoFormat dest_format, GstVideoInfo * dest,
GstBuffer ** dest_buffer)
{
gint width, height, stride;
GstVideoFrame src_frame, dest_frame;
GstVideoFormat format;
gint k, l;
guint8 *sdata, *ddata;
format = GST_VIDEO_INFO_FORMAT (src);
width = GST_VIDEO_INFO_WIDTH (src);
height = GST_VIDEO_INFO_HEIGHT (src);
gst_video_info_init (dest);
if (!gst_video_info_set_format (dest, dest_format, width, height)) {
g_warn_if_reached ();
return;
}
*dest_buffer = gst_buffer_new_and_alloc (GST_VIDEO_INFO_SIZE (dest));
gst_video_frame_map (&src_frame, src, src_buffer, GST_MAP_READ);
gst_video_frame_map (&dest_frame, dest, *dest_buffer, GST_MAP_WRITE);
sdata = GST_VIDEO_FRAME_PLANE_DATA (&src_frame, 0);
ddata = GST_VIDEO_FRAME_PLANE_DATA (&dest_frame, 0);
stride = GST_VIDEO_FRAME_PLANE_STRIDE (&src_frame, 0);
if (format == GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_YUV &&
dest_format == GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_RGB) {
gint ayuv;
gint a, y, u, v, r, g, b;
for (k = 0; k < height; k++) {
for (l = 0; l < width; l++) {
ayuv = GST_READ_UINT32_BE (sdata);
a = ayuv >> 24;
y = (ayuv >> 16) & 0xff;
u = (ayuv >> 8) & 0xff;
v = (ayuv & 0xff);
r = (298 * y + 459 * v - 63514) >> 8;
g = (298 * y - 55 * u - 136 * v + 19681) >> 8;
b = (298 * y + 541 * u - 73988) >> 8;
r = CLAMP (r, 0, 255);
g = CLAMP (g, 0, 255);
b = CLAMP (b, 0, 255);
/* native endian ARGB */
*(guint32 *) ddata = ((a << 24) | (r << 16) | (g << 8) | b);
sdata += 4;
ddata += 4;
}
sdata += stride - 4 * width;
}
} else if (format == GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_RGB &&
dest_format == GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_YUV) {
gint argb;
gint a, y, u, v, r, g, b;
for (k = 0; k < height; k++) {
for (l = 0; l < width; l++) {
/* native endian ARGB */
argb = *(guint32 *) sdata;
a = argb >> 24;
r = (argb >> 16) & 0xff;
g = (argb >> 8) & 0xff;
b = (argb & 0xff);
y = (47 * r + 157 * g + 16 * b + 4096) >> 8;
u = (-26 * r - 87 * g + 112 * b + 32768) >> 8;
v = (112 * r - 102 * g - 10 * b + 32768) >> 8;
y = CLAMP (y, 0, 255);
u = CLAMP (u, 0, 255);
v = CLAMP (v, 0, 255);
GST_WRITE_UINT32_BE (ddata, ((a << 24) | (y << 16) | (u << 8) | v));
sdata += 4;
ddata += 4;
}
sdata += stride - 4 * width;
}
} else {
GST_ERROR ("unsupported conversion");
g_assert_not_reached ();
}
gst_video_frame_unmap (&src_frame);
gst_video_frame_unmap (&dest_frame);
}
static GstBuffer *
gst_video_overlay_rectangle_get_pixels_raw_internal (GstVideoOverlayRectangle *
rectangle, GstVideoOverlayFormatFlags flags, gboolean unscaled,
GstVideoFormat wanted_format)
{
GstVideoOverlayFormatFlags new_flags;
GstVideoOverlayRectangle *scaled_rect = NULL, *conv_rect = NULL;
GstVideoInfo info;
GstVideoFrame frame;
GstBuffer *buf;
GList *l;
guint width, height;
guint wanted_width;
guint wanted_height;
gboolean apply_global_alpha;
gboolean revert_global_alpha;
GstVideoFormat format;
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle), NULL);
g_return_val_if_fail (gst_video_overlay_rectangle_check_flags (flags), NULL);
width = GST_VIDEO_INFO_WIDTH (&rectangle->info);
height = GST_VIDEO_INFO_HEIGHT (&rectangle->info);
wanted_width = unscaled ? width : rectangle->render_width;
wanted_height = unscaled ? height : rectangle->render_height;
format = GST_VIDEO_INFO_FORMAT (&rectangle->info);
apply_global_alpha =
(! !(rectangle->flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA)
&& !(flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA));
revert_global_alpha =
(! !(rectangle->flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA)
&& ! !(flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA));
/* This assumes we don't need to adjust the format */
if (wanted_width == width &&
wanted_height == height &&
wanted_format == format &&
gst_video_overlay_rectangle_is_same_alpha_type (rectangle->flags,
flags)) {
/* don't need to apply/revert global-alpha either: */
if ((!apply_global_alpha
|| rectangle->applied_global_alpha == rectangle->global_alpha)
&& (!revert_global_alpha || rectangle->applied_global_alpha == 1.0)) {
return rectangle->pixels;
} else {
/* only apply/revert global-alpha */
scaled_rect = rectangle;
goto done;
}
}
/* see if we've got one cached already */
GST_RECTANGLE_LOCK (rectangle);
for (l = rectangle->scaled_rectangles; l != NULL; l = l->next) {
GstVideoOverlayRectangle *r = l->data;
if (GST_VIDEO_INFO_WIDTH (&r->info) == wanted_width &&
GST_VIDEO_INFO_HEIGHT (&r->info) == wanted_height &&
GST_VIDEO_INFO_FORMAT (&r->info) == wanted_format &&
gst_video_overlay_rectangle_is_same_alpha_type (r->flags, flags)) {
/* we'll keep these rectangles around until finalize, so it's ok not
* to take our own ref here */
scaled_rect = r;
break;
}
}
GST_RECTANGLE_UNLOCK (rectangle);
if (scaled_rect != NULL)
goto done;
/* maybe have one in the right format though */
if (format != wanted_format) {
GST_RECTANGLE_LOCK (rectangle);
for (l = rectangle->scaled_rectangles; l != NULL; l = l->next) {
GstVideoOverlayRectangle *r = l->data;
if (GST_VIDEO_INFO_FORMAT (&r->info) == wanted_format &&
gst_video_overlay_rectangle_is_same_alpha_type (r->flags, flags)) {
/* we'll keep these rectangles around until finalize, so it's ok not
* to take our own ref here */
conv_rect = r;
break;
}
}
GST_RECTANGLE_UNLOCK (rectangle);
} else {
conv_rect = rectangle;
}
if (conv_rect == NULL) {
GstVideoInfo conv_info;
gst_video_overlay_rectangle_convert (&rectangle->info, rectangle->pixels,
wanted_format, &conv_info, &buf);
gst_buffer_add_video_meta (buf, GST_VIDEO_FRAME_FLAG_NONE,
GST_VIDEO_INFO_FORMAT (&conv_info), width, height);
conv_rect = gst_video_overlay_rectangle_new_raw (buf,
0, 0, width, height, rectangle->flags);
if (rectangle->global_alpha != 1.0)
gst_video_overlay_rectangle_set_global_alpha (scaled_rect,
rectangle->global_alpha);
gst_buffer_unref (buf);
/* keep this converted one around as well in any case */
GST_RECTANGLE_LOCK (rectangle);
rectangle->scaled_rectangles =
g_list_prepend (rectangle->scaled_rectangles, conv_rect);
GST_RECTANGLE_UNLOCK (rectangle);
}
/* now we continue from conv_rect */
width = GST_VIDEO_INFO_WIDTH (&conv_rect->info);
height = GST_VIDEO_INFO_HEIGHT (&conv_rect->info);
format = GST_VIDEO_INFO_FORMAT (&conv_rect->info);
/* not cached yet, do the preprocessing and put the result into our cache */
if (wanted_width != width || wanted_height != height) {
GstVideoInfo scaled_info;
/* we could check the cache for a scaled rect with global_alpha == 1 here */
gst_video_blend_scale_linear_RGBA (&conv_rect->info, conv_rect->pixels,
wanted_height, wanted_width, &scaled_info, &buf);
info = scaled_info;
gst_buffer_add_video_meta (buf, GST_VIDEO_FRAME_FLAG_NONE,
GST_VIDEO_INFO_FORMAT (&conv_rect->info), wanted_width, wanted_height);
} else if (!gst_video_overlay_rectangle_is_same_alpha_type (conv_rect->flags,
flags)) {
/* if we don't have to scale, we have to modify the alpha values, so we
* need to make a copy of the pixel memory (and we take ownership below) */
buf = gst_buffer_copy (conv_rect->pixels);
info = conv_rect->info;
} else {
/* do not need to scale or modify alpha values, almost done then */
scaled_rect = conv_rect;
goto done;
}
new_flags = conv_rect->flags;
gst_video_frame_map (&frame, &info, buf, GST_MAP_READWRITE);
if (!gst_video_overlay_rectangle_is_same_alpha_type (conv_rect->flags, flags)) {
if (rectangle->flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA) {
gst_video_overlay_rectangle_unpremultiply (&frame);
new_flags &= ~GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA;
} else {
gst_video_overlay_rectangle_premultiply (&frame);
new_flags |= GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA;
}
}
gst_video_frame_unmap (&frame);
scaled_rect = gst_video_overlay_rectangle_new_raw (buf,
0, 0, wanted_width, wanted_height, new_flags);
if (conv_rect->global_alpha != 1.0)
gst_video_overlay_rectangle_set_global_alpha (scaled_rect,
conv_rect->global_alpha);
gst_buffer_unref (buf);
GST_RECTANGLE_LOCK (rectangle);
rectangle->scaled_rectangles =
g_list_prepend (rectangle->scaled_rectangles, scaled_rect);
GST_RECTANGLE_UNLOCK (rectangle);
done:
GST_RECTANGLE_LOCK (rectangle);
if (apply_global_alpha
&& scaled_rect->applied_global_alpha != rectangle->global_alpha) {
gst_video_overlay_rectangle_apply_global_alpha (scaled_rect,
rectangle->global_alpha);
gst_video_overlay_rectangle_set_global_alpha (scaled_rect,
rectangle->global_alpha);
} else if (revert_global_alpha && scaled_rect->applied_global_alpha != 1.0) {
gst_video_overlay_rectangle_apply_global_alpha (scaled_rect, 1.0);
}
GST_RECTANGLE_UNLOCK (rectangle);
return scaled_rect->pixels;
}
/**
* gst_video_overlay_rectangle_get_pixels_raw:
* @rectangle: a #GstVideoOverlayRectangle
* @flags: flags
* If a global_alpha value != 1 is set for the rectangle, the caller
* should set the #GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA flag
* if he wants to apply global-alpha himself. If the flag is not set
* global_alpha is applied internally before returning the pixel-data.
*
* Returns: (transfer none): a #GstBuffer holding the pixel data with
* format as originally provided and specified in video meta with
* width and height of the render dimensions as per
* gst_video_overlay_rectangle_get_render_rectangle(). This function does
* not return a reference, the caller should obtain a reference of her own
* with gst_buffer_ref() if needed.
*/
GstBuffer *
gst_video_overlay_rectangle_get_pixels_raw (GstVideoOverlayRectangle *
rectangle, GstVideoOverlayFormatFlags flags)
{
return gst_video_overlay_rectangle_get_pixels_raw_internal (rectangle,
flags, FALSE, GST_VIDEO_INFO_FORMAT (&rectangle->info));
}
/**
* gst_video_overlay_rectangle_get_pixels_argb:
* @rectangle: a #GstVideoOverlayRectangle
* @flags: flags
* If a global_alpha value != 1 is set for the rectangle, the caller
* should set the #GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA flag
* if he wants to apply global-alpha himself. If the flag is not set
* global_alpha is applied internally before returning the pixel-data.
*
* Returns: (transfer none): a #GstBuffer holding the ARGB pixel data with
* width and height of the render dimensions as per
* gst_video_overlay_rectangle_get_render_rectangle(). This function does
* not return a reference, the caller should obtain a reference of her own
* with gst_buffer_ref() if needed.
*/
GstBuffer *
gst_video_overlay_rectangle_get_pixels_argb (GstVideoOverlayRectangle *
rectangle, GstVideoOverlayFormatFlags flags)
{
return gst_video_overlay_rectangle_get_pixels_raw_internal (rectangle,
flags, FALSE, GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_RGB);
}
/**
* gst_video_overlay_rectangle_get_pixels_ayuv:
* @rectangle: a #GstVideoOverlayRectangle
* @flags: flags
* If a global_alpha value != 1 is set for the rectangle, the caller
* should set the #GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA flag
* if he wants to apply global-alpha himself. If the flag is not set
* global_alpha is applied internally before returning the pixel-data.
*
* Returns: (transfer none): a #GstBuffer holding the AYUV pixel data with
* width and height of the render dimensions as per
* gst_video_overlay_rectangle_get_render_rectangle(). This function does
* not return a reference, the caller should obtain a reference of her own
* with gst_buffer_ref() if needed.
*/
GstBuffer *
gst_video_overlay_rectangle_get_pixels_ayuv (GstVideoOverlayRectangle *
rectangle, GstVideoOverlayFormatFlags flags)
{
return gst_video_overlay_rectangle_get_pixels_raw_internal (rectangle,
flags, FALSE, GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_YUV);
}
/**
* gst_video_overlay_rectangle_get_pixels_unscaled_raw:
* @rectangle: a #GstVideoOverlayRectangle
* @flags: flags.
* If a global_alpha value != 1 is set for the rectangle, the caller
* should set the #GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA flag
* if he wants to apply global-alpha himself. If the flag is not set
* global_alpha is applied internally before returning the pixel-data.
*
* Retrieves the pixel data as it is. This is useful if the caller can
* do the scaling itself when handling the overlaying. The rectangle will
* need to be scaled to the render dimensions, which can be retrieved using
* gst_video_overlay_rectangle_get_render_rectangle().
*
* Returns: (transfer none): a #GstBuffer holding the pixel data with
* #GstVideoMeta set. This function does not return a reference, the caller
* should obtain a reference of her own with gst_buffer_ref() if needed.
*/
GstBuffer *
gst_video_overlay_rectangle_get_pixels_unscaled_raw (GstVideoOverlayRectangle *
rectangle, GstVideoOverlayFormatFlags flags)
{
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle), NULL);
return gst_video_overlay_rectangle_get_pixels_raw_internal (rectangle,
flags, TRUE, GST_VIDEO_INFO_FORMAT (&rectangle->info));
}
/**
* gst_video_overlay_rectangle_get_pixels_unscaled_argb:
* @rectangle: a #GstVideoOverlayRectangle
* @flags: flags.
* If a global_alpha value != 1 is set for the rectangle, the caller
* should set the #GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA flag
* if he wants to apply global-alpha himself. If the flag is not set
* global_alpha is applied internally before returning the pixel-data.
*
* Retrieves the pixel data as it is. This is useful if the caller can
* do the scaling itself when handling the overlaying. The rectangle will
* need to be scaled to the render dimensions, which can be retrieved using
* gst_video_overlay_rectangle_get_render_rectangle().
*
* Returns: (transfer none): a #GstBuffer holding the ARGB pixel data with
* #GstVideoMeta set. This function does not return a reference, the caller
* should obtain a reference of her own with gst_buffer_ref() if needed.
*/
GstBuffer *
gst_video_overlay_rectangle_get_pixels_unscaled_argb (GstVideoOverlayRectangle *
rectangle, GstVideoOverlayFormatFlags flags)
{
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle), NULL);
return gst_video_overlay_rectangle_get_pixels_raw_internal (rectangle,
flags, TRUE, GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_RGB);
}
/**
* gst_video_overlay_rectangle_get_pixels_unscaled_ayuv:
* @rectangle: a #GstVideoOverlayRectangle
* @flags: flags.
* If a global_alpha value != 1 is set for the rectangle, the caller
* should set the #GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA flag
* if he wants to apply global-alpha himself. If the flag is not set
* global_alpha is applied internally before returning the pixel-data.
*
* Retrieves the pixel data as it is. This is useful if the caller can
* do the scaling itself when handling the overlaying. The rectangle will
* need to be scaled to the render dimensions, which can be retrieved using
* gst_video_overlay_rectangle_get_render_rectangle().
*
* Returns: (transfer none): a #GstBuffer holding the AYUV pixel data with
* #GstVideoMeta set. This function does not return a reference, the caller
* should obtain a reference of her own with gst_buffer_ref() if needed.
*/
GstBuffer *
gst_video_overlay_rectangle_get_pixels_unscaled_ayuv (GstVideoOverlayRectangle *
rectangle, GstVideoOverlayFormatFlags flags)
{
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle), NULL);
return gst_video_overlay_rectangle_get_pixels_raw_internal (rectangle,
flags, TRUE, GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_YUV);
}
/**
* gst_video_overlay_rectangle_get_flags:
* @rectangle: a #GstVideoOverlayRectangle
*
* Retrieves the flags associated with a #GstVideoOverlayRectangle.
* This is useful if the caller can handle both premultiplied alpha and
* non premultiplied alpha, for example. By knowing whether the rectangle
* uses premultiplied or not, it can request the pixel data in the format
* it is stored in, to avoid unnecessary conversion.
*
* Returns: the #GstVideoOverlayFormatFlags associated with the rectangle.
*/
GstVideoOverlayFormatFlags
gst_video_overlay_rectangle_get_flags (GstVideoOverlayRectangle * rectangle)
{
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle),
GST_VIDEO_OVERLAY_FORMAT_FLAG_NONE);
return rectangle->flags;
}
/**
* gst_video_overlay_rectangle_get_global_alpha:
* @rectangle: a #GstVideoOverlayRectangle
*
* Retrieves the global-alpha value associated with a #GstVideoOverlayRectangle.
*
* Returns: the global-alpha value associated with the rectangle.
*/
gfloat
gst_video_overlay_rectangle_get_global_alpha (GstVideoOverlayRectangle *
rectangle)
{
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle), -1);
return rectangle->global_alpha;
}
/**
* gst_video_overlay_rectangle_set_global_alpha:
* @rectangle: a #GstVideoOverlayRectangle
* @global_alpha: Global alpha value (0 to 1.0)
*
* Sets the global alpha value associated with a #GstVideoOverlayRectangle. Per-
* pixel alpha values are multiplied with this value. Valid
* values: 0 <= global_alpha <= 1; 1 to deactivate.
*
* @rectangle must be writable, meaning its refcount must be 1. You can
* make the rectangles inside a #GstVideoOverlayComposition writable using
* gst_video_overlay_composition_make_writable() or
* gst_video_overlay_composition_copy().
*/
void
gst_video_overlay_rectangle_set_global_alpha (GstVideoOverlayRectangle *
rectangle, gfloat global_alpha)
{
g_return_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle));
g_return_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST
(rectangle)));
g_return_if_fail (global_alpha >= 0 && global_alpha <= 1);
if (rectangle->global_alpha != global_alpha) {
rectangle->global_alpha = global_alpha;
if (global_alpha != 1)
rectangle->flags |= GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA;
else
rectangle->flags &= ~GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA;
/* update seq_num automatically to signal the consumer, that data has changed
* note, that this might mislead renderers, that can handle global-alpha
* themselves, because what they want to know is whether the actual pixel data
* has changed. */
rectangle->seq_num = gst_video_overlay_get_seqnum ();
}
}
/**
* gst_video_overlay_rectangle_copy:
* @rectangle: (transfer none): a #GstVideoOverlayRectangle to copy
*
* Makes a copy of @rectangle, so that it is possible to modify it
* (e.g. to change the render co-ordinates or render dimension). The
* actual overlay pixel data buffers contained in the rectangle are not
* copied.
*
* Returns: (transfer full): a new #GstVideoOverlayRectangle equivalent
* to @rectangle.
*/
GstVideoOverlayRectangle *
gst_video_overlay_rectangle_copy (GstVideoOverlayRectangle * rectangle)
{
GstVideoOverlayRectangle *copy;
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle), NULL);
copy = gst_video_overlay_rectangle_new_raw (rectangle->pixels,
rectangle->x, rectangle->y,
rectangle->render_width, rectangle->render_height, rectangle->flags);
if (rectangle->global_alpha != 1)
gst_video_overlay_rectangle_set_global_alpha (copy,
rectangle->global_alpha);
return copy;
}
/**
* gst_video_overlay_rectangle_get_seqnum:
* @rectangle: a #GstVideoOverlayRectangle
*
* Returns the sequence number of this rectangle. Sequence numbers are
* monotonically increasing and unique for overlay compositions and rectangles
* (meaning there will never be a rectangle with the same sequence number as
* a composition).
*
* Using the sequence number of a rectangle as an indicator for changed
* pixel-data of a rectangle is dangereous. Some API calls, like e.g.
* gst_video_overlay_rectangle_set_global_alpha(), automatically update
* the per rectangle sequence number, which is misleading for renderers/
* consumers, that handle global-alpha themselves. For them the
* pixel-data returned by gst_video_overlay_rectangle_get_pixels_*()
* won't be different for different global-alpha values. In this case a
* renderer could also use the GstBuffer pointers as a hint for changed
* pixel-data.
*
* Returns: the sequence number of @rectangle
*/
guint
gst_video_overlay_rectangle_get_seqnum (GstVideoOverlayRectangle * rectangle)
{
g_return_val_if_fail (GST_IS_VIDEO_OVERLAY_RECTANGLE (rectangle), 0);
return rectangle->seq_num;
}
Reference in a new issue View git blame Copy permalink