/* * GStreamer * Copyright (C) 2012-2014 Matthew Waters * * 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 #include "gl.h" #include "gstglcolorconvert.h" /** * SECTION:gstglcolorconvert * @short_description: an object that converts between color spaces/formats * @see_also: #GstGLUpload, #GstGLDownload, #GstGLMemory * * #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(). * * For handling stride scaling in the shader, see * gst_gl_color_convert_set_texture_scaling(). */ #define USING_OPENGL(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_OPENGL) #define USING_OPENGL3(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_OPENGL3) #define USING_GLES(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES) #define USING_GLES2(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES2) #define USING_GLES3(context) (gst_gl_context_get_gl_api (context) & GST_GL_API_GLES3) static void _do_convert (GstGLContext * context, GstGLColorConvert * convert); static void _init_convert (GstGLContext * context, GstGLColorConvert * convert); static gboolean _init_convert_fbo (GstGLContext * context, GstGLColorConvert * convert); static gboolean _gst_gl_color_convert_perform_unlocked (GstGLColorConvert * convert, GstGLMemory * in_tex[GST_VIDEO_MAX_PLANES], GstGLMemory * out_tex[GST_VIDEO_MAX_PLANES]); 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.0625, -0.5, -0.5}; static const gfloat from_yuv_bt601_rcoeff[] = {1.164, 0.000, 1.596}; static const gfloat from_yuv_bt601_gcoeff[] = {1.164,-0.391,-0.813}; static const gfloat from_yuv_bt601_bcoeff[] = {1.164, 2.018, 0.000}; /* 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.0625, -0.5, -0.5}; static const gfloat from_yuv_bt709_rcoeff[] = {1.164, 0.000, 1.787}; static const gfloat from_yuv_bt709_gcoeff[] = {1.164,-0.213,-0.531}; static const gfloat from_yuv_bt709_bcoeff[] = {1.164,2.112, 0.000}; #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.0625, 0.5, 0.5}; static const gfloat from_rgb_bt601_ycoeff[] = {0.256816, 0.504154, 0.0979137}; static const gfloat from_rgb_bt601_ucoeff[] = {-0.148246, -0.29102, 0.439266}; static const gfloat from_rgb_bt601_vcoeff[] = {0.439271, -0.367833, -0.071438}; /* 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.0625, 0.5, 0.5}; static const gfloat from_rgb_bt709_ycoeff[] = { 0.182604, 0.614526, 0.061976 }; static const gfloat from_rgb_bt709_ucoeff[] = { -0.100640, -0.338688, 0.439327 }; static const gfloat from_rgb_bt709_vcoeff[] = { 0.440654, -0.400285, -0.040370 }; /** 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" /* Channel reordering for XYZ <-> ZYX conversion */ static const char *frag_REORDER = "#ifdef GL_ES\n" "precision mediump float;\n" "#endif\n" "varying vec2 v_texcoord;\n" "uniform sampler2D tex;\n" "uniform vec2 tex_scale0;\n" "uniform vec2 tex_scale1;\n" "uniform vec2 tex_scale2;\n" "void main(void)\n" "{\n" " vec4 t = texture2D(tex, v_texcoord * tex_scale0);\n" " gl_FragColor = vec4(t.%c, t.%c, t.%c, t.%c);\n" "}"; /** 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 char *frag_COMPOSE = "#ifdef GL_ES\n" "precision mediump float;\n" "#endif\n" "varying vec2 v_texcoord;\n" "uniform sampler2D tex;\n" "uniform vec2 tex_scale0;\n" "uniform vec2 tex_scale1;\n" "uniform vec2 tex_scale2;\n" COMPOSE_WEIGHT "void main(void)\n" "{\n" " float r, g, b, a;\n" " vec4 t = texture2D(tex, v_texcoord * tex_scale0);\n" " r = dot(t.%c%c, compose_weight);" " g = r;\n" " b = r;\n" " a = 1.0;\n" " gl_FragColor = vec4(%c, %c, %c, %c);\n" "}"; static const char *frag_AYUV_to_RGB = "#ifdef GL_ES\n" "precision mediump float;\n" "#endif\n" "varying vec2 v_texcoord;\n" "uniform sampler2D tex;\n" "uniform vec2 tex_scale0;\n" "uniform vec2 tex_scale1;\n" "uniform vec2 tex_scale2;\n" YUV_TO_RGB_COEFFICIENTS "void main(void) {\n" " float r,g,b,a;\n" " vec3 yuv;\n" " yuv = texture2D(tex,v_texcoord * tex_scale0).gba;\n" " yuv += offset;\n" " r = dot(yuv, coeff1);\n" " g = dot(yuv, coeff2);\n" " b = dot(yuv, coeff3);\n" " a = 1.0;\n" " gl_FragColor=vec4(%c,%c,%c,%c);\n" "}"; static const gchar *frag_RGB_to_AYUV = "#ifdef GL_ES\n" "precision mediump float;\n" "#endif\n" "varying vec2 v_texcoord;\n" "uniform sampler2D tex;\n" RGB_TO_YUV_COEFFICIENTS "void main(void) {\n" " vec4 texel;\n" " float y, u, v;\n" " texel = texture2D(tex, v_texcoord).%c%c%c%c;\n" " y = dot(texel.rgb, coeff1);\n" " u = dot(texel.rgb, coeff2);\n" " v = dot(texel.rgb, coeff3);\n" " y += offset.x;\n" " u += offset.y;\n" " v += offset.z;\n" " gl_FragColor = vec4(1.0,y,u,v);\n" "}\n"; /** YUV to RGB conversion */ static const char *frag_PLANAR_YUV_to_RGB = "#ifdef GL_ES\n" "precision mediump float;\n" "#endif\n" "varying vec2 v_texcoord;\n" "uniform sampler2D Ytex, Utex, Vtex;\n" "uniform vec2 tex_scale0;\n" "uniform vec2 tex_scale1;\n" "uniform vec2 tex_scale2;\n" YUV_TO_RGB_COEFFICIENTS "void main(void) {\n" " float r, g, b, a;\n" " vec3 yuv;\n" " yuv.x = texture2D(Ytex,v_texcoord * tex_scale0).r;\n" " yuv.y = texture2D(Utex,v_texcoord * tex_scale1).r;\n" " yuv.z = texture2D(Vtex,v_texcoord * tex_scale2).r;\n" " yuv += offset;\n" " r = dot(yuv, coeff1);\n" " g = dot(yuv, coeff2);\n" " b = dot(yuv, coeff3);\n" " a = 1.0;\n" " gl_FragColor = vec4(%c, %c, %c, %c);\n" "}\n"; static const gchar *frag_RGB_to_PLANAR_YUV = "#ifdef GL_ES\n" "precision mediump float;\n" "#endif\n" "varying vec2 v_texcoord;\n" "uniform sampler2D tex;\n" "uniform float w, h;\n" RGB_TO_YUV_COEFFICIENTS "void main(void) {\n" " float y, u, v;\n" " vec4 texel = texture2D(tex, v_texcoord).%c%c%c%c;\n" " vec4 texel2 = texture2D(tex, v_texcoord * 2.0).%c%c%c%c;\n" " y = dot(texel.rgb, coeff1);\n" " u = dot(texel2.rgb, coeff2);\n" " v = dot(texel2.rgb, coeff3);\n" " y += offset.x;\n" " u += offset.y;\n" " v += offset.z;\n" " gl_FragData[0] = vec4(y, 0.0, 0.0, 1.0);\n" " gl_FragData[1] = vec4(u, 0.0, 0.0, 1.0);\n" " gl_FragData[2] = vec4(v, 0.0, 0.0, 1.0);\n" "}\n"; /** NV12/NV21 to RGB conversion */ static const char *frag_NV12_NV21_to_RGB = { "#ifdef GL_ES\n" "precision mediump float;\n" "#endif\n" "varying vec2 v_texcoord;\n" "uniform sampler2D Ytex,UVtex;\n" "uniform vec2 tex_scale0;\n" "uniform vec2 tex_scale1;\n" "uniform vec2 tex_scale2;\n" YUV_TO_RGB_COEFFICIENTS "void main(void) {\n" " float r, g, b, a;\n" " vec3 yuv;\n" " yuv.x=texture2D(Ytex, v_texcoord * tex_scale0).r;\n" " yuv.yz=texture2D(UVtex, v_texcoord * tex_scale1).%c%c;\n" " yuv += offset;\n" " r = dot(yuv, coeff1);\n" " g = dot(yuv, coeff2);\n" " b = dot(yuv, coeff3);\n" " a = 1.0;\n" " gl_FragColor=vec4(%c, %c, %c, %c);\n" "}" }; /* YUY2:r,g,a UYVY:a,b,r */ static const gchar *frag_YUY2_UYVY_to_RGB = "#ifdef GL_ES\n" "precision mediump float;\n" "#endif\n" "varying vec2 v_texcoord;\n" "uniform sampler2D Ytex, UVtex;\n" "uniform vec2 tex_scale0;\n" "uniform vec2 tex_scale1;\n" "uniform vec2 tex_scale2;\n" YUV_TO_RGB_COEFFICIENTS "void main(void) {\n" " vec3 yuv;\n" " float r, g, b, a;\n" " yuv.x = texture2D(Ytex, v_texcoord * tex_scale0).%c;\n" " yuv.yz = texture2D(UVtex, v_texcoord * tex_scale1).%c%c;\n" " yuv += offset;\n" " r = dot(yuv, coeff1);\n" " g = dot(yuv, coeff2);\n" " b = dot(yuv, coeff3);\n" " a = 1.0;\n" " gl_FragColor = vec4(%c, %c, %c, %c);\n" "}\n"; static const gchar *frag_RGB_to_YUY2_UYVY = "#ifdef GL_ES\n" "precision mediump float;\n" "#endif\n" "varying vec2 v_texcoord;\n" "uniform sampler2D tex;\n" "uniform float width;\n" RGB_TO_YUV_COEFFICIENTS "void main(void) {\n" " vec4 texel1, texel2;\n" " float fx, fy, y1, y2, u, v;\n" " fx = v_texcoord.x;\n" " fy = v_texcoord.y;\n" " texel1 = texture2D(tex, vec2(fx*2.0, fy)).%c%c%c%c;\n" " texel2 = texture2D(tex, vec2(fx*2.0+1.0 / width, fy)).%c%c%c%c;\n" " y1 = dot(texel1.rgb, coeff1);\n" " y2 = dot(texel2.rgb, coeff1);\n" " u = dot(texel1.rgb, coeff2);\n" " v = dot(texel1.rgb, coeff3);\n" " y1 += offset.x;\n" " y2 += offset.x;\n" " u += offset.y;\n" " v += offset.z;\n" " gl_FragColor = vec4(%s);\n" "}\n"; 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"; /* *INDENT-ON* */ struct ConvertInfo { gint in_n_textures; gint out_n_textures; gchar *frag_prog; const gchar *shader_tex_names[GST_VIDEO_MAX_PLANES]; gfloat shader_scaling[GST_VIDEO_MAX_PLANES][2]; gfloat *cms_offset; gfloat *cms_coeff1; /* r,y */ gfloat *cms_coeff2; /* g,u */ gfloat *cms_coeff3; /* b,v */ }; struct _GstGLColorConvertPrivate { int n_textures; gboolean result; gboolean (*draw) (GstGLContext * context, GstGLColorConvert * download); struct ConvertInfo convert_info; GstGLMemory *scratch; GstGLMemory *out_temp[GST_VIDEO_MAX_PLANES]; }; 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, G_TYPE_OBJECT, DEBUG_INIT); static void gst_gl_color_convert_finalize (GObject * object); #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); g_mutex_init (&convert->lock); } /** * gst_gl_color_convert_new: * @context: a #GstGLContext * * Returns: a new #GstGLColorConvert object */ GstGLColorConvert * gst_gl_color_convert_new (GstGLContext * context) { GstGLColorConvert *convert; GstGLColorConvertPrivate *priv; convert = g_object_new (GST_TYPE_GL_COLOR_CONVERT, NULL); convert->context = gst_object_ref (context); priv = convert->priv; priv->draw = _do_convert_draw; return convert; } static void gst_gl_color_convert_finalize (GObject * object) { GstGLColorConvert *convert; guint i; convert = GST_GL_COLOR_CONVERT (object); if (convert->fbo || convert->depth_buffer) { gst_gl_context_del_fbo (convert->context, convert->fbo, convert->depth_buffer); convert->fbo = 0; convert->depth_buffer = 0; } for (i = 0; i < convert->priv->convert_info.out_n_textures; i++) { if (convert->priv->out_temp[i]) gst_memory_unref ((GstMemory *) convert->priv->out_temp[i]); convert->priv->out_temp[i] = NULL; } if (convert->shader) { gst_object_unref (convert->shader); convert->shader = NULL; } if (convert->priv->scratch) { gst_memory_unref ((GstMemory *) convert->priv->scratch); convert->priv->scratch = NULL; } if (convert->context) { gst_object_unref (convert->context); convert->context = NULL; } g_mutex_clear (&convert->lock); G_OBJECT_CLASS (gst_gl_color_convert_parent_class)->finalize (object); } static gboolean _gst_gl_color_convert_init_format_unlocked (GstGLColorConvert * convert, GstVideoInfo * in_info, GstVideoInfo * out_info) { g_return_val_if_fail (convert != NULL, FALSE); g_return_val_if_fail (in_info, FALSE); g_return_val_if_fail (out_info, FALSE); 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); if (convert->initted) { return TRUE; } else { convert->initted = TRUE; } convert->in_info = *in_info; convert->out_info = *out_info; gst_gl_context_thread_add (convert->context, (GstGLContextThreadFunc) _init_convert, convert); return convert->priv->result; } /** * gst_gl_color_convert_init_format: * @convert: a #GstGLColorConvert * @in_info: input #GstVideoInfo * @out_info: output #GstVideoInfo * * Initializes @convert with the information required for conversion. * * Returns: whether the initialization was successful */ gboolean gst_gl_color_convert_init_format (GstGLColorConvert * convert, GstVideoInfo * in_info, GstVideoInfo * out_info) { gboolean ret; g_mutex_lock (&convert->lock); ret = _gst_gl_color_convert_init_format_unlocked (convert, in_info, out_info); g_mutex_unlock (&convert->lock); return ret; } /** * gst_gl_color_convert_perform: * @convert: a #GstGLColorConvert * @in_tex: the texture ids for input formatted according to in_info * @out_tex: the texture ids for output formatted according to out_info * * Converts the data contained in in_tex into out_tex using the formats * specified by the #GstVideoInfos passed to * gst_gl_color_convert_init_format() * * Returns: whether the conversion was successful */ gboolean gst_gl_color_convert_perform (GstGLColorConvert * convert, GstGLMemory * in_tex[GST_VIDEO_MAX_PLANES], GstGLMemory * out_tex[GST_VIDEO_MAX_PLANES]) { gboolean ret; g_return_val_if_fail (convert != NULL, FALSE); g_mutex_lock (&convert->lock); ret = _gst_gl_color_convert_perform_unlocked (convert, in_tex, out_tex); g_mutex_unlock (&convert->lock); return ret; } /** * gst_gl_color_convert_set_texture_scaling: * @convert: a #GstGLColorConvert * @scaling: array of texture scaling coefficients stored in width, height * order per texture being converted. * * Scales the input textures by the given amount. Useful for performing stride * scaling in a shader on OpenGL platforms that do not support * GL_PIXEL_[UN]PACK_LENGTH such as GL|ES 2.0. */ void gst_gl_color_convert_set_texture_scaling (GstGLColorConvert * convert, gfloat scaling[GST_VIDEO_MAX_PLANES][2]) { guint i; g_return_if_fail (convert != NULL); for (i = 0; i < GST_VIDEO_MAX_PLANES; i++) { convert->priv->convert_info.shader_scaling[i][0] = scaling[i][0]; convert->priv->convert_info.shader_scaling[i][1] = scaling[i][1]; } } static gboolean _gst_gl_color_convert_perform_unlocked (GstGLColorConvert * convert, GstGLMemory * in_tex[GST_VIDEO_MAX_PLANES], GstGLMemory * out_tex[GST_VIDEO_MAX_PLANES]) { g_return_val_if_fail (convert != NULL, FALSE); g_return_val_if_fail (in_tex, FALSE); g_return_val_if_fail (out_tex, FALSE); convert->in_tex[0] = in_tex[0]; convert->in_tex[1] = in_tex[1]; convert->in_tex[2] = in_tex[2]; convert->in_tex[3] = in_tex[3]; convert->out_tex[0] = out_tex[0]; convert->out_tex[1] = out_tex[1]; convert->out_tex[2] = out_tex[2]; convert->out_tex[3] = out_tex[3]; GST_LOG ("Converting %s from %p,%p,%p,%p into %s using %p,%p,%p,%p", gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (&convert->in_info)), in_tex[0], in_tex[1], in_tex[2], in_tex[3], gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (&convert->out_info)), out_tex[0], out_tex[1], out_tex[2], out_tex[3]); gst_gl_context_thread_add (convert->context, (GstGLContextThreadFunc) _do_convert, convert); return TRUE; } static gboolean _create_shader (GstGLContext * context, const gchar * vertex_src, const gchar * fragment_src, GstGLShader ** out_shader) { GstGLShader *shader; GError *error = NULL; g_return_val_if_fail (vertex_src != NULL || fragment_src != NULL, FALSE); shader = gst_gl_shader_new (context); if (vertex_src) gst_gl_shader_set_vertex_source (shader, vertex_src); if (fragment_src) gst_gl_shader_set_fragment_source (shader, fragment_src); if (!gst_gl_shader_compile (shader, &error)) { gst_gl_context_set_error (context, "%s", error->message); g_error_free (error); gst_gl_context_clear_shader (context); gst_object_unref (shader); return FALSE; } *out_shader = shader; return TRUE; } static inline gchar _index_to_shader_swizzle (int idx) { switch (idx) { case 0: return 'r'; case 1: return 'g'; case 2: return 'b'; case 3: return 'a'; default: return '#'; } } /* attempts to transform expected to want using swizzling */ static gchar * _RGB_pixel_order (const gchar * expected, const gchar * wanted) { GString *ret = g_string_sized_new (4); gchar *expect, *want; int len; if (g_ascii_strcasecmp (expected, wanted) == 0) return g_ascii_strdown (expected, -1); expect = g_ascii_strdown (expected, -1); want = g_ascii_strdown (wanted, -1); /* pad want with 'a's */ if ((len = strlen (want)) < 4) { gchar *new_want = g_strndup (want, 4); while (len < 4) { new_want[len] = 'a'; len++; } g_free (want); want = new_want; } /* pad expect with 'a's */ if ((len = strlen (expect)) < 4) { gchar *new_expect = g_strndup (expect, 4); while (len < 4) { new_expect[len] = 'a'; len++; } g_free (expect); expect = new_expect; } /* build the swizzle format */ while (want && want[0] != '\0') { gchar *val; gint idx; gchar needle = want[0]; if (needle == 'x') needle = 'a'; if (!(val = strchr (expect, needle)) && needle == 'a' && !(val = strchr (expect, 'x'))) goto fail; idx = (gint) (val - expect); ret = g_string_append_c (ret, _index_to_shader_swizzle (idx)); want = &want[1]; } return g_string_free (ret, FALSE); fail: g_string_free (ret, TRUE); return NULL; } static void _RGB_to_RGB (GstGLContext * context, GstGLColorConvert * convert) { struct ConvertInfo *info = &convert->priv->convert_info; GstVideoFormat in_format = GST_VIDEO_INFO_FORMAT (&convert->in_info); const gchar *in_format_str = gst_video_format_to_string (in_format); GstVideoFormat out_format = GST_VIDEO_INFO_FORMAT (&convert->out_info); const gchar *out_format_str = gst_video_format_to_string (out_format); gchar *pixel_order = _RGB_pixel_order (in_format_str, out_format_str); info->in_n_textures = 1; info->out_n_textures = 1; info->frag_prog = g_strdup_printf (frag_REORDER, pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); info->shader_tex_names[0] = "tex"; info->shader_scaling[0][0] = 1.0f; info->shader_scaling[0][1] = 1.0f; } static void _YUV_to_RGB (GstGLContext * context, GstGLColorConvert * convert) { struct ConvertInfo *info = &convert->priv->convert_info; GstVideoFormat out_format = GST_VIDEO_INFO_FORMAT (&convert->out_info); const gchar *out_format_str = gst_video_format_to_string (out_format); gchar *pixel_order = _RGB_pixel_order ("rgba", out_format_str); info->out_n_textures = 1; info->shader_scaling[0][0] = 1.0f; info->shader_scaling[0][1] = 1.0f; info->shader_scaling[1][0] = 1.0f; info->shader_scaling[1][1] = 1.0f; info->shader_scaling[2][0] = 1.0f; info->shader_scaling[2][1] = 1.0f; switch (GST_VIDEO_INFO_FORMAT (&convert->in_info)) { case GST_VIDEO_FORMAT_AYUV: info->frag_prog = g_strdup_printf (frag_AYUV_to_RGB, pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); info->in_n_textures = 1; info->shader_tex_names[0] = "tex"; break; case GST_VIDEO_FORMAT_I420: case GST_VIDEO_FORMAT_Y444: case GST_VIDEO_FORMAT_Y42B: case GST_VIDEO_FORMAT_Y41B: info->frag_prog = g_strdup_printf (frag_PLANAR_YUV_to_RGB, pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); info->in_n_textures = 3; info->shader_tex_names[0] = "Ytex"; info->shader_tex_names[1] = "Utex"; info->shader_tex_names[2] = "Vtex"; break; case GST_VIDEO_FORMAT_YV12: info->frag_prog = g_strdup_printf (frag_PLANAR_YUV_to_RGB, pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); info->in_n_textures = 3; info->shader_tex_names[0] = "Ytex"; info->shader_tex_names[1] = "Vtex"; info->shader_tex_names[2] = "Utex"; break; case GST_VIDEO_FORMAT_YUY2: info->frag_prog = g_strdup_printf (frag_YUY2_UYVY_to_RGB, 'r', 'g', 'a', pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); info->in_n_textures = 1; info->shader_tex_names[1] = "Ytex"; info->shader_tex_names[0] = "UVtex"; convert->priv->scratch = (GstGLMemory *) gst_gl_memory_alloc (context, GST_VIDEO_GL_TEXTURE_TYPE_LUMINANCE_ALPHA, GST_VIDEO_INFO_WIDTH (&convert->in_info), GST_VIDEO_INFO_HEIGHT (&convert->in_info), GST_VIDEO_INFO_WIDTH (&convert->in_info)); break; case GST_VIDEO_FORMAT_NV12: info->frag_prog = g_strdup_printf (frag_NV12_NV21_to_RGB, 'r', 'a', pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); info->in_n_textures = 2; info->shader_tex_names[0] = "Ytex"; info->shader_tex_names[1] = "UVtex"; break; case GST_VIDEO_FORMAT_NV21: info->frag_prog = g_strdup_printf (frag_NV12_NV21_to_RGB, 'a', 'r', pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); info->in_n_textures = 2; info->shader_tex_names[0] = "Ytex"; info->shader_tex_names[1] = "UVtex"; break; case GST_VIDEO_FORMAT_UYVY: info->frag_prog = g_strdup_printf (frag_YUY2_UYVY_to_RGB, 'a', 'r', 'b', pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); info->in_n_textures = 1; info->shader_tex_names[1] = "Ytex"; info->shader_tex_names[0] = "UVtex"; convert->priv->scratch = (GstGLMemory *) gst_gl_memory_alloc (context, GST_VIDEO_GL_TEXTURE_TYPE_LUMINANCE_ALPHA, GST_VIDEO_INFO_WIDTH (&convert->in_info), GST_VIDEO_INFO_HEIGHT (&convert->in_info), GST_VIDEO_INFO_WIDTH (&convert->in_info)); break; default: break; } if (gst_video_colorimetry_matches (&convert->in_info.colorimetry, GST_VIDEO_COLORIMETRY_BT709)) { info->cms_offset = (gfloat *) from_yuv_bt709_offset; info->cms_coeff1 = (gfloat *) from_yuv_bt709_rcoeff; info->cms_coeff2 = (gfloat *) from_yuv_bt709_gcoeff; info->cms_coeff3 = (gfloat *) from_yuv_bt709_bcoeff; } else { /* defaults/bt601 */ info->cms_offset = (gfloat *) from_yuv_bt601_offset; info->cms_coeff1 = (gfloat *) from_yuv_bt601_rcoeff; info->cms_coeff2 = (gfloat *) from_yuv_bt601_gcoeff; info->cms_coeff3 = (gfloat *) from_yuv_bt601_bcoeff; } g_free (pixel_order); } static void _RGB_to_YUV (GstGLContext * context, GstGLColorConvert * convert) { struct ConvertInfo *info = &convert->priv->convert_info; GstVideoFormat in_format = GST_VIDEO_INFO_FORMAT (&convert->in_info); const gchar *in_format_str = gst_video_format_to_string (in_format); gchar *pixel_order = _RGB_pixel_order (in_format_str, "rgba"); info->frag_prog = NULL; info->in_n_textures = 1; info->shader_tex_names[0] = "tex"; info->shader_scaling[0][0] = 1.0f; info->shader_scaling[0][1] = 1.0f; info->shader_scaling[1][0] = 1.0f; info->shader_scaling[1][1] = 1.0f; info->shader_scaling[2][0] = 1.0f; info->shader_scaling[2][1] = 1.0f; switch (GST_VIDEO_INFO_FORMAT (&convert->out_info)) { case GST_VIDEO_FORMAT_AYUV: info->frag_prog = g_strdup_printf (frag_RGB_to_AYUV, pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); info->out_n_textures = 1; break; case GST_VIDEO_FORMAT_I420: case GST_VIDEO_FORMAT_YV12: case GST_VIDEO_FORMAT_Y444: case GST_VIDEO_FORMAT_Y42B: case GST_VIDEO_FORMAT_Y41B: info->frag_prog = g_strdup_printf (frag_RGB_to_PLANAR_YUV, pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3], pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); info->out_n_textures = 3; break; case GST_VIDEO_FORMAT_YUY2: info->frag_prog = g_strdup_printf (frag_RGB_to_YUY2_UYVY, pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3], pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3], "y1,u,y2,v"); info->out_n_textures = 1; break; case GST_VIDEO_FORMAT_UYVY: info->frag_prog = g_strdup_printf (frag_RGB_to_YUY2_UYVY, pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3], pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3], "u,y1,v,y2"); info->out_n_textures = 1; break; default: break; } if (gst_video_colorimetry_matches (&convert->in_info.colorimetry, GST_VIDEO_COLORIMETRY_BT709)) { info->cms_offset = (gfloat *) from_rgb_bt709_offset; info->cms_coeff1 = (gfloat *) from_rgb_bt709_ycoeff; info->cms_coeff2 = (gfloat *) from_rgb_bt709_ucoeff; info->cms_coeff3 = (gfloat *) from_rgb_bt709_vcoeff; } else { /* defaults/bt601 */ info->cms_offset = (gfloat *) from_rgb_bt601_offset; info->cms_coeff1 = (gfloat *) from_rgb_bt601_ycoeff; info->cms_coeff2 = (gfloat *) from_rgb_bt601_ucoeff; info->cms_coeff3 = (gfloat *) from_rgb_bt601_vcoeff; } g_free (pixel_order); } static void _RGB_to_GRAY (GstGLContext * context, GstGLColorConvert * convert) { struct ConvertInfo *info = &convert->priv->convert_info; GstVideoFormat in_format = GST_VIDEO_INFO_FORMAT (&convert->in_info); const gchar *in_format_str = gst_video_format_to_string (in_format); gchar *pixel_order = _RGB_pixel_order (in_format_str, "rgba"); info->in_n_textures = 1; info->out_n_textures = 1; info->shader_tex_names[0] = "tex"; info->shader_scaling[0][0] = 1.0f; info->shader_scaling[0][1] = 1.0f; info->shader_scaling[1][0] = 1.0f; info->shader_scaling[1][1] = 1.0f; info->shader_scaling[2][0] = 1.0f; info->shader_scaling[2][1] = 1.0f; switch (GST_VIDEO_INFO_FORMAT (&convert->out_info)) { case GST_VIDEO_FORMAT_GRAY8: info->frag_prog = g_strdup_printf (frag_REORDER, pixel_order[0], pixel_order[0], pixel_order[0], pixel_order[3]); break; default: break; } } static void _GRAY_to_RGB (GstGLContext * context, GstGLColorConvert * convert) { struct ConvertInfo *info = &convert->priv->convert_info; GstVideoFormat out_format = GST_VIDEO_INFO_FORMAT (&convert->out_info); const gchar *out_format_str = gst_video_format_to_string (out_format); gchar *pixel_order = _RGB_pixel_order ("rgba", out_format_str); info->in_n_textures = 1; info->out_n_textures = 1; info->shader_tex_names[0] = "tex"; info->shader_scaling[0][0] = 1.0f; info->shader_scaling[0][1] = 1.0f; info->shader_scaling[1][0] = 1.0f; info->shader_scaling[1][1] = 1.0f; info->shader_scaling[2][0] = 1.0f; info->shader_scaling[2][1] = 1.0f; switch (GST_VIDEO_INFO_FORMAT (&convert->in_info)) { case GST_VIDEO_FORMAT_GRAY8: info->frag_prog = g_strdup_printf (frag_REORDER, pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); break; case GST_VIDEO_FORMAT_GRAY16_LE: info->frag_prog = g_strdup_printf (frag_COMPOSE, 'a', 'r', pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); break; case GST_VIDEO_FORMAT_GRAY16_BE: info->frag_prog = g_strdup_printf (frag_COMPOSE, 'r', 'a', pixel_order[0], pixel_order[1], pixel_order[2], pixel_order[3]); break; default: break; } } /* Called in the gl thread */ void _init_convert (GstGLContext * context, GstGLColorConvert * convert) { GstGLFuncs *gl; gboolean res; struct ConvertInfo *info = &convert->priv->convert_info; gint i; gl = context->gl_vtable; GST_INFO ("Initializing color conversion from %s to %s", gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (&convert->in_info)), gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (&convert->out_info))); if (!gl->CreateProgramObject && !gl->CreateProgram) { gst_gl_context_set_error (context, "Cannot perform color conversion without OpenGL shaders"); goto error; } if (GST_VIDEO_INFO_IS_RGB (&convert->in_info)) { if (GST_VIDEO_INFO_IS_RGB (&convert->out_info)) { _RGB_to_RGB (context, convert); } } if (GST_VIDEO_INFO_IS_YUV (&convert->in_info)) { if (GST_VIDEO_INFO_IS_RGB (&convert->out_info)) { _YUV_to_RGB (context, convert); } } if (GST_VIDEO_INFO_IS_RGB (&convert->in_info)) { if (GST_VIDEO_INFO_IS_YUV (&convert->out_info)) { _RGB_to_YUV (context, convert); } } if (GST_VIDEO_INFO_IS_RGB (&convert->in_info)) { if (GST_VIDEO_INFO_IS_GRAY (&convert->out_info)) { _RGB_to_GRAY (context, convert); } } if (GST_VIDEO_INFO_IS_GRAY (&convert->in_info)) { if (GST_VIDEO_INFO_IS_RGB (&convert->out_info)) { _GRAY_to_RGB (context, convert); } } if (!info->frag_prog || info->in_n_textures == 0 || info->out_n_textures == 0) goto unhandled_format; /* multiple draw targets not supported on GLES2...yet */ if (info->out_n_textures > 1 && (!gl->DrawBuffers || USING_GLES2 (context))) { g_free (info->frag_prog); GST_ERROR ("Conversion requires output to multiple draw buffers"); goto incompatible_api; } res = _create_shader (context, text_vertex_shader, info->frag_prog, &convert->shader); g_free (info->frag_prog); if (!res) goto error; convert->shader_attr_position_loc = gst_gl_shader_get_attribute_location (convert->shader, "a_position"); convert->shader_attr_texture_loc = gst_gl_shader_get_attribute_location (convert->shader, "a_texcoord"); gst_gl_shader_use (convert->shader); if (info->cms_offset && info->cms_coeff1 && info->cms_coeff2 && info->cms_coeff3) { gst_gl_shader_set_uniform_3fv (convert->shader, "offset", 1, info->cms_offset); gst_gl_shader_set_uniform_3fv (convert->shader, "coeff1", 1, info->cms_coeff1); gst_gl_shader_set_uniform_3fv (convert->shader, "coeff2", 1, info->cms_coeff2); gst_gl_shader_set_uniform_3fv (convert->shader, "coeff3", 1, info->cms_coeff3); } for (i = info->in_n_textures; i >= 0; i--) { gchar *scale_name = g_strdup_printf ("tex_scale%u", i); if (info->shader_tex_names[i]) gst_gl_shader_set_uniform_1i (convert->shader, info->shader_tex_names[i], i); gst_gl_shader_set_uniform_2fv (convert->shader, scale_name, 1, info->shader_scaling[i]); g_free (scale_name); } gst_gl_shader_set_uniform_1f (convert->shader, "width", GST_VIDEO_INFO_WIDTH (&convert->in_info)); gst_gl_context_clear_shader (context); if (!_init_convert_fbo (context, convert)) { goto error; } gl->BindTexture (GL_TEXTURE_2D, 0); convert->priv->result = TRUE; return; unhandled_format: gst_gl_context_set_error (context, "Don't know how to convert from %s to %s", gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (&convert->in_info)), gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (&convert->out_info))); error: convert->priv->result = FALSE; return; incompatible_api: { gst_gl_context_set_error (context, "Converting from %s to %s requires " "functionality that the current OpenGL setup does not support", gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (&convert->in_info)), gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (&convert->out_info))); convert->priv->result = FALSE; return; } } /* called by _init_convert (in the gl thread) */ gboolean _init_convert_fbo (GstGLContext * context, GstGLColorConvert * convert) { GstGLFuncs *gl; guint out_width, out_height; GLuint fake_texture = 0; /* a FBO must hava texture to init */ gl = context->gl_vtable; out_width = GST_VIDEO_INFO_WIDTH (&convert->out_info); out_height = GST_VIDEO_INFO_HEIGHT (&convert->out_info); if (!gl->GenFramebuffers) { /* turn off the pipeline because Frame buffer object is a not present */ gst_gl_context_set_error (context, "Context, EXT_framebuffer_object supported: no"); return FALSE; } GST_INFO ("Context, EXT_framebuffer_object supported: yes"); /* setup FBO */ gl->GenFramebuffers (1, &convert->fbo); gl->BindFramebuffer (GL_FRAMEBUFFER, convert->fbo); /* setup the render buffer for depth */ gl->GenRenderbuffers (1, &convert->depth_buffer); gl->BindRenderbuffer (GL_RENDERBUFFER, convert->depth_buffer); if (USING_OPENGL (context)) { gl->RenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH_COMPONENT, out_width, out_height); gl->RenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, out_width, out_height); } if (USING_GLES2 (context)) { gl->RenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, out_width, out_height); } /* a fake texture is attached to the convert FBO (cannot init without it) */ gl->GenTextures (1, &fake_texture); gl->BindTexture (GL_TEXTURE_2D, fake_texture); gl->TexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, out_width, out_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); /* attach the texture to the FBO to renderer to */ gl->FramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fake_texture, 0); /* attach the depth render buffer to the FBO */ gl->FramebufferRenderbuffer (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, convert->depth_buffer); if (USING_OPENGL (context)) { gl->FramebufferRenderbuffer (GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, convert->depth_buffer); } if (!gst_gl_context_check_framebuffer_status (context)) { gst_gl_context_set_error (context, "GL framebuffer status incomplete"); return FALSE; } /* unbind the FBO */ gl->BindFramebuffer (GL_FRAMEBUFFER, 0); gl->DeleteTextures (1, &fake_texture); return TRUE; } /* Called by the idle function in the gl thread */ void _do_convert (GstGLContext * context, GstGLColorConvert * convert) { guint in_width, in_height, out_width, out_height; struct ConvertInfo *c_info = &convert->priv->convert_info; GstMapInfo in_infos[GST_VIDEO_MAX_PLANES], out_infos[GST_VIDEO_MAX_PLANES]; gboolean res = TRUE; gint i = 0; out_width = GST_VIDEO_INFO_WIDTH (&convert->out_info); out_height = GST_VIDEO_INFO_HEIGHT (&convert->out_info); in_width = GST_VIDEO_INFO_WIDTH (&convert->in_info); in_height = GST_VIDEO_INFO_HEIGHT (&convert->in_info); GST_TRACE ("converting to textures:%p,%p,%p,%p dimensions:%ux%u, " "from textures:%p,%p,%p,%p dimensions:%ux%u", convert->out_tex[0], convert->out_tex[1], convert->out_tex[2], convert->out_tex[3], out_width, out_height, convert->in_tex[0], convert->in_tex[1], convert->in_tex[2], convert->in_tex[3], in_width, in_height); for (i = 0; i < c_info->in_n_textures; i++) { gst_memory_map ((GstMemory *) convert->in_tex[i], &in_infos[i], GST_MAP_READ | GST_MAP_GL); } for (i = 0; i < c_info->out_n_textures; i++) { if (convert->out_tex[i]->tex_type == GST_VIDEO_GL_TEXTURE_TYPE_LUMINANCE || convert->out_tex[i]->tex_type == GST_VIDEO_GL_TEXTURE_TYPE_LUMINANCE_ALPHA || out_width != convert->out_tex[i]->width || out_height != convert->out_tex[i]->height) { /* Luminance formats are not color renderable */ /* renderering to a framebuffer only renders the intersection of all * the attachments i.e. the smallest attachment size */ if (!convert->priv->out_temp[i]) convert->priv->out_temp[i] = (GstGLMemory *) gst_gl_memory_alloc (context, GST_VIDEO_GL_TEXTURE_TYPE_RGBA, out_width, out_height, out_width); } else { convert->priv->out_temp[i] = convert->out_tex[i]; } gst_memory_map ((GstMemory *) convert->priv->out_temp[i], &out_infos[i], GST_MAP_WRITE | GST_MAP_GL); } if (!convert->priv->draw (context, convert)) res = FALSE; for (i = 0; i < c_info->in_n_textures; i++) { gst_memory_unmap ((GstMemory *) convert->in_tex[i], &in_infos[i]); } for (i = 0; i < c_info->out_n_textures; i++) { gst_memory_unmap ((GstMemory *) convert->priv->out_temp[i], &out_infos[i]); if (convert->out_tex[i]->tex_type == GST_VIDEO_GL_TEXTURE_TYPE_LUMINANCE || convert->out_tex[i]->tex_type == GST_VIDEO_GL_TEXTURE_TYPE_LUMINANCE_ALPHA || out_width != convert->out_tex[i]->width || out_height != convert->out_tex[i]->height) { GstGLMemory *gl_mem = convert->out_tex[i]; GstMapInfo from_info, to_info; gst_memory_map ((GstMemory *) convert->priv->out_temp[i], &from_info, GST_MAP_READ | GST_MAP_GL); gst_memory_map ((GstMemory *) gl_mem, &to_info, GST_MAP_WRITE | GST_MAP_GL); gst_gl_memory_copy_into_texture (convert->priv->out_temp[i], gl_mem->tex_id, gl_mem->tex_type, gl_mem->width, gl_mem->height, FALSE); gst_memory_unmap ((GstMemory *) gl_mem, &to_info); gst_memory_unmap ((GstMemory *) convert->priv->out_temp[i], &from_info); } else { convert->priv->out_temp[i] = NULL; } } convert->priv->result = res; return; } static gboolean _do_convert_draw (GstGLContext * context, GstGLColorConvert * convert) { GstGLFuncs *gl; struct ConvertInfo *c_info = &convert->priv->convert_info; guint out_width, out_height; gint i; GLint viewport_dim[4]; const GLfloat vVertices[] = { 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 }; GLushort indices[] = { 0, 1, 2, 0, 2, 3 }; GLenum multipleRT[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2 }; gl = context->gl_vtable; out_width = GST_VIDEO_INFO_WIDTH (&convert->out_info); out_height = GST_VIDEO_INFO_HEIGHT (&convert->out_info); /* two sources of the same data */ if (convert->priv->scratch) { gst_gl_memory_copy_into_texture (convert->in_tex[0], convert->priv->scratch->tex_id, convert->priv->scratch->tex_type, convert->priv->scratch->width, convert->priv->scratch->height, TRUE); } gl->BindFramebuffer (GL_FRAMEBUFFER, convert->fbo); /* attach the texture to the FBO to renderer to */ for (i = 0; i < c_info->out_n_textures; i++) { /* needed? */ gl->BindTexture (GL_TEXTURE_2D, convert->out_tex[i]->tex_id); gl->FramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, convert->priv->out_temp[i]->tex_id, 0); } if (gl->DrawBuffers) gl->DrawBuffers (c_info->out_n_textures, multipleRT); else if (gl->DrawBuffer) gl->DrawBuffer (GL_COLOR_ATTACHMENT0); gl->GetIntegerv (GL_VIEWPORT, viewport_dim); gl->Viewport (0, 0, out_width, out_height); gl->ClearColor (0.0, 0.0, 0.0, 0.0); gl->Clear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); gst_gl_shader_use (convert->shader); gl->VertexAttribPointer (convert->shader_attr_position_loc, 3, GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), vVertices); gl->VertexAttribPointer (convert->shader_attr_texture_loc, 2, GL_FLOAT, GL_FALSE, 5 * sizeof (GLfloat), &vVertices[3]); gl->EnableVertexAttribArray (convert->shader_attr_position_loc); gl->EnableVertexAttribArray (convert->shader_attr_texture_loc); if (convert->priv->scratch) { gl->ActiveTexture (GL_TEXTURE0 + c_info->in_n_textures); gl->BindTexture (GL_TEXTURE_2D, convert->priv->scratch->tex_id); } for (i = c_info->in_n_textures - 1; i >= 0; i--) { gl->ActiveTexture (GL_TEXTURE0 + i); gl->BindTexture (GL_TEXTURE_2D, convert->in_tex[i]->tex_id); gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); } gl->DrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices); gl->DisableVertexAttribArray (convert->shader_attr_position_loc); gl->DisableVertexAttribArray (convert->shader_attr_texture_loc); if (gl->DrawBuffer) gl->DrawBuffer (GL_NONE); /* we are done with the shader */ gst_gl_context_clear_shader (context); gl->Viewport (viewport_dim[0], viewport_dim[1], viewport_dim[2], viewport_dim[3]); gst_gl_context_check_framebuffer_status (context); gl->BindFramebuffer (GL_FRAMEBUFFER, 0); return TRUE; }