/*

 * GStreamer

 * Copyright (C) 2012-2014 Matthew Waters <ystree00@gmail.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 <stdio.h>

#include "gstglcolorconvert.h"

#include "gl.h"

#include "gstglfuncs.h"

#include "gstglsl_private.h"

/**

 * SECTION:gstglcolorconvert

 * @title: GstGLColorConvert

 * @short_description: convert between video color spaces and formats

 * @see_also: #GstGLUpload, #GstGLMemory, #GstGLBaseMemory

 *

 * #GstGLColorConvert is an object that converts between color spaces and/or

 * formats using OpenGL Shaders.

 *

 * A #GstGLColorConvert can be created with gst_gl_color_convert_new(), the

 * configuration negotiated with gst_gl_color_convert_transform_caps() and the

 * conversion performed with gst_gl_color_convert_perform().

 *

 * The glcolorconvertelement provides a GStreamer element that uses

 * #GstGLColorConvert to convert between video formats and color spaces.

 */

#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 void _do_convert (GstGLContext * context, GstGLColorConvert * convert);

static gboolean _init_convert (GstGLColorConvert * convert);

static gboolean _init_convert_fbo (GstGLColorConvert * convert);

static GstBuffer *_gst_gl_color_convert_perform_unlocked (GstGLColorConvert *

    convert, GstBuffer * inbuf);

static gboolean _do_convert_draw (GstGLContext * context,

    GstGLColorConvert * convert);

/* *INDENT-OFF* */

#define YUV_TO_RGB_COEFFICIENTS \

      "uniform vec3 offset;\n" \

      "uniform vec3 coeff1;\n" \

      "uniform vec3 coeff2;\n" \

      "uniform vec3 coeff3;\n"

/* FIXME: use the colormatrix support from videoconvert */

/* BT. 601 standard with the following ranges:

 * Y = [16..235] (of 255)

 * Cb/Cr = [16..240] (of 255)

 */

static const gfloat from_yuv_bt601_offset[] = {-0.0625f, -0.5f, -0.5f};

static const gfloat from_yuv_bt601_rcoeff[] = {1.164f, 0.000f, 1.596f};

static const gfloat from_yuv_bt601_gcoeff[] = {1.164f,-0.391f,-0.813f};

static const gfloat from_yuv_bt601_bcoeff[] = {1.164f, 2.018f, 0.000f};

/* BT. 709 standard with the following ranges:

 * Y = [16..235] (of 255)

 * Cb/Cr = [16..240] (of 255)

 */

static const gfloat from_yuv_bt709_offset[] = {-0.0625f, -0.5f, -0.5f};

static const gfloat from_yuv_bt709_rcoeff[] = {1.164f, 0.000f, 1.787f};

static const gfloat from_yuv_bt709_gcoeff[] = {1.164f,-0.213f,-0.531f};

static const gfloat from_yuv_bt709_bcoeff[] = {1.164f,2.112f, 0.000f};

#define RGB_TO_YUV_COEFFICIENTS \

      "uniform vec3 offset;\n" \

      "uniform vec3 coeff1;\n" \

      "uniform vec3 coeff2;\n" \

      "uniform vec3 coeff3;\n"

/* Matrix inverses of the color matrices found above */

/* BT. 601 standard with the following ranges:

 * Y = [16..235] (of 255)

 * Cb/Cr = [16..240] (of 255)

 */

static const gfloat from_rgb_bt601_offset[] = {0.0625f, 0.5f, 0.5f};

static const gfloat from_rgb_bt601_ycoeff[] = {0.256816f, 0.504154f, 0.0979137f};

static const gfloat from_rgb_bt601_ucoeff[] = {-0.148246f, -0.29102f, 0.439266f};

static const gfloat from_rgb_bt601_vcoeff[] = {0.439271f, -0.367833f, -0.071438f};

/* BT. 709 standard with the following ranges:

 * Y = [16..235] (of 255)

 * Cb/Cr = [16..240] (of 255)

 */

static const gfloat from_rgb_bt709_offset[] = {0.0625f, 0.5f, 0.5f};

static const gfloat from_rgb_bt709_ycoeff[] = {0.182604f, 0.614526f, 0.061976f};

static const gfloat from_rgb_bt709_ucoeff[] = {-0.100640f, -0.338688f, 0.439327f};

static const gfloat from_rgb_bt709_vcoeff[] = {0.440654f, -0.400285f, -0.040370f};

/* GRAY16 to RGB conversion

 *  data transfered as GL_LUMINANCE_ALPHA then convert back to GRAY16 

 *  high byte weight as : 255*256/65535 

 *  ([0~1] denormalize to [0~255],shift to high byte,normalize to [0~1])

 *  low byte weight as : 255/65535 (similar)

 * */

#define COMPOSE_WEIGHT \

    "const vec2 compose_weight = vec2(0.996109, 0.003891);\n"

#define DEFAULT_UNIFORMS         \

    "#ifdef GL_ES\n"             \

    "precision mediump float;\n" \

    "#endif\n"                   \

    "uniform vec2 tex_scale0;\n" \

    "uniform vec2 tex_scale1;\n" \

    "uniform vec2 tex_scale2;\n" \

    "uniform float width;\n"     \

    "uniform float height;\n"    \

    "uniform float poffset_x;\n" \

    "uniform float poffset_y;\n"

#define MAX_FUNCTIONS 4

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

struct shader_templ

{

  const gchar *extensions;

  const gchar *uniforms;

  const gchar *functions[MAX_FUNCTIONS];

  GstGLTextureTarget target;

};

#define glsl_func_yuv_to_rgb \

    "vec3 yuv_to_rgb (vec3 val, vec3 offset, vec3 ycoeff, vec3 ucoeff, vec3 vcoeff) {\n" \

    "  vec3 rgb;\n"                 \

    "  val += offset;\n"            \

    "  rgb.r = dot(val, ycoeff);\n" \

    "  rgb.g = dot(val, ucoeff);\n" \

    "  rgb.b = dot(val, vcoeff);\n" \

    "  return rgb;\n"               \

    "}\n"

#define glsl_func_rgb_to_yuv \

    "vec3 rgb_to_yuv (vec3 val, vec3 offset, vec3 rcoeff, vec3 gcoeff, vec3 bcoeff) {\n" \

    "  vec3 yuv;\n"                         \

    "  yuv.r = dot(val.rgb, rcoeff);\n"     \

    "  yuv.g = dot(val.rgb, gcoeff);\n"     \

    "  yuv.b = dot(val.rgb, bcoeff);\n"     \

    "  yuv += offset;\n"                    \

    "  return yuv;\n"                       \

    "}\n"

/* Channel reordering for XYZ <-> ZYX conversion */

static const gchar templ_REORDER_BODY[] =

    "vec4 t = texture2D(tex, texcoord * tex_scale0);\n"

    "%s\n" /* clobber alpha channel? */

    "gl_FragColor = vec4(t.%c, t.%c, t.%c, t.%c);\n";

static const struct shader_templ templ_REORDER =

  { NULL,

    DEFAULT_UNIFORMS "uniform sampler2D tex;\n",

    { NULL, },

    GST_GL_TEXTURE_TARGET_2D

  };

/* GRAY16 to RGB conversion

 *  data transfered as GL_LUMINANCE_ALPHA then convert back to GRAY16 

 *  high byte weight as : 255*256/65535 

 *  ([0~1] denormalize to [0~255],shift to high byte,normalize to [0~1])

 *  low byte weight as : 255/65535 (similar)

 * */

static const gchar templ_COMPOSE_BODY[] =

    "vec4 rgba;\n"

    "vec4 t = texture2D(tex, texcoord * tex_scale0);\n"

    "rgba.rgb = vec3 (dot(t.%c%c, compose_weight));"

    "rgba.a = 1.0;\n"

    "gl_FragColor = vec4(rgba.%c, rgba.%c, rgba.%c, rgba.%c);\n";

static const struct shader_templ templ_COMPOSE =

  { NULL,

    DEFAULT_UNIFORMS COMPOSE_WEIGHT "uniform sampler2D tex;\n",

    { NULL, },

    GST_GL_TEXTURE_TARGET_2D

  };

static const gchar templ_AYUV_to_RGB_BODY[] =

    "vec4 texel, rgba;\n"

    "texel = texture2D(tex, texcoord * tex_scale0);\n"

    "rgba.rgb = yuv_to_rgb (texel.yzw, offset, coeff1, coeff2, coeff3);\n"

    "rgba.a = texel.r;\n"

    "gl_FragColor=vec4(rgba.%c,rgba.%c,rgba.%c,rgba.%c);\n";

static const struct shader_templ templ_AYUV_to_RGB =

  { NULL,

    DEFAULT_UNIFORMS YUV_TO_RGB_COEFFICIENTS "uniform sampler2D tex;\n",

    { glsl_func_yuv_to_rgb, NULL, },

    GST_GL_TEXTURE_TARGET_2D

  };

static const gchar templ_RGB_to_AYUV_BODY[] =

    "vec4 texel, ayuv;\n"

    "texel = texture2D(tex, texcoord).%c%c%c%c;\n"

    "ayuv.yzw = rgb_to_yuv (texel.rgb, offset, coeff1, coeff2, coeff3);\n"

    "ayuv.x = %s;\n"

    "gl_FragColor = ayuv;\n";

static const struct shader_templ templ_RGB_to_AYUV =

  { NULL,

    DEFAULT_UNIFORMS RGB_TO_YUV_COEFFICIENTS "uniform sampler2D tex;\n",

    { glsl_func_rgb_to_yuv, NULL, },

    GST_GL_TEXTURE_TARGET_2D

  };

/* YUV to RGB conversion */

static const gchar templ_PLANAR_YUV_to_RGB_BODY[] =

    "vec4 texel, rgba;\n"

    /* FIXME: should get the sampling right... */

    "texel.x = texture2D(Ytex, texcoord * tex_scale0).r;\n"

    "texel.y = texture2D(Utex, texcoord * tex_scale1).r;\n"

    "texel.z = texture2D(Vtex, texcoord * tex_scale2).r;\n"

    "rgba.rgb = yuv_to_rgb (texel.xyz, offset, coeff1, coeff2, coeff3);\n"

    "rgba.a = 1.0;\n"

    "gl_FragColor=vec4(rgba.%c,rgba.%c,rgba.%c,rgba.%c);\n";

static const struct shader_templ templ_PLANAR_YUV_to_RGB =

  { NULL,

    DEFAULT_UNIFORMS YUV_TO_RGB_COEFFICIENTS "uniform sampler2D Ytex, Utex, Vtex;\n",

    { glsl_func_yuv_to_rgb, NULL, },

    GST_GL_TEXTURE_TARGET_2D

  };

static const gchar templ_RGB_to_PLANAR_YUV_BODY[] =

    "vec4 texel;\n"

    "vec3 yuv;\n"

    "texel = texture2D(tex, texcoord).%c%c%c%c;\n"

    /* FIXME: this is not quite correct yet */

    "vec4 uv_texel = vec4(0.0);\n"

    /* One u and v sample can be generated by a nxm sized block given by     */

    /* @chroma_sampling.  The result is the average of all the values in the */

    /* block computed with a rolling average. */

    "vec2 unnormalization;\n"

    "if (texcoord.x == v_texcoord.x) {\n"

    "  unnormalization = vec2(width, height);\n"

    "} else {\n"

    "  unnormalization = vec2 (1.0);\n"

    "}\n"

     /* scale for chroma size */

    "vec2 chroma_pos = texcoord * chroma_sampling * unnormalization;\n"

     /* offset chroma to the center of the first texel in the block */

    "chroma_pos -= clamp(chroma_sampling * 0.5 - 0.5, vec2(0.0), chroma_sampling);\n"

    "if (chroma_pos.x < width && chroma_pos.y < height) {\n"

    "  for (int i = 0; i < int(chroma_sampling.x); i++) {\n"

    "    vec2 delta = vec2 (float(i), 0.0);\n"

    "    for (int j = 0; j < int(chroma_sampling.y); j++) {\n"

    "      int n = (i+1)*(j+1);\n"

    "      delta.y = float(j);\n"

    "      vec4 s = texture2D(tex, (chroma_pos + delta) / unnormalization).%c%c%c%c;\n"

           /* rolling average */

    "      uv_texel = (float(n-1) * uv_texel + s) / float(n);\n"

    "    }\n"

    "  }\n"

    "}\n"

    "yuv.x = rgb_to_yuv (texel.rgb, offset, coeff1, coeff2, coeff3).x;\n"

    "yuv.yz = rgb_to_yuv (uv_texel.rgb, offset, coeff1, coeff2, coeff3).yz;\n"

    "gl_FragData[0] = vec4(yuv.x, 0.0, 0.0, 1.0);\n"

    "gl_FragData[1] = vec4(yuv.y, 0.0, 0.0, 1.0);\n"

    "gl_FragData[2] = vec4(yuv.z, 0.0, 0.0, 1.0);\n";

static const struct shader_templ templ_RGB_to_PLANAR_YUV =

  { NULL,

    DEFAULT_UNIFORMS RGB_TO_YUV_COEFFICIENTS "uniform sampler2D tex;\n"

    "uniform vec2 chroma_sampling;\n",

    { glsl_func_rgb_to_yuv, NULL, },

    GST_GL_TEXTURE_TARGET_2D

  };

/* NV12/NV21 to RGB conversion */

static const gchar templ_NV12_NV21_to_RGB_BODY[] =

    "vec4 rgba;\n"

    "vec3 yuv;\n"

    /* FIXME: should get the sampling right... */

    "yuv.x=texture2D(Ytex, texcoord * tex_scale0).r;\n"

    "yuv.yz=texture2D(UVtex, texcoord * tex_scale1).%c%c;\n"

    "rgba.rgb = yuv_to_rgb (yuv, offset, coeff1, coeff2, coeff3);\n"

    "rgba.a = 1.0;\n"

    "gl_FragColor=vec4(rgba.%c,rgba.%c,rgba.%c,rgba.%c);\n";

static const struct shader_templ templ_NV12_NV21_to_RGB =

  { NULL,

    DEFAULT_UNIFORMS YUV_TO_RGB_COEFFICIENTS "uniform sampler2D Ytex, UVtex;\n",

    { glsl_func_yuv_to_rgb, NULL, },

    GST_GL_TEXTURE_TARGET_2D

  };

/* RGB to NV12/NV21 conversion */

/* NV12: u, v

   NV21: v, u */

static const gchar templ_RGB_to_NV12_NV21_BODY[] =

    "vec4 texel, uv_texel;\n"

    "vec3 yuv;\n"

    "texel = texture2D(tex, texcoord).%c%c%c%c;\n"

    "uv_texel = texture2D(tex, texcoord * tex_scale0 * 2.0).%c%c%c%c;\n"

    "yuv.x = rgb_to_yuv (texel.rgb, offset, coeff1, coeff2, coeff3).x;\n"

    "yuv.yz = rgb_to_yuv (uv_texel.rgb, offset, coeff1, coeff2, coeff3).yz;\n"

    "gl_FragData[0] = vec4(yuv.x, 0.0, 0.0, 1.0);\n"

    "gl_FragData[1] = vec4(yuv.%c, yuv.%c, 0.0, 1.0);\n";

static const struct shader_templ templ_RGB_to_NV12_NV21 =

  { NULL,

    DEFAULT_UNIFORMS RGB_TO_YUV_COEFFICIENTS "uniform sampler2D tex;\n",

    { glsl_func_rgb_to_yuv, NULL, },

    GST_GL_TEXTURE_TARGET_2D

  };

/* YUY2:r,g,a

   UYVY:a,b,r */

static const gchar templ_YUY2_UYVY_to_RGB_BODY[] =

    "vec4 rgba, uv_texel;\n"

    "vec3 yuv;\n"

    /* FIXME: should get the sampling right... */

    "float dx1 = -poffset_x;\n"

    "float dx2 = 0.0;\n"

    "yuv.x = texture2D(Ytex, texcoord * tex_scale0).%c;\n"

    /* v_texcoord are normalized, texcoord may not be e.g. rectangle textures */

    "float inorder = mod (v_texcoord.x * width, 2.0);\n"

    "if (inorder < 1.0) {\n"

    "  dx2 = -dx1;\n"

    "  dx1 = 0.0;\n"

    "}\n"

    "uv_texel.rg = texture2D(Ytex, texcoord * tex_scale0 + vec2(dx1, 0.0)).r%c;\n"

    "uv_texel.ba = texture2D(Ytex, texcoord * tex_scale0 + vec2(dx2, 0.0)).r%c;\n"

    "yuv.yz = uv_texel.%c%c;\n"

    "rgba.rgb = yuv_to_rgb (yuv, offset, coeff1, coeff2, coeff3);\n"

    "rgba.a = 1.0;\n"

    "gl_FragColor = vec4(rgba.%c,rgba.%c,rgba.%c,rgba.%c);\n";

static const struct shader_templ templ_YUY2_UYVY_to_RGB =

  { NULL,

    DEFAULT_UNIFORMS YUV_TO_RGB_COEFFICIENTS "uniform sampler2D Ytex;\n",

    { glsl_func_yuv_to_rgb, NULL, },

    GST_GL_TEXTURE_TARGET_2D

  };

static const gchar templ_RGB_to_YUY2_UYVY_BODY[] =

    "vec4 texel1, texel2;\n"

    "vec3 yuv, yuv1, yuv2;\n"

    "float fx, dx, fy;\n"

    /* v_texcoord are normalized, texcoord may not be e.g. rectangle textures */

    "float inorder = mod (v_texcoord.x * width, 2.0);\n"

    "fx = texcoord.x;\n"

    "dx = poffset_x;\n"

    "if (inorder > 1.0) {\n"

    "  dx = -dx;\n"

    "}\n"

    "fy = texcoord.y;\n"

    "texel1 = texture2D(tex, vec2(fx, fy)).%c%c%c%c;\n"

    "texel2 = texture2D(tex, vec2(fx + dx, fy)).%c%c%c%c;\n"

    "yuv1 = rgb_to_yuv (texel1.rgb, offset, coeff1, coeff2, coeff3);\n"

    "yuv2 = rgb_to_yuv (texel2.rgb, offset, coeff1, coeff2, coeff3);\n"

    "yuv.x = yuv1.x;\n"

    "yuv.yz = (yuv1.yz + yuv2.yz) * 0.5;\n"

    "if (inorder < 1.0) {\n"

    "  gl_FragColor = vec4(yuv.%c, yuv.%c, 0.0, 0.0);\n"

    "} else {\n"

    "  gl_FragColor = vec4(yuv.%c, yuv.%c, 0.0, 0.0);\n"

    "}\n";

static const struct shader_templ templ_RGB_to_YUY2_UYVY =

  { NULL,

    DEFAULT_UNIFORMS RGB_TO_YUV_COEFFICIENTS "uniform sampler2D tex;\n",

    { glsl_func_rgb_to_yuv, NULL, },

    GST_GL_TEXTURE_TARGET_2D

  };

static const gchar text_vertex_shader[] =

    "attribute vec4 a_position;   \n"

    "attribute vec2 a_texcoord;   \n"

    "varying vec2 v_texcoord;     \n"

    "void main()                  \n"

    "{                            \n"

    "  gl_Position = a_position; \n"

    "  v_texcoord = a_texcoord;  \n"

    "}                            \n";

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 };

/* *INDENT-ON* */

struct ConvertInfo

{

  gint in_n_textures;

  gint out_n_textures;

  const struct shader_templ *templ;

  gchar *frag_body;

  gchar *frag_prog;

  const gchar *shader_tex_names[GST_VIDEO_MAX_PLANES];

  gfloat *cms_offset;

  gfloat *cms_coeff1;           /* r,y */

  gfloat *cms_coeff2;           /* g,u */

  gfloat *cms_coeff3;           /* b,v */

  gfloat chroma_sampling[2];

};

struct _GstGLColorConvertPrivate

{

  gboolean result;

  struct ConvertInfo convert_info;

  GstGLTextureTarget from_texture_target;

  GstGLTextureTarget to_texture_target;

  GstGLMemory *in_tex[GST_VIDEO_MAX_PLANES];

  GstGLMemory *out_tex[GST_VIDEO_MAX_PLANES];

  GstGLFormat in_tex_formats[GST_VIDEO_MAX_PLANES];

  GLuint vao;

  GLuint vertex_buffer;

  GLuint vbo_indices;

  GLuint attr_position;

  GLuint attr_texture;

  GstCaps *in_caps;

  GstCaps *out_caps;

  GstBufferPool *pool;

  gboolean pool_started;

};

GST_DEBUG_CATEGORY_STATIC (gst_gl_color_convert_debug);

#define GST_CAT_DEFAULT gst_gl_color_convert_debug

#define DEBUG_INIT \

  GST_DEBUG_CATEGORY_INIT (gst_gl_color_convert_debug, "glconvert", 0, "convert");

G_DEFINE_TYPE_WITH_CODE (GstGLColorConvert, gst_gl_color_convert,

    GST_TYPE_OBJECT, DEBUG_INIT);

static void gst_gl_color_convert_finalize (GObject * object);

static void gst_gl_color_convert_reset (GstGLColorConvert * convert);

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

    GST_TYPE_GL_COLOR_CONVERT, GstGLColorConvertPrivate))

static void

gst_gl_color_convert_class_init (GstGLColorConvertClass * klass)

{

  g_type_class_add_private (klass, sizeof (GstGLColorConvertPrivate));

  G_OBJECT_CLASS (klass)->finalize = gst_gl_color_convert_finalize;

}

static void

gst_gl_color_convert_init (GstGLColorConvert * convert)

{

  convert->priv = GST_GL_COLOR_CONVERT_GET_PRIVATE (convert);

  gst_gl_color_convert_reset (convert);

}

/**

 * gst_gl_color_convert_new:

 * @context: a #GstGLContext

 *

 * Returns: (transfer full): a new #GstGLColorConvert object

 *

 * Since: 1.4

 */

GstGLColorConvert *

gst_gl_color_convert_new (GstGLContext * context)

{

  GstGLColorConvert *convert;

  convert = g_object_new (GST_TYPE_GL_COLOR_CONVERT, NULL);

  gst_object_ref_sink (convert);

  convert->context = gst_object_ref (context);

  gst_video_info_set_format (&convert->in_info, GST_VIDEO_FORMAT_ENCODED, 0, 0);

  gst_video_info_set_format (&convert->out_info, GST_VIDEO_FORMAT_ENCODED, 0,

      0);

  GST_DEBUG_OBJECT (convert,

      "Created new colorconvert for context %" GST_PTR_FORMAT, context);

  return convert;

}

static void

gst_gl_color_convert_finalize (GObject * object)

{

  GstGLColorConvert *convert;

  convert = GST_GL_COLOR_CONVERT (object);

  gst_gl_color_convert_reset (convert);

  if (convert->context) {

    gst_object_unref (convert->context);

    convert->context = NULL;

  }

  G_OBJECT_CLASS (gst_gl_color_convert_parent_class)->finalize (object);

}

static void

_reset_gl (GstGLContext * context, GstGLColorConvert * convert)

{

  const GstGLFuncs *gl = context->gl_vtable;

  if (convert->priv->vao) {

    gl->DeleteVertexArrays (1, &convert->priv->vao);

    convert->priv->vao = 0;

  }

  if (convert->priv->vertex_buffer) {

    gl->DeleteBuffers (1, &convert->priv->vertex_buffer);

    convert->priv->vertex_buffer = 0;

  }

  if (convert->priv->vbo_indices) {

    gl->DeleteBuffers (1, &convert->priv->vbo_indices);

    convert->priv->vbo_indices = 0;

  }

}

static void

gst_gl_color_convert_reset_shader (GstGLColorConvert * convert)

{

  convert->priv->convert_info.chroma_sampling[0] = 1.0f;

  convert->priv->convert_info.chroma_sampling[1] = 1.0f;

  if (convert->priv->convert_info.frag_prog) {

    g_free (convert->priv->convert_info.frag_prog);

    convert->priv->convert_info.frag_prog = NULL;

  }

  if (convert->priv->convert_info.frag_body) {

    g_free (convert->priv->convert_info.frag_body);

    convert->priv->convert_info.frag_body = NULL;

  }

  if (convert->shader) {

    gst_object_unref (convert->shader);

    convert->shader = NULL;

  }

  convert->initted = FALSE;

}

static void

gst_gl_color_convert_reset (GstGLColorConvert * convert)

{

  guint i;

  if (convert->fbo) {

    gst_object_unref (convert->fbo);

    convert->fbo = NULL;

  }

  for (i = 0; i < convert->priv->convert_info.out_n_textures; i++) {

    if (convert->priv->out_tex[i])

      gst_memory_unref ((GstMemory *) convert->priv->out_tex[i]);

    convert->priv->out_tex[i] = NULL;

  }

  if (convert->priv->pool) {

    convert->priv->pool_started = FALSE;

    gst_object_unref (convert->priv->pool);

    convert->priv->pool = NULL;

  }

  gst_caps_replace (&convert->priv->in_caps, NULL);

  gst_caps_replace (&convert->priv->out_caps, NULL);

  if (convert->context) {

    gst_gl_context_thread_add (convert->context,

        (GstGLContextThreadFunc) _reset_gl, convert);

  }

  gst_gl_color_convert_reset_shader (convert);

}

static gboolean

_gst_gl_color_convert_can_passthrough_info (GstVideoInfo * in,

    GstVideoInfo * out)

{

  gint i;

  if (GST_VIDEO_INFO_FORMAT (in) != GST_VIDEO_INFO_FORMAT (out))

    return FALSE;

  if (GST_VIDEO_INFO_WIDTH (in) != GST_VIDEO_INFO_WIDTH (out))

    return FALSE;

  if (GST_VIDEO_INFO_HEIGHT (in) != GST_VIDEO_INFO_HEIGHT (out))

    return FALSE;

  if (GST_VIDEO_INFO_SIZE (in) != GST_VIDEO_INFO_SIZE (out))

    return FALSE;

  for (i = 0; i < in->finfo->n_planes; i++) {

    if (in->stride[i] != out->stride[i])

      return FALSE;

    if (in->offset[i] != out->offset[i])

      return FALSE;

  }

  if (!gst_video_colorimetry_is_equal (&in->colorimetry, &out->colorimetry))

    return FALSE;

  if (in->chroma_site != out->chroma_site)

    return FALSE;

  return TRUE;

}

static gboolean

_gst_gl_color_convert_set_caps_unlocked (GstGLColorConvert * convert,

    GstCaps * in_caps, GstCaps * out_caps)

{

  GstVideoInfo in_info, out_info;

  GstCapsFeatures *in_features, *out_features;

  GstGLTextureTarget from_target, to_target;

  gboolean passthrough;

  g_return_val_if_fail (convert != NULL, FALSE);

  g_return_val_if_fail (in_caps, FALSE);

  g_return_val_if_fail (out_caps, FALSE);

  GST_LOG_OBJECT (convert, "Setting caps in %" GST_PTR_FORMAT

      " out %" GST_PTR_FORMAT, in_caps, out_caps);

  if (!gst_video_info_from_caps (&in_info, in_caps))

    g_assert_not_reached ();

  if (!gst_video_info_from_caps (&out_info, out_caps))

    g_assert_not_reached ();

  g_return_val_if_fail (GST_VIDEO_INFO_FORMAT (&in_info) !=

      GST_VIDEO_FORMAT_UNKNOWN, FALSE);

  g_return_val_if_fail (GST_VIDEO_INFO_FORMAT (&in_info) !=

      GST_VIDEO_FORMAT_ENCODED, FALSE);

  g_return_val_if_fail (GST_VIDEO_INFO_FORMAT (&out_info) !=

      GST_VIDEO_FORMAT_UNKNOWN, FALSE);

  g_return_val_if_fail (GST_VIDEO_INFO_FORMAT (&out_info) !=

      GST_VIDEO_FORMAT_ENCODED, FALSE);

  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)

      || !gst_caps_features_contains (out_features,

          GST_CAPS_FEATURE_MEMORY_GL_MEMORY)) {

    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"));

    else

      from_target = GST_GL_TEXTURE_TARGET_2D;

    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"));

    else

      to_target = GST_GL_TEXTURE_TARGET_2D;

    if (to_target == GST_GL_TEXTURE_TARGET_NONE

        || from_target == GST_GL_TEXTURE_TARGET_NONE)

      /* invalid caps */

      return FALSE;

  }

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

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

      convert->priv->from_texture_target == from_target &&

      convert->priv->to_texture_target == to_target)

    return TRUE;

  /* If input and output are identical, pass through directly */

  passthrough =

      _gst_gl_color_convert_can_passthrough_info (&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;

  {

    guint yuv_gray_flags, in_flags, out_flags;

    in_flags = GST_VIDEO_FORMAT_INFO_FLAGS (in_info.finfo);

    out_flags = GST_VIDEO_FORMAT_INFO_FLAGS (out_info.finfo);

    yuv_gray_flags = GST_VIDEO_FORMAT_FLAG_YUV | GST_VIDEO_FORMAT_FLAG_GRAY;

    /* GRAY/YUV -> GRAY/YUV is not supported for non-passthrough */

    if (!passthrough && (in_flags & yuv_gray_flags) != 0

        && (out_flags & yuv_gray_flags) != 0)

      return FALSE;

  }

  gst_gl_color_convert_reset (convert);

  convert->in_info = in_info;

  convert->out_info = out_info;

  gst_caps_replace (&convert->priv->in_caps, in_caps);

  gst_caps_replace (&convert->priv->out_caps, out_caps);

  convert->priv->from_texture_target = from_target;

  convert->priv->to_texture_target = to_target;

  convert->initted = FALSE;

  convert->passthrough = passthrough;

#ifndef GST_DISABLE_GST_DEBUG

  if (G_UNLIKELY (convert->passthrough))

    GST_DEBUG_OBJECT (convert,

        "Configuring passthrough mode for same in/out caps");

  else {

    GST_DEBUG_OBJECT (convert, "Color converting %" GST_PTR_FORMAT

        " to %" GST_PTR_FORMAT, in_caps, out_caps);

  }

#endif

  return TRUE;

}

/**

 * gst_gl_color_convert_set_caps:

 * @convert: a #GstGLColorConvert

 * @in_caps: input #GstCaps

 * @out_caps: output #GstCaps

 *

 * Initializes @convert with the information required for conversion.

 *

 * Since: 1.6

 */

gboolean

gst_gl_color_convert_set_caps (GstGLColorConvert * convert,

    GstCaps * in_caps, GstCaps * out_caps)

{

  gboolean ret;

  GST_OBJECT_LOCK (convert);

  ret = _gst_gl_color_convert_set_caps_unlocked (convert, in_caps, out_caps);

  GST_OBJECT_UNLOCK (convert);

  return ret;

}

/**

 * gst_gl_color_convert_decide_allocation:

 * @convert: a #GstGLColorConvert

 * @query: a completed ALLOCATION #GstQuery

 *

 * Provides an implementation of #GstBaseTransfromClass::decide_allocation()

 *

 * Returns: whether the allocation parameters were successfully chosen

 *

 * Since: 1.8

 */

gboolean

gst_gl_color_convert_decide_allocation (GstGLColorConvert * convert,

    GstQuery * query)

{

  GstBufferPool *pool = NULL;

  GstStructure *config;

  GstCaps *caps;

  guint min, max, size, n, i;

  gboolean update_pool;

  GstGLVideoAllocationParams *params;

  GstVideoInfo vinfo;

  gst_query_parse_allocation (query, &caps, NULL);

  if (!caps)

    return FALSE;

  gst_video_info_from_caps (&vinfo, caps);

  n = gst_query_get_n_allocation_pools (query);

  if (n > 0) {

    update_pool = TRUE;

    for (i = 0; i < n; i++) {

      gst_query_parse_nth_allocation_pool (query, i, &pool, &size, &min, &max;;

      if (!pool || !GST_IS_GL_BUFFER_POOL (pool)) {

        if (pool)

          gst_object_unref (pool);

        pool = NULL;

      }

    }

  }

  if (!pool) {

    GstVideoInfo vinfo;

    gst_video_info_init (&vinfo);

    size = vinfo.size;

    min = max = 0;

    update_pool = FALSE;

  }

  if (!pool)

    pool = gst_gl_buffer_pool_new (convert->context);

  config = gst_buffer_pool_get_config (pool);

  gst_buffer_pool_config_set_params (config, caps, size, min, max);

  gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);

  if (gst_query_find_allocation_meta (query, GST_GL_SYNC_META_API_TYPE, NULL))

    gst_buffer_pool_config_add_option (config,

        GST_BUFFER_POOL_OPTION_GL_SYNC_META);

  params = gst_gl_video_allocation_params_new (convert->context, NULL, &vinfo,

      0, NULL, convert->priv->to_texture_target, 0);

  gst_buffer_pool_config_set_gl_allocation_params (config,

      (GstGLAllocationParams *) params);

  gst_gl_allocation_params_free ((GstGLAllocationParams *) params);

  if (!gst_buffer_pool_set_config (pool, config))

    GST_WARNING_OBJECT (convert, "Failed to set buffer pool config");

  if (update_pool)

    gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);

  else

    gst_query_add_allocation_pool (query, pool, size, min, max);

  if (convert->priv->pool) {

    gst_object_unref (convert->priv->pool);

    convert->priv->pool_started = FALSE;

  }

  convert->priv->pool = pool;

  return TRUE;

}

static void

_init_value_string_list (GValue * list, ...)

{

  GValue item = G_VALUE_INIT;

  gchar *str;

  va_list args;

  g_value_init (list, GST_TYPE_LIST);

  va_start (args, list);

  while ((str = va_arg (args, gchar *))) {

    g_value_init (&item, G_TYPE_STRING);

    g_value_set_string (&item, str);

    gst_value_list_append_value (list, &item);