gstreamer/subprojects/gst-plugins-base/gst-libs/gst/video/video-multiview.c

503 lines
14 KiB
C

/* GStreamer
* Copyright (C) <2015> Jan Schmidt <jan@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <string.h>
#include "video.h"
GType
gst_video_multiview_flagset_get_type (void)
{
static GType type = 0;
if (g_once_init_enter (&type)) {
GType _type = gst_flagset_register (GST_TYPE_VIDEO_MULTIVIEW_FLAGS);
g_once_init_leave (&type, _type);
}
return type;
}
/* Caps mnemonics for the various multiview representations */
static const struct mview_map_t
{
const gchar *caps_repr;
GstVideoMultiviewMode mode;
} gst_multiview_modes[] = {
{
"mono", GST_VIDEO_MULTIVIEW_MODE_MONO}, {
"left", GST_VIDEO_MULTIVIEW_MODE_LEFT}, {
"right", GST_VIDEO_MULTIVIEW_MODE_RIGHT}, {
"side-by-side", GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE}, {
"side-by-side-quincunx", GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX}, {
"column-interleaved", GST_VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED}, {
"row-interleaved", GST_VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED}, {
"top-bottom", GST_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM}, {
"checkerboard", GST_VIDEO_MULTIVIEW_MODE_CHECKERBOARD}, {
"frame-by-frame", GST_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME}, {
"multiview-frame-by-frame",
GST_VIDEO_MULTIVIEW_MODE_MULTIVIEW_FRAME_BY_FRAME}, {
"separated", GST_VIDEO_MULTIVIEW_MODE_SEPARATED}
};
/**
* gst_video_multiview_mode_to_caps_string:
* @mview_mode: A #GstVideoMultiviewMode value
*
* Returns: The caps string representation of the mode, or NULL if invalid.
*
* Given a #GstVideoMultiviewMode returns the multiview-mode caps string
* for insertion into a caps structure
*
* Since: 1.6
*/
const gchar *
gst_video_multiview_mode_to_caps_string (GstVideoMultiviewMode mview_mode)
{
gint i;
for (i = 0; i < G_N_ELEMENTS (gst_multiview_modes); i++) {
if (gst_multiview_modes[i].mode == mview_mode) {
return gst_multiview_modes[i].caps_repr;
}
}
return NULL;
}
/**
* gst_video_multiview_mode_from_caps_string:
* @caps_mview_mode: multiview-mode field string from caps
*
* Returns: The #GstVideoMultiviewMode value
*
* Given a string from a caps multiview-mode field,
* output the corresponding #GstVideoMultiviewMode
* or #GST_VIDEO_MULTIVIEW_MODE_NONE
*
* Since: 1.6
*/
GstVideoMultiviewMode
gst_video_multiview_mode_from_caps_string (const gchar * caps_mview_mode)
{
gint i;
for (i = 0; i < G_N_ELEMENTS (gst_multiview_modes); i++) {
if (g_str_equal (gst_multiview_modes[i].caps_repr, caps_mview_mode)) {
return gst_multiview_modes[i].mode;
}
}
GST_ERROR ("Invalid multiview info %s", caps_mview_mode);
g_warning ("Invalid multiview info %s", caps_mview_mode);
return GST_VIDEO_MULTIVIEW_MODE_NONE;
}
/* Array of mono, unpacked, double-height and double-width modes */
static GValue mode_values[5];
static void
init_mview_mode_vals (void)
{
static gsize mview_mode_vals_init = 0;
if (g_once_init_enter (&mview_mode_vals_init)) {
GValue item = { 0, };
GValue *list;
g_value_init (&item, G_TYPE_STRING);
/* Mono modes */
list = mode_values;
g_value_init (list, GST_TYPE_LIST);
g_value_set_static_string (&item, "mono");
gst_value_list_append_value (list, &item);
g_value_set_static_string (&item, "left");
gst_value_list_append_value (list, &item);
g_value_set_static_string (&item, "right");
gst_value_list_append_value (list, &item);
/* Unpacked modes - ones split across buffers or memories */
list = mode_values + 1;
g_value_init (list, GST_TYPE_LIST);
g_value_set_static_string (&item, "separated");
gst_value_list_append_value (list, &item);
g_value_set_static_string (&item, "frame-by-frame");
gst_value_list_append_value (list, &item);
g_value_set_static_string (&item, "multiview-frame-by-frame");
gst_value_list_append_value (list, &item);
/* Double height modes */
list = mode_values + 2;
g_value_init (list, GST_TYPE_LIST);
g_value_set_static_string (&item, "top-bottom");
gst_value_list_append_value (list, &item);
g_value_set_static_string (&item, "row-interleaved");
gst_value_list_append_value (list, &item);
/* Double width modes */
list = mode_values + 3;
g_value_init (list, GST_TYPE_LIST);
g_value_set_static_string (&item, "side-by-side");
gst_value_list_append_value (list, &item);
g_value_set_static_string (&item, "side-by-side-quincunx");
gst_value_list_append_value (list, &item);
g_value_set_static_string (&item, "column-interleaved");
gst_value_list_append_value (list, &item);
/* Double size (both width & height) modes */
list = mode_values + 4;
g_value_init (list, GST_TYPE_LIST);
g_value_set_static_string (&item, "checkerboard");
gst_value_list_append_value (list, &item);
g_value_unset (&item);
g_once_init_leave (&mview_mode_vals_init, 1);
}
}
/**
* gst_video_multiview_get_mono_modes:
*
* Returns: A const #GValue containing a list of mono video modes
*
* Utility function that returns a #GValue with a GstList of mono video
* modes (mono/left/right) for use in caps negotiations.
*
* Since: 1.6
*/
const GValue *
gst_video_multiview_get_mono_modes (void)
{
init_mview_mode_vals ();
return mode_values;
}
/**
* gst_video_multiview_get_unpacked_modes:
*
* Returns: A const #GValue containing a list of 'unpacked' stereo video modes
*
* Utility function that returns a #GValue with a GstList of unpacked
* stereo video modes (separated/frame-by-frame/frame-by-frame-multiview)
* for use in caps negotiations.
*
* Since: 1.6
*/
const GValue *
gst_video_multiview_get_unpacked_modes (void)
{
init_mview_mode_vals ();
return mode_values + 1;
}
/**
* gst_video_multiview_get_doubled_height_modes:
*
* Returns: A const #GValue containing a list of stereo video modes
*
* Utility function that returns a #GValue with a GstList of packed stereo
* video modes with double the height of a single view for use in
* caps negotiations. Currently this is top-bottom and row-interleaved.
*
* Since: 1.6
*/
const GValue *
gst_video_multiview_get_doubled_height_modes (void)
{
init_mview_mode_vals ();
return mode_values + 2;
}
/**
* gst_video_multiview_get_doubled_width_modes:
*
* Returns: A const #GValue containing a list of stereo video modes
*
* Utility function that returns a #GValue with a GstList of packed stereo
* video modes with double the width of a single view for use in
* caps negotiations. Currently this is side-by-side, side-by-side-quincunx
* and column-interleaved.
*
* Since: 1.6
*/
const GValue *
gst_video_multiview_get_doubled_width_modes (void)
{
init_mview_mode_vals ();
return mode_values + 3;
}
/**
* gst_video_multiview_get_doubled_size_modes:
*
* Returns: A const #GValue containing a list of stereo video modes
*
* Utility function that returns a #GValue with a GstList of packed
* stereo video modes that have double the width/height of a single
* view for use in caps negotiation. Currently this is just
* 'checkerboard' layout.
*
* Since: 1.6
*/
const GValue *
gst_video_multiview_get_doubled_size_modes (void)
{
init_mview_mode_vals ();
return mode_values + 4;
}
static void
gst_video_multiview_separated_video_info_from_packed (GstVideoInfo * info)
{
GstVideoMultiviewMode mview_mode;
mview_mode = GST_VIDEO_INFO_MULTIVIEW_MODE (info);
/* Normalise the half-aspect flag by adjusting PAR */
switch (mview_mode) {
case GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE:
case GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX:
case GST_VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED:
case GST_VIDEO_MULTIVIEW_MODE_CHECKERBOARD:
info->width /= 2;
info->views *= 2;
GST_VIDEO_INFO_MULTIVIEW_MODE (info) = GST_VIDEO_MULTIVIEW_MODE_SEPARATED;
if (GST_VIDEO_INFO_MULTIVIEW_FLAGS (info) &
GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT)
info->par_n *= 2;
break;
case GST_VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED:
case GST_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM:
info->height /= 2;
info->views *= 2;
GST_VIDEO_INFO_MULTIVIEW_MODE (info) = GST_VIDEO_MULTIVIEW_MODE_SEPARATED;
if (GST_VIDEO_INFO_MULTIVIEW_FLAGS (info) &
GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT)
info->par_d *= 2;
break;
default:
/* Mono/left/right/frame-by-frame/already separated */
break;
}
GST_VIDEO_INFO_MULTIVIEW_FLAGS (info) &=
~GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT;
}
static void
gst_video_multiview_separated_video_info_to_packed (GstVideoInfo * info,
GstVideoMultiviewMode packed_mview_mode,
GstVideoMultiviewFlags packed_mview_flags)
{
/* Convert single-frame info to a packed mode */
GST_VIDEO_INFO_MULTIVIEW_MODE (info) = packed_mview_mode;
GST_VIDEO_INFO_MULTIVIEW_FLAGS (info) = packed_mview_flags;
switch (packed_mview_mode) {
case GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE:
case GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX:
case GST_VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED:
case GST_VIDEO_MULTIVIEW_MODE_CHECKERBOARD:
info->width *= 2;
info->views /= 2;
if (packed_mview_flags & GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT)
info->par_d *= 2;
break;
case GST_VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED:
case GST_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM:
info->height *= 2;
info->views /= 2;
if (packed_mview_flags & GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT)
info->par_n *= 2;
break;
default:
break;
}
}
/**
* gst_video_multiview_video_info_change_mode:
* @info: A #GstVideoInfo structure to operate on
* @out_mview_mode: A #GstVideoMultiviewMode value
* @out_mview_flags: A set of #GstVideoMultiviewFlags
*
* Utility function that transforms the width/height/PAR
* and multiview mode and flags of a #GstVideoInfo into
* the requested mode.
*
* Since: 1.6
*/
void
gst_video_multiview_video_info_change_mode (GstVideoInfo * info,
GstVideoMultiviewMode out_mview_mode,
GstVideoMultiviewFlags out_mview_flags)
{
gst_video_multiview_separated_video_info_from_packed (info);
gst_video_multiview_separated_video_info_to_packed (info, out_mview_mode,
out_mview_flags);
}
/**
* gst_video_multiview_guess_half_aspect:
* @mv_mode: A #GstVideoMultiviewMode
* @width: Video frame width in pixels
* @height: Video frame height in pixels
* @par_n: Numerator of the video pixel-aspect-ratio
* @par_d: Denominator of the video pixel-aspect-ratio
*
* Returns: A boolean indicating whether the
* #GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT flag should be set.
*
* Utility function that heuristically guess whether a
* frame-packed stereoscopic video contains half width/height
* encoded views, or full-frame views by looking at the
* overall display aspect ratio.
*
* Since: 1.6
*/
gboolean
gst_video_multiview_guess_half_aspect (GstVideoMultiviewMode mv_mode,
guint width, guint height, guint par_n, guint par_d)
{
switch (mv_mode) {
case GST_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM:
case GST_VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED:
/* If the video is wider than it is tall, assume half aspect */
if (height * par_d <= width * par_n)
return TRUE;
break;
case GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE:
case GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX:
case GST_VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED:
/* If the video DAR is less than 2.39:1, assume half-aspect */
if (width * par_n < 2.39 * height * par_d)
return TRUE;
break;
default:
break;
}
return FALSE;
}
#if 0 /* Multiview meta disabled for now */
GType
gst_video_multiview_meta_api_get_type (void)
{
static GType type = 0;
static const gchar *tags[] =
{ GST_META_TAG_VIDEO_STR, GST_META_TAG_MEMORY_STR,
NULL
};
if (g_once_init_enter (&type)) {
GType _type = gst_meta_api_type_register ("GstVideoMultiviewMetaAPI", tags);
g_once_init_leave (&type, _type);
}
return type;
}
static gboolean
gst_video_multiview_meta_init (GstVideoMultiviewMeta * mview_meta,
gpointer params, GstBuffer * buffer)
{
mview_meta->n_views = 0;
mview_meta->view_info = NULL;
return TRUE;
}
static void
gst_video_multiview_meta_free (GstVideoMultiviewMeta * mview_meta,
GstBuffer * buffer)
{
g_free (mview_meta->view_info);
}
/* video multiview metadata */
const GstMetaInfo *
gst_video_multiview_meta_get_info (void)
{
static const GstMetaInfo *video_meta_info = NULL;
if (g_once_init_enter (&video_meta_info)) {
const GstMetaInfo *meta =
gst_meta_register (GST_VIDEO_MULTIVIEW_META_API_TYPE,
"GstVideoMultiviewMeta",
sizeof (GstVideoMultiviewMeta),
(GstMetaInitFunction) gst_video_multiview_meta_init,
(GstMetaFreeFunction) gst_video_multiview_meta_free,
NULL);
g_once_init_leave (&video_meta_info, meta);
}
return video_meta_info;
}
GstVideoMultiviewMeta *
gst_buffer_add_video_multiview_meta (GstBuffer * buffer, guint n_views)
{
GstVideoMultiviewMeta *meta;
meta =
(GstVideoMultiviewMeta *) gst_buffer_add_meta (buffer,
GST_VIDEO_MULTIVIEW_META_INFO, NULL);
if (!meta)
return NULL;
meta->view_info = g_new0 (GstVideoMultiviewViewInfo, n_views);
meta->n_views = n_views;
return meta;
}
void
gst_video_multiview_meta_set_n_views (GstVideoMultiviewMeta * mview_meta,
guint n_views)
{
guint i;
mview_meta->view_info =
g_renew (GstVideoMultiviewViewInfo, mview_meta->view_info, n_views);
if (mview_meta->view_info == NULL) {
if (n_views > 0)
g_warning ("Failed to allocate GstVideoMultiview data");
mview_meta->n_views = 0;
return;
}
/* Make sure new entries are zero */
for (i = mview_meta->n_views; i < n_views; i++) {
GstVideoMultiviewViewInfo *info = mview_meta->view_info + i;
info->meta_id = 0;
info->view_label = GST_VIDEO_MULTIVIEW_VIEW_UNKNOWN;
}
mview_meta->n_views = n_views;
}
#endif