/*

 * GStreamer

 * Copyright (C) 2009 Julien Isorce <julien.isorce@mail.com>

 * Copyright (C) 2014 Jan Schmidt <jan@centricular.com>

 * Copyright (C) 2015 Matthew Waters <matthew@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.

 */

/**

 * SECTION:gstglviewconvert

 * @title: GstGLViewConvert

 * @short_description: convert between steroscopic/multiview video formats

 * @see_also: #GstGLColorConvert, #GstGLContext

 *

 * Convert stereoscopic/multiview video using fragment shaders.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "gstglviewconvert.h"

#include <gst/video/gstvideoaffinetransformationmeta.h>

#include "gstglcontext.h"

#include "gstglframebuffer.h"

#include "gstglmemory.h"

#include "gstglshader.h"

#include "gstglshaderstrings.h"

#include "gstglsl.h"

#include "gstglsl_private.h"

#include "gstglslstage.h"

#include "gstglutils_private.h"

#define USING_OPENGL(context) (gst_gl_context_check_gl_version (context, GST_GL_API_OPENGL, 1, 0))

#define USING_OPENGL3(context) (gst_gl_context_check_gl_version (context, GST_GL_API_OPENGL3, 3, 1))

#define USING_GLES(context) (gst_gl_context_check_gl_version (context, GST_GL_API_GLES, 1, 0))

#define USING_GLES2(context) (gst_gl_context_check_gl_version (context, GST_GL_API_GLES2, 2, 0))

#define USING_GLES3(context) (gst_gl_context_check_gl_version (context, GST_GL_API_GLES2, 3, 0))

static GstStaticCaps caps_template =

GST_STATIC_CAPS ("video/x-raw(" GST_CAPS_FEATURE_MEMORY_GL_MEMORY "), "

    "format = (string) RGBA, "

    "width = " GST_VIDEO_SIZE_RANGE ", "

    "height = " GST_VIDEO_SIZE_RANGE ", "

    "framerate = " GST_VIDEO_FPS_RANGE ", "

    "texture-target = (string) { 2D, rectangle, external-oes } ");

#define GST_CAT_DEFAULT gst_gl_view_convert_debug

GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);

enum

{

  PROP_0,

  PROP_INPUT_LAYOUT,

  PROP_INPUT_FLAGS,

  PROP_OUTPUT_LAYOUT,

  PROP_OUTPUT_FLAGS,

  PROP_OUTPUT_DOWNMIX_MODE

};

#define DEFAULT_DOWNMIX GST_GL_STEREO_DOWNMIX_ANAGLYPH_GREEN_MAGENTA_DUBOIS

struct _GstGLViewConvertPrivate

{

  gboolean result;

  GstVideoMultiviewMode input_mode;

  GstVideoMultiviewFlags input_flags;

  GstVideoMultiviewMode output_mode;

  GstVideoMultiviewFlags output_flags;

  GstBuffer *primary_in;

  GstBuffer *auxilliary_in;

  GstBuffer *primary_out;

  GstBuffer *auxilliary_out;

  GstGLMemory *in_tex[GST_VIDEO_MAX_PLANES];

  GstGLMemory *out_tex[GST_VIDEO_MAX_PLANES];

  guint n_out_tex;

  GLuint vao;

  GLuint vertex_buffer;

  GLuint vbo_indices;

  GLuint attr_position;

  GLuint attr_texture;

};

#define GST_GL_VIEW_CONVERT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \

    GST_TYPE_GL_VIEW_CONVERT, GstGLViewConvertPrivate))

#define DEBUG_INIT \

  GST_DEBUG_CATEGORY_INIT (gst_gl_view_convert_debug, "glviewconvert", 0, "glviewconvert object");

G_DEFINE_TYPE_WITH_CODE (GstGLViewConvert, gst_gl_view_convert,

    GST_TYPE_OBJECT, DEBUG_INIT);

static void gst_gl_view_convert_set_property (GObject * object,

    guint prop_id, const GValue * value, GParamSpec * pspec);

static void gst_gl_view_convert_get_property (GObject * object,

    guint prop_id, GValue * value, GParamSpec * pspec);

static void gst_gl_view_convert_finalize (GObject * object);

static void _do_view_convert (GstGLContext * context,

    GstGLViewConvert * viewconvert);

GType

gst_gl_stereo_downmix_mode_get_type (void)

{

  static volatile gsize g_define_type_id__volatile = 0;

  if (g_once_init_enter (&g_define_type_id__volatile)) {

    static const GEnumValue values[] = {

      {GST_GL_STEREO_DOWNMIX_ANAGLYPH_GREEN_MAGENTA_DUBOIS,

          "Dubois optimised Green-Magenta anaglyph", "green-magenta-dubois"},

      {GST_GL_STEREO_DOWNMIX_ANAGLYPH_RED_CYAN_DUBOIS,

            "Dubois optimised Red-Cyan anaglyph",

          "red-cyan-dubois"},

      {GST_GL_STEREO_DOWNMIX_ANAGLYPH_AMBER_BLUE_DUBOIS,

          "Dubois optimised Amber-Blue anaglyph", "amber-blue-dubois"},

      {0, NULL, NULL}

    };

    GType g_define_type_id =

        g_enum_register_static ("GstGLStereoDownmix", values);

    g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

  }

  return g_define_type_id__volatile;

}

/* *INDENT-OFF* */

/* These match the order and number of DOWNMIX_ANAGLYPH_* modes */

static GLfloat downmix_matrices[][2][9] = {

  {                             /* Green-Magenta Dubois */

        {-0.062f, 0.284f, -0.015f, -0.158f, 0.668f, -0.027f, -0.039f, 0.143f, 0.021f},

        {0.529f, -0.016f, 0.009f, 0.705f, -0.015f, 0.075f, 0.024f, -0.065f, 0.937f}

      },

  {                             /* Red-Cyan Dubois */

        /* Source of this matrix: http://www.site.uottawa.ca/~edubois/anaglyph/LeastSquaresHowToPhotoshop.pdf */

        {0.437f, -0.062f, -0.048f, 0.449f, -0.062f, -0.050f, 0.164f, -0.024f, -0.017f},

        {-0.011f, 0.377f, -0.026f, -0.032f, 0.761f, -0.093f, -0.007f, 0.009f, 1.234f}

      },

  {                             /* Amber-blue Dubois */

        {1.062f, -0.026f, -0.038f, -0.205f, 0.908f, -0.173f, 0.299f, 0.068f, 0.022f},

        {-0.016f, 0.006f, 0.094f, -0.123f, 0.062f, 0.185f, -0.017f, -0.017f, 0.911f}

      }

};

static gfloat identity_matrix[] = {

  1.0f, 0.0f, 0.0f, 0.0f,

  0.0f, 1.0f, 0.0f, 0.0f,

  0.0f, 0.0f, 1.0f, 0.0f,

  0.0f, 0.0f, 0.0f, 1.0f,

};

/* *INDENT-ON* */

#define glsl_OES_extension_string "#extension GL_OES_EGL_image_external : require \n"

/* *INDENT-OFF* */

static const gchar *fragment_header =

  "#ifdef GL_ES\n"

  "precision mediump float;\n"

  "#endif\n"

  "uniform sampler2D tex_l;\n"

  "uniform sampler2D tex_r;\n"

  "uniform float width;\n"

  "uniform float height;\n"

  "uniform mat3 downmix[2];\n"

  "uniform vec2 tex_scale[2];\n"

  "uniform vec2 offsets[2];\n";

static const gchar *frag_input =

  "  vec2 l_tex = v_texcoord * tex_scale[0] + offsets[0];\n"

  "  vec2 r_tex = v_texcoord * tex_scale[1] + offsets[1];\n"

  "  l = texture2D(tex_l, l_tex).rgba;\n"

  "  r = texture2D(tex_r, r_tex).rgba;\n";

static const gchar *frag_output_downmix =

  "  vec3 lcol = l.rgb * l.a + vec3(1.0-l.a);\n"

  "  vec3 rcol = r.rgb * r.a + vec3(1.0-r.a);\n"

  "  if (l.a + r.a > 0.0) {\n"

  "    lcol = clamp (downmix[0] * lcol, 0.0, 1.0);\n"

  "    rcol = clamp (downmix[1] * rcol, 0.0, 1.0);\n"

  "    gl_FragColor = vec4 (lcol + rcol, 1.0);\n"

  "  } else {\n"

  "    gl_FragColor = vec4 (0.0);\n"

  "  }\n";

static const gchar *frag_output_left =

  "  gl_FragColor = l;\n";

static const gchar *frag_output_right =

  "  gl_FragColor = r;\n";

static const gchar *frag_output_side_by_side =

  "  if (v_texcoord.x < 0.5) {\n"

  "    gl_FragColor = l;\n"

  "  } else {\n"

  "    gl_FragColor = r;\n"

  "  };\n";

static const gchar *frag_output_top_bottom =

  "if (v_texcoord.y < 0.5) {\n"

  "  gl_FragColor = l;\n"

  "} else {\n"

  "  gl_FragColor = r;\n"

  "};\n";

static const gchar *frag_output_column_interleaved =

  "if (int(mod(l_tex.x * width, 2.0)) == 0) {\n"

  "  gl_FragColor = l;\n"

  "} else {\n"

  "  gl_FragColor = r;\n"

  "};\n";

static const gchar *frag_output_row_interleaved =

  "if (int(mod(l_tex.y * height, 2.0)) == 0) {\n"

  "  gl_FragColor = l;\n"

  "} else {\n"

  "  gl_FragColor = r;\n"

  "};\n";

static const gchar *frag_output_checkerboard =

  "if (int(mod(l_tex.x * width, 2.0)) == \n"

  "    int(mod(l_tex.y * height, 2.0))) {\n"

  "  gl_FragColor = l;\n"

  "} else {\n"

  "  gl_FragColor = r;\n"

  "};\n";

static const gchar *frag_output_separated =

  "gl_FragData[0] = l;\n"

  "gl_FragData[1] = r;\n";

/* *INDENT-ON* */

static const GLfloat vertices[] = {

  1.0f, -1.0f, 0.0f, 1.0f, 0.0f,

  -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,

  -1.0f, 1.0f, 0.0f, 0.0f, 1.0f,

  1.0f, 1.0f, 0.0f, 1.0f, 1.0f

};

static const GLushort indices[] = { 0, 1, 2, 0, 2, 3 };

static void

gst_gl_view_convert_class_init (GstGLViewConvertClass * klass)

{

  GObjectClass *gobject_class = (GObjectClass *) klass;

  g_type_class_add_private (klass, sizeof (GstGLViewConvertPrivate));

  gobject_class->set_property = gst_gl_view_convert_set_property;

  gobject_class->get_property = gst_gl_view_convert_get_property;

  gobject_class->finalize = gst_gl_view_convert_finalize;

  g_object_class_install_property (gobject_class, PROP_INPUT_LAYOUT,

      g_param_spec_enum ("input-mode-override",

          "Input Multiview Mode Override",

          "Override any input information about multiview layout",

          GST_TYPE_VIDEO_MULTIVIEW_MODE,

          GST_VIDEO_MULTIVIEW_MODE_NONE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_INPUT_FLAGS,

      g_param_spec_flags ("input-flags-override",

          "Input Multiview Flags Override",

          "Override any input information about multiview layout flags",

          GST_TYPE_VIDEO_MULTIVIEW_FLAGS, GST_VIDEO_MULTIVIEW_FLAGS_NONE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_OUTPUT_LAYOUT,

      g_param_spec_enum ("output-mode-override",

          "Output Multiview Mode Override",

          "Override automatic output mode selection for multiview layout",

          GST_TYPE_VIDEO_MULTIVIEW_MODE, GST_VIDEO_MULTIVIEW_MODE_NONE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_OUTPUT_FLAGS,

      g_param_spec_flags ("output-flags-override",

          "Output Multiview Flags Override",

          "Override automatic negotiation for output multiview layout flags",

          GST_TYPE_VIDEO_MULTIVIEW_FLAGS, GST_VIDEO_MULTIVIEW_FLAGS_NONE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_OUTPUT_DOWNMIX_MODE,

      g_param_spec_enum ("downmix-mode", "Mode for mono downmixed output",

          "Output anaglyph type to generate when downmixing to mono",

          GST_TYPE_GL_STEREO_DOWNMIX_MODE_TYPE, DEFAULT_DOWNMIX,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

}

static void

gst_gl_view_convert_init (GstGLViewConvert * convert)

{

  convert->priv = GST_GL_VIEW_CONVERT_GET_PRIVATE (convert);

  convert->shader = NULL;

  convert->downmix_mode = DEFAULT_DOWNMIX;

  convert->priv->input_mode = GST_VIDEO_MULTIVIEW_MODE_NONE;

  convert->priv->input_flags = GST_VIDEO_MULTIVIEW_FLAGS_NONE;

  convert->priv->output_mode = GST_VIDEO_MULTIVIEW_MODE_NONE;

  convert->priv->output_flags = GST_VIDEO_MULTIVIEW_FLAGS_NONE;

  convert->input_mode_override = GST_VIDEO_MULTIVIEW_MODE_NONE;

  convert->input_flags_override = GST_VIDEO_MULTIVIEW_FLAGS_NONE;

  convert->output_mode_override = GST_VIDEO_MULTIVIEW_MODE_NONE;

  convert->output_flags_override = GST_VIDEO_MULTIVIEW_FLAGS_NONE;

  gst_video_info_init (&convert->in_info);

  gst_video_info_init (&convert->out_info);

}

static void

gst_gl_view_convert_finalize (GObject * object)

{

  GstGLViewConvert *viewconvert;

  viewconvert = GST_GL_VIEW_CONVERT (object);

  gst_gl_view_convert_reset (viewconvert);

  gst_buffer_replace (&viewconvert->priv->primary_in, NULL);

  gst_buffer_replace (&viewconvert->priv->auxilliary_in, NULL);

  gst_buffer_replace (&viewconvert->priv->primary_out, NULL);

  gst_buffer_replace (&viewconvert->priv->auxilliary_out, NULL);

  if (viewconvert->context) {

    gst_object_unref (viewconvert->context);

    viewconvert->context = NULL;

  }

  G_OBJECT_CLASS (gst_gl_view_convert_parent_class)->finalize (object);

}

/**

 * gst_gl_view_convert_new:

 *

 * Returns: (transfer full): a new #GstGLViewConvert

 *

 * Since: 1.6

 */

GstGLViewConvert *

gst_gl_view_convert_new (void)

{

  GstGLViewConvert *convert;

  convert = g_object_new (GST_TYPE_GL_VIEW_CONVERT, NULL);

  gst_object_ref_sink (convert);

  return convert;

}

/**

 * gst_gl_view_convert_set_context:

 * @viewconvert: a #GstGLViewConvert

 * @context: the #GstGLContext to set

 *

 * Set @context on @viewconvert

 *

 * Since: 1.6

 */

void

gst_gl_view_convert_set_context (GstGLViewConvert * viewconvert,

    GstGLContext * context)

{

  g_return_if_fail (GST_IS_GL_VIEW_CONVERT (viewconvert));

  if (gst_object_replace ((GstObject **) & viewconvert->context,

          GST_OBJECT (context)))

    gst_gl_view_convert_reset (viewconvert);

}

static gboolean

_view_convert_set_format (GstGLViewConvert * viewconvert,

    GstVideoInfo * in_info, GstGLTextureTarget from_target,

    GstVideoInfo * out_info, GstGLTextureTarget to_target)

{

  gboolean passthrough;

  g_return_val_if_fail (GST_IS_GL_VIEW_CONVERT (viewconvert), FALSE);

  if (gst_video_info_is_equal (in_info, &viewconvert->in_info) &&

      gst_video_info_is_equal (out_info, &viewconvert->out_info) &&

      viewconvert->from_texture_target == from_target &&

      viewconvert->to_texture_target == to_target)

    return TRUE;

  if (GST_VIDEO_INFO_FORMAT (in_info) != GST_VIDEO_FORMAT_RGBA ||

      GST_VIDEO_INFO_FORMAT (out_info) != GST_VIDEO_FORMAT_RGBA) {

    GST_ERROR_OBJECT (viewconvert,

        "Multiview conversion can currently only be performed on RGBA textures");

    return FALSE;

  }

  passthrough = gst_video_info_is_equal (in_info, out_info) &&

      from_target == to_target;

  if (!passthrough && to_target != GST_GL_TEXTURE_TARGET_2D

      && to_target != GST_GL_TEXTURE_TARGET_RECTANGLE)

    return FALSE;

  /* FIXME: Compare what changed and decide if we need a full reset or not */

  GST_OBJECT_LOCK (viewconvert);

  gst_gl_view_convert_reset (viewconvert);

  viewconvert->in_info = *in_info;

  viewconvert->out_info = *out_info;

  viewconvert->from_texture_target = from_target;

  viewconvert->to_texture_target = to_target;

  viewconvert->caps_passthrough = passthrough;

  gst_buffer_replace (&viewconvert->priv->primary_in, NULL);

  gst_buffer_replace (&viewconvert->priv->auxilliary_in, NULL);

  gst_buffer_replace (&viewconvert->priv->primary_out, NULL);

  gst_buffer_replace (&viewconvert->priv->auxilliary_out, NULL);

  GST_OBJECT_UNLOCK (viewconvert);

  return TRUE;

}

/**

 * gst_gl_view_convert_set_caps:

 * @viewconvert: a #GstGLViewConvert

 * @in_caps: input #GstCaps

 * @out_caps: output #GstCaps

 *

 * Initializes @viewconvert with the information required for conversion.

 *

 * Since: 1.6

 */

gboolean

gst_gl_view_convert_set_caps (GstGLViewConvert * viewconvert,

    GstCaps * in_caps, GstCaps * out_caps)

{

  GstVideoInfo in_info, out_info;

  GstCapsFeatures *in_features, *out_features;

  GstGLTextureTarget from_target = GST_GL_TEXTURE_TARGET_2D;

  GstGLTextureTarget to_target = GST_GL_TEXTURE_TARGET_2D;

  g_return_val_if_fail (GST_IS_GL_VIEW_CONVERT (viewconvert), FALSE);

  g_return_val_if_fail (GST_IS_CAPS (in_caps), FALSE);

  g_return_val_if_fail (GST_IS_CAPS (out_caps), FALSE);

  GST_INFO_OBJECT (viewconvert,

      "Configuring multiview conversion from caps %" GST_PTR_FORMAT

      " to %" GST_PTR_FORMAT, in_caps, out_caps);

  in_features = gst_caps_get_features (in_caps, 0);

  out_features = gst_caps_get_features (out_caps, 0);

  if (!gst_caps_features_contains (in_features,

          GST_CAPS_FEATURE_MEMORY_GL_MEMORY))

    return FALSE;

  if (!gst_caps_features_contains (out_features,

          GST_CAPS_FEATURE_MEMORY_GL_MEMORY))

    return FALSE;

  if (!gst_video_info_from_caps (&in_info, in_caps))

    return FALSE;

  if (!gst_video_info_from_caps (&out_info, out_caps))

    return FALSE;

  {

    GstStructure *in_s = gst_caps_get_structure (in_caps, 0);

    GstStructure *out_s = gst_caps_get_structure (out_caps, 0);

    if (gst_structure_has_field_typed (in_s, "texture-target", G_TYPE_STRING)) {

      from_target =

          gst_gl_texture_target_from_string (gst_structure_get_string (in_s,

              "texture-target"));

    }

    if (gst_structure_has_field_typed (out_s, "texture-target", G_TYPE_STRING)) {

      to_target =

          gst_gl_texture_target_from_string (gst_structure_get_string (out_s,

              "texture-target"));

    }

    if (to_target == GST_GL_TEXTURE_TARGET_NONE

        || from_target == GST_GL_TEXTURE_TARGET_NONE)

      /* invalid caps */

      return FALSE;

  }

  return _view_convert_set_format (viewconvert, &in_info, from_target,

      &out_info, to_target);

}

/* Function that can halve the value

 * of ints, fractions, int/fraction ranges and lists of ints/fractions */

static gboolean

_halve_value (GValue * out, const GValue * in_value)

{

  /* Fundamental fixed types first */

  if (G_VALUE_HOLDS_INT (in_value)) {

    g_value_init (out, G_TYPE_INT);

    g_value_set_int (out, MAX (g_value_get_int (in_value) / 2, 1));

  } else if (GST_VALUE_HOLDS_FRACTION (in_value)) {

    gint num, den;

    num = gst_value_get_fraction_numerator (in_value);

    den = gst_value_get_fraction_denominator (in_value);

    g_value_init (out, GST_TYPE_FRACTION);

    /* Don't adjust 'infinite' fractions */

    if ((num != 1 || den != 2147483647) && (num != 2147483647 || den != 1)) {

      /* FIXME - could do better approximation when den > G_MAXINT/2? */

      den = den > G_MAXINT / 2 ? G_MAXINT : den * 2;

    }

    gst_value_set_fraction (out, num, den);

  } else if (GST_VALUE_HOLDS_INT_RANGE (in_value)) {

    gint range_min = gst_value_get_int_range_min (in_value);

    gint range_max = gst_value_get_int_range_max (in_value);

    gint range_step = gst_value_get_int_range_step (in_value);

    g_value_init (out, GST_TYPE_INT_RANGE);

    if (range_min != 1)

      range_min = MAX (1, range_min / 2);

    if (range_max != G_MAXINT)

      range_max = MAX (1, range_max / 2);

    gst_value_set_int_range_step (out, range_min,

        range_max, MAX (1, range_step / 2));

  } else if (GST_VALUE_HOLDS_FRACTION_RANGE (in_value)) {

    GValue min_out = G_VALUE_INIT;

    GValue max_out = G_VALUE_INIT;

    const GValue *range_min = gst_value_get_fraction_range_min (in_value);

    const GValue *range_max = gst_value_get_fraction_range_max (in_value);

    _halve_value (&min_out, range_min);

    _halve_value (&max_out, range_max);

    g_value_init (out, GST_TYPE_FRACTION_RANGE);

    gst_value_set_fraction_range (out, &min_out, &max_out);

    g_value_unset (&min_out);

    g_value_unset (&max_out);

  } else if (GST_VALUE_HOLDS_LIST (in_value)) {

    gint i;

    g_value_init (out, GST_TYPE_LIST);

    for (i = 0; i < gst_value_list_get_size (in_value); i++) {

      const GValue *entry;

      GValue tmp = G_VALUE_INIT;

      entry = gst_value_list_get_value (in_value, i);

      /* Random list values might not be the right type */

      if (!_halve_value (&tmp, entry))

        goto fail;

      gst_value_list_append_and_take_value (out, &tmp);

    }

  } else {

    return FALSE;

  }

  return TRUE;

fail:

  g_value_unset (out);

  return FALSE;

}

static GstStructure *

_halve_structure_field (const GstStructure * in, const gchar * field_name)

{

  GstStructure *out;

  const GValue *in_value = gst_structure_get_value (in, field_name);

  GValue tmp = G_VALUE_INIT;

  if (G_UNLIKELY (in_value == NULL))

    return gst_structure_copy (in);     /* Field doesn't exist, leave it as is */

  if (!_halve_value (&tmp, in_value))

    return NULL;

  out = gst_structure_copy (in);

  gst_structure_set_value (out, field_name, &tmp);

  g_value_unset (&tmp);

  return out;

}

/* Function that can double the value

 * of ints, fractions, int/fraction ranges and lists of ints/fractions */

static gboolean

_double_value (GValue * out, const GValue * in_value)

{

  /* Fundamental fixed types first */

  if (G_VALUE_HOLDS_INT (in_value)) {

    gint n = g_value_get_int (in_value);

    g_value_init (out, G_TYPE_INT);

    if (n <= G_MAXINT / 2)

      g_value_set_int (out, n * 2);

    else

      g_value_set_int (out, G_MAXINT);

  } else if (GST_VALUE_HOLDS_FRACTION (in_value)) {

    gint num, den;

    num = gst_value_get_fraction_numerator (in_value);

    den = gst_value_get_fraction_denominator (in_value);

    g_value_init (out, GST_TYPE_FRACTION);

    /* Don't adjust 'infinite' fractions */

    if ((num != 1 || den != 2147483647) && (num != 2147483647 || den != 1)) {

      /* FIXME - could do better approximation when num > G_MAXINT/2? */

      num = num > G_MAXINT / 2 ? G_MAXINT : num * 2;

    }

    gst_value_set_fraction (out, num, den);

  } else if (GST_VALUE_HOLDS_INT_RANGE (in_value)) {

    gint range_min = gst_value_get_int_range_min (in_value);

    gint range_max = gst_value_get_int_range_max (in_value);

    gint range_step = gst_value_get_int_range_step (in_value);

    if (range_min != 1) {

      range_min = MIN (G_MAXINT / 2, range_min);

      range_min *= 2;

    }

    if (range_max != G_MAXINT) {

      range_max = MIN (G_MAXINT / 2, range_max);

      range_max *= 2;

    }

    range_step = MIN (G_MAXINT / 2, range_step);

    g_value_init (out, GST_TYPE_INT_RANGE);

    gst_value_set_int_range_step (out, range_min, range_max, range_step);

  } else if (GST_VALUE_HOLDS_FRACTION_RANGE (in_value)) {

    GValue min_out = G_VALUE_INIT;

    GValue max_out = G_VALUE_INIT;

    const GValue *range_min = gst_value_get_fraction_range_min (in_value);

    const GValue *range_max = gst_value_get_fraction_range_max (in_value);

    _double_value (&min_out, range_min);

    _double_value (&max_out, range_max);

    g_value_init (out, GST_TYPE_FRACTION_RANGE);

    gst_value_set_fraction_range (out, &min_out, &max_out);

    g_value_unset (&min_out);

    g_value_unset (&max_out);

  } else if (GST_VALUE_HOLDS_LIST (in_value)) {

    gint i;

    g_value_init (out, GST_TYPE_LIST);

    for (i = 0; i < gst_value_list_get_size (in_value); i++) {

      const GValue *entry;

      GValue tmp = G_VALUE_INIT;

      entry = gst_value_list_get_value (in_value, i);

      /* Random list values might not be the right type */

      if (!_double_value (&tmp, entry))

        goto fail;

      gst_value_list_append_and_take_value (out, &tmp);

    }

  } else {

    return FALSE;

  }

  return TRUE;

fail:

  g_value_unset (out);

  return FALSE;

}

static GstStructure *

_double_structure_field (const GstStructure * in, const gchar * field_name)

{

  GstStructure *out;

  const GValue *in_value = gst_structure_get_value (in, field_name);

  GValue tmp = G_VALUE_INIT;

  if (G_UNLIKELY (in_value == NULL))

    return gst_structure_copy (in);     /* Field doesn't exist, leave it as is */

  if (!_double_value (&tmp, in_value))

    return NULL;

  out = gst_structure_copy (in);

  gst_structure_set_value (out, field_name, &tmp);

  g_value_unset (&tmp);

  return out;

}

/* Return a copy of the caps with the requested field halved in value/range */

#if 0

static GstCaps *

_halve_caps_field (const GstCaps * in, const gchar * field_name)

{

  gint i;

  GstCaps *out = gst_caps_new_empty ();

  for (i = 0; i < gst_caps_get_size (in); i++) {

    const GstStructure *cur = gst_caps_get_structure (in, i);

    GstCapsFeatures *f = gst_caps_get_features (in, i);

    GstStructure *res = _halve_structure_field (cur, field_name);

    out =

        gst_caps_merge_structure_full (out, res,

        f ? gst_caps_features_copy (f) : NULL);

  }

  return out;

}

#endif

/* Return a copy of the caps with the requested field doubled in value/range */

static GstCaps *

_double_caps_field (const GstCaps * in, const gchar * field_name)

{

  gint i;

  GstCaps *out = gst_caps_new_empty ();

  for (i = 0; i < gst_caps_get_size (in); i++) {

    const GstStructure *cur = gst_caps_get_structure (in, i);

    GstCapsFeatures *f = gst_caps_get_features (in, i);

    GstStructure *res = _double_structure_field (cur, field_name);

    out =

        gst_caps_merge_structure_full (out, res,

        f ? gst_caps_features_copy (f) : NULL);

  }

  return out;

}

/* Takes ownership of the input caps  */

static GstCaps *

_expand_par_for_half_aspect (GstCaps * in, gboolean vertical_half_aspect)

{

  guint mview_flags, mview_flags_mask;

  GstCaps *out;

  GstStructure *tmp;

  out = gst_caps_new_empty ();

  while (gst_caps_get_size (in) > 0) {

    GstStructure *s;

    GstCapsFeatures *features;

    features = gst_caps_get_features (in, 0);

    if (features)

      features = gst_caps_features_copy (features);

    s = gst_caps_steal_structure (in, 0);

    if (!gst_structure_get_flagset (s, "multiview-flags", &mview_flags,

            &mview_flags_mask)) {

      gst_caps_append_structure_full (out, s, features);

      continue;

    }

    /* If the input doesn't care about the half-aspect flag, allow current PAR in either variant */

    if ((mview_flags_mask & GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT) == 0) {

      gst_caps_append_structure_full (out, s, features);

      continue;

    }

    if (!gst_structure_has_field (s, "pixel-aspect-ratio")) {

      /* No par field, dont-care the half-aspect flag */

      gst_structure_set (s, "multiview-flags",

          GST_TYPE_VIDEO_MULTIVIEW_FLAGSET,

          mview_flags & ~GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT,

          mview_flags_mask & ~GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT, NULL);

      gst_caps_append_structure_full (out, s, features);

      continue;

    }

    /* Halve or double PAR base on inputs input specified. */

    /* Append a copy with the half-aspect flag as-is */

    tmp = gst_structure_copy (s);

    out = gst_caps_merge_structure_full (out, tmp,

        features ? gst_caps_features_copy (features) : NULL);

    /* and then a copy inverted */

    if (mview_flags & GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT) {

      /* Input is half-aspect. Double/halve the PAR, clear the flag */

      if (vertical_half_aspect)

        tmp = _halve_structure_field (s, "pixel-aspect-ratio");

      else

        tmp = _double_structure_field (s, "pixel-aspect-ratio");

      /* Clear the flag */

      gst_structure_set (tmp, "multiview-flags",

          GST_TYPE_VIDEO_MULTIVIEW_FLAGSET,

          mview_flags & ~GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT,

          mview_flags_mask | GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT, NULL);

    } else {

      if (vertical_half_aspect)

        tmp = _double_structure_field (s, "pixel-aspect-ratio");

      else

        tmp = _halve_structure_field (s, "pixel-aspect-ratio");

      /* Set the flag */

      gst_structure_set (tmp, "multiview-flags",

          GST_TYPE_VIDEO_MULTIVIEW_FLAGSET,

          mview_flags | GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT,

          mview_flags_mask | GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT, NULL);

    }

    out = gst_caps_merge_structure_full (out, tmp,

        features ? gst_caps_features_copy (features) : NULL);

    gst_structure_free (s);

    if (features)

      gst_caps_features_free (features);

  }

  gst_caps_unref (in);

  return out;

}

/* If input supports top-bottom or row-interleaved, we may halve height to mono frames.

 * If input supports left-right, checkerboard, quincunx or column-interleaved,

 * we may halve width to mono frames.

 * For output of top-bottom or row-interleaved, we may double the mono height

 * For output of left-right, checkerboard, quincunx or column-interleaved,

 * we may double the mono width.

 * In all cases, if input has half-aspect and output does not, we may double the PAR

 * And if input does *not* have half-aspect flag and output does not, we may halve the PAR

 */

static GstCaps *

_expand_structure (GstGLViewConvert * viewconvert,

    GstCaps * out_caps, GstStructure * structure, GstCapsFeatures * features)

{

  GstCaps *expanded_caps, *tmp;

  GstCaps *mono_caps;

  const gchar *default_mview_mode_str = NULL;

  guint mview_flags, mview_flags_mask;

  const GValue *in_modes;

  gint i;

  /* Empty caps to accumulate into */

  expanded_caps = gst_caps_new_empty ();

  /* First, set defaults if multiview flags are missing */

  default_mview_mode_str =

      gst_video_multiview_mode_to_caps_string (GST_VIDEO_MULTIVIEW_MODE_MONO);

  mview_flags = GST_VIDEO_MULTIVIEW_FLAGS_NONE;

  mview_flags_mask = GST_FLAG_SET_MASK_EXACT;

  if (!gst_structure_has_field (structure, "multiview-mode")) {

    gst_structure_set (structure,

        "multiview-mode", G_TYPE_STRING, default_mview_mode_str, NULL);

  }

  if (!gst_structure_has_field (structure, "multiview-flags")) {

    gst_structure_set (structure,

        "multiview-flags", GST_TYPE_VIDEO_MULTIVIEW_FLAGSET, mview_flags,

        mview_flags_mask, NULL);

  } else {

    gst_structure_get_flagset (structure, "multiview-flags",

        &mview_flags, &mview_flags_mask);

  }

  in_modes = gst_structure_get_value (structure, "multiview-mode");

  mono_caps = gst_caps_new_empty ();

  if (gst_value_intersect (NULL, in_modes,

          gst_video_multiview_get_mono_modes ())) {

    GstStructure *new_struct = gst_structure_copy (structure);

    gst_structure_set_value (new_struct, "multiview-mode",

        gst_video_multiview_get_mono_modes ());

    /* Half-aspect makes no sense for mono or unpacked, get rid of it */

    if (mview_flags & GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT) {

      gst_structure_set (new_struct, "multiview-flags",

          GST_TYPE_VIDEO_MULTIVIEW_FLAGSET,

          mview_flags & ~GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT,

          mview_flags_mask & ~GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT, NULL);

    }

    gst_caps_append_structure_full (mono_caps, new_struct,

        features ? gst_caps_features_copy (features) : NULL);

  }

  if (gst_value_intersect (NULL, in_modes,

          gst_video_multiview_get_unpacked_modes ())) {

    GstStructure *new_struct = gst_structure_copy (structure);

    gst_structure_set_value (new_struct, "multiview-mode",

        gst_video_multiview_get_mono_modes ());

    /* Half-aspect makes no sense for mono or unpacked, get rid of it */

    if (mview_flags & GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT) {

      gst_structure_set (new_struct, "multiview-flags",

          GST_TYPE_VIDEO_MULTIVIEW_FLAGSET,

          mview_flags & ~GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT,

          mview_flags_mask & ~GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT, NULL);

    }

    gst_caps_append_structure_full (mono_caps, new_struct,

        features ? gst_caps_features_copy (features) : NULL);

  }