/* * GStreamer * Copyright (C) 2014 Lubosz Sarnecki <lubosz@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. */ /** * SECTION:element-gltransformation * * Transforms video on the GPU. * * <refsect2> * <title>Examples</title> * |[ * gst-launch-1.0 gltestsrc ! gltransformation rotation-z=45 ! glimagesink * ]| A pipeline to rotate by 45 degrees * |[ * gst-launch-1.0 gltestsrc ! gltransformation translation-x=0.5 ! glimagesink * ]| Translate the video by 0.5 * |[ * gst-launch-1.0 gltestsrc ! gltransformation scale-y=0.5 scale-x=0.5 ! glimagesink * ]| Resize the video by 0.5 * |[ * gst-launch-1.0 gltestsrc ! gltransformation rotation-x=-45 ortho=True ! glimagesink * ]| Rotate the video around the X-Axis by -45° with an orthographic projection * </refsect2> */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "gstgltransformation.h" #include <gst/gl/gstglapi.h> #include <graphene-gobject.h> #define GST_CAT_DEFAULT gst_gl_transformation_debug GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT); #define gst_gl_transformation_parent_class parent_class enum { PROP_0, PROP_FOV, PROP_ORTHO, PROP_TRANSLATION_X, PROP_TRANSLATION_Y, PROP_TRANSLATION_Z, PROP_ROTATION_X, PROP_ROTATION_Y, PROP_ROTATION_Z, PROP_SCALE_X, PROP_SCALE_Y, PROP_MVP, PROP_PIVOT_X, PROP_PIVOT_Y, PROP_PIVOT_Z, }; #define DEBUG_INIT \ GST_DEBUG_CATEGORY_INIT (gst_gl_transformation_debug, "gltransformation", 0, "gltransformation element"); G_DEFINE_TYPE_WITH_CODE (GstGLTransformation, gst_gl_transformation, GST_TYPE_GL_FILTER, DEBUG_INIT); static void gst_gl_transformation_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); static void gst_gl_transformation_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static gboolean gst_gl_transformation_set_caps (GstGLFilter * filter, GstCaps * incaps, GstCaps * outcaps); static void gst_gl_transformation_reset_gl (GstGLFilter * filter); static gboolean gst_gl_transformation_stop (GstBaseTransform * trans); static gboolean gst_gl_transformation_init_shader (GstGLFilter * filter); static void gst_gl_transformation_callback (gpointer stuff); static void gst_gl_transformation_build_mvp (GstGLTransformation * transformation); static gboolean gst_gl_transformation_filter_texture (GstGLFilter * filter, guint in_tex, guint out_tex); /* vertex source */ static const gchar *cube_v_src = "attribute vec4 position; \n" "attribute vec2 uv; \n" "uniform mat4 mvp; \n" "varying vec2 out_uv; \n" "void main() \n" "{ \n" " gl_Position = mvp * position; \n" " out_uv = uv; \n" "} \n"; /* fragment source */ static const gchar *cube_f_src = "#ifdef GL_ES \n" " precision mediump float; \n" "#endif \n" "varying vec2 out_uv; \n" "uniform sampler2D texture; \n" "void main() \n" "{ \n" " gl_FragColor = texture2D (texture, out_uv);\n" "} \n"; static void gst_gl_transformation_class_init (GstGLTransformationClass * klass) { GObjectClass *gobject_class; GstElementClass *element_class; gobject_class = (GObjectClass *) klass; element_class = GST_ELEMENT_CLASS (klass); gobject_class->set_property = gst_gl_transformation_set_property; gobject_class->get_property = gst_gl_transformation_get_property; GST_GL_FILTER_CLASS (klass)->init_fbo = gst_gl_transformation_init_shader; GST_GL_FILTER_CLASS (klass)->display_reset_cb = gst_gl_transformation_reset_gl; GST_GL_FILTER_CLASS (klass)->set_caps = gst_gl_transformation_set_caps; GST_GL_FILTER_CLASS (klass)->filter_texture = gst_gl_transformation_filter_texture; GST_BASE_TRANSFORM_CLASS (klass)->stop = gst_gl_transformation_stop; g_object_class_install_property (gobject_class, PROP_FOV, g_param_spec_float ("fov", "Fov", "Field of view angle in degrees", 0.0, G_MAXFLOAT, 90.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_ORTHO, g_param_spec_boolean ("ortho", "Orthographic", "Use orthographic projection", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /* Rotation */ g_object_class_install_property (gobject_class, PROP_ROTATION_X, g_param_spec_float ("rotation-x", "X Rotation", "Rotates the video around the X-Axis in degrees.", -G_MAXFLOAT, G_MAXFLOAT, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_ROTATION_Y, g_param_spec_float ("rotation-y", "Y Rotation", "Rotates the video around the Y-Axis in degrees.", -G_MAXFLOAT, G_MAXFLOAT, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_ROTATION_Z, g_param_spec_float ("rotation-z", "Z Rotation", "Rotates the video around the Z-Axis in degrees.", -G_MAXFLOAT, G_MAXFLOAT, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /* Translation */ g_object_class_install_property (gobject_class, PROP_TRANSLATION_X, g_param_spec_float ("translation-x", "X Translation", "Translates the video at the X-Axis, in universal [0-1] coordinate.", -G_MAXFLOAT, G_MAXFLOAT, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_TRANSLATION_Y, g_param_spec_float ("translation-y", "Y Translation", "Translates the video at the Y-Axis, in universal [0-1] coordinate.", -G_MAXFLOAT, G_MAXFLOAT, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_TRANSLATION_Z, g_param_spec_float ("translation-z", "Z Translation", "Translates the video at the Z-Axis, in universal [0-1] coordinate.", -G_MAXFLOAT, G_MAXFLOAT, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /* Scale */ g_object_class_install_property (gobject_class, PROP_SCALE_X, g_param_spec_float ("scale-x", "X Scale", "Scale multiplier for the X-Axis.", 0.0, G_MAXFLOAT, 1.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_SCALE_Y, g_param_spec_float ("scale-y", "Y Scale", "Scale multiplier for the Y-Axis.", 0.0, G_MAXFLOAT, 1.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /* Pivot */ g_object_class_install_property (gobject_class, PROP_PIVOT_X, g_param_spec_float ("pivot-x", "X Pivot", "Rotation pivot point X coordinate, where 0 is the center," " -1 the lef +1 the right boarder and <-1, >1 outside.", -G_MAXFLOAT, G_MAXFLOAT, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PIVOT_Y, g_param_spec_float ("pivot-y", "Y Pivot", "Rotation pivot point X coordinate, where 0 is the center," " -1 the lef +1 the right boarder and <-1, >1 outside.", -G_MAXFLOAT, G_MAXFLOAT, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PIVOT_Z, g_param_spec_float ("pivot-z", "Z Pivot", "Relevant for rotation in 3D space. You look into the negative Z axis direction", -G_MAXFLOAT, G_MAXFLOAT, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /* MVP */ g_object_class_install_property (gobject_class, PROP_MVP, g_param_spec_boxed ("mvp-matrix", "Modelview Projection Matrix", "The final Graphene 4x4 Matrix for transformation", GRAPHENE_TYPE_MATRIX, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); gst_element_class_set_metadata (element_class, "OpenGL transformation filter", "Filter/Effect/Video", "Transform video on the GPU", "Lubosz Sarnecki <lubosz@gmail.com>"); GST_GL_BASE_FILTER_CLASS (klass)->supported_gl_api = GST_GL_API_OPENGL | GST_GL_API_OPENGL3 | GST_GL_API_GLES2; } static void gst_gl_transformation_init (GstGLTransformation * filter) { filter->shader = NULL; filter->fov = 90; filter->aspect = 1.0; filter->znear = 0.1; filter->zfar = 100; filter->xscale = 1.0; filter->yscale = 1.0; filter->in_tex = 0; gst_gl_transformation_build_mvp (filter); } static void gst_gl_transformation_build_mvp (GstGLTransformation * transformation) { graphene_point3d_t translation_vector = GRAPHENE_POINT3D_INIT (transformation->xtranslation * 2.0 * transformation->aspect, transformation->ytranslation * 2.0, transformation->ztranslation * 2.0); graphene_point3d_t pivot_vector = GRAPHENE_POINT3D_INIT (-transformation->xpivot * transformation->aspect, transformation->ypivot, -transformation->zpivot); graphene_point3d_t negative_pivot_vector; graphene_matrix_t model_matrix; graphene_matrix_t projection_matrix; graphene_matrix_t view_matrix; graphene_matrix_t vp_matrix; graphene_vec3_t eye; graphene_vec3_t center; graphene_vec3_t up; graphene_vec3_init (&eye, 0.f, 0.f, 1.f); graphene_vec3_init (¢er, 0.f, 0.f, 0.f); graphene_vec3_init (&up, 0.f, 1.f, 0.f); /* Translate into pivot origin */ graphene_matrix_init_translate (&model_matrix, &pivot_vector); /* Scale */ graphene_matrix_scale (&model_matrix, transformation->xscale, transformation->yscale, 1.0f); /* Rotation */ graphene_matrix_rotate (&model_matrix, transformation->xrotation, graphene_vec3_x_axis ()); graphene_matrix_rotate (&model_matrix, transformation->yrotation, graphene_vec3_y_axis ()); graphene_matrix_rotate (&model_matrix, transformation->zrotation, graphene_vec3_z_axis ()); /* Translate back from pivot origin */ graphene_point3d_scale (&pivot_vector, -1.0, &negative_pivot_vector); graphene_matrix_translate (&model_matrix, &negative_pivot_vector); /* Translation */ graphene_matrix_translate (&model_matrix, &translation_vector); if (transformation->ortho) { graphene_matrix_init_ortho (&projection_matrix, -transformation->aspect, transformation->aspect, -1, 1, transformation->znear, transformation->zfar); } else { graphene_matrix_init_perspective (&projection_matrix, transformation->fov, transformation->aspect, transformation->znear, transformation->zfar); } graphene_matrix_init_look_at (&view_matrix, &eye, ¢er, &up); graphene_matrix_multiply (&view_matrix, &projection_matrix, &vp_matrix); graphene_matrix_multiply (&model_matrix, &vp_matrix, &transformation->mvp_matrix); } static void gst_gl_transformation_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstGLTransformation *filter = GST_GL_TRANSFORMATION (object); switch (prop_id) { case PROP_FOV: filter->fov = g_value_get_float (value); break; case PROP_ORTHO: filter->ortho = g_value_get_boolean (value); break; case PROP_TRANSLATION_X: filter->xtranslation = g_value_get_float (value); break; case PROP_TRANSLATION_Y: filter->ytranslation = g_value_get_float (value); break; case PROP_TRANSLATION_Z: filter->ztranslation = g_value_get_float (value); break; case PROP_ROTATION_X: filter->xrotation = g_value_get_float (value); break; case PROP_ROTATION_Y: filter->yrotation = g_value_get_float (value); break; case PROP_ROTATION_Z: filter->zrotation = g_value_get_float (value); break; case PROP_SCALE_X: filter->xscale = g_value_get_float (value); break; case PROP_SCALE_Y: filter->yscale = g_value_get_float (value); break; case PROP_PIVOT_X: filter->xpivot = g_value_get_float (value); break; case PROP_PIVOT_Y: filter->ypivot = g_value_get_float (value); break; case PROP_PIVOT_Z: filter->zpivot = g_value_get_float (value); break; case PROP_MVP: if (g_value_get_boxed (value) != NULL) filter->mvp_matrix = *((graphene_matrix_t *) g_value_get_boxed (value)); return; break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } gst_gl_transformation_build_mvp (filter); } static void gst_gl_transformation_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstGLTransformation *filter = GST_GL_TRANSFORMATION (object); switch (prop_id) { case PROP_FOV: g_value_set_float (value, filter->fov); break; case PROP_ORTHO: g_value_set_boolean (value, filter->ortho); break; case PROP_TRANSLATION_X: g_value_set_float (value, filter->xtranslation); break; case PROP_TRANSLATION_Y: g_value_set_float (value, filter->ytranslation); break; case PROP_TRANSLATION_Z: g_value_set_float (value, filter->ztranslation); break; case PROP_ROTATION_X: g_value_set_float (value, filter->xrotation); break; case PROP_ROTATION_Y: g_value_set_float (value, filter->yrotation); break; case PROP_ROTATION_Z: g_value_set_float (value, filter->zrotation); break; case PROP_SCALE_X: g_value_set_float (value, filter->xscale); break; case PROP_SCALE_Y: g_value_set_float (value, filter->yscale); break; case PROP_PIVOT_X: g_value_set_float (value, filter->xpivot); break; case PROP_PIVOT_Y: g_value_set_float (value, filter->ypivot); break; case PROP_PIVOT_Z: g_value_set_float (value, filter->zpivot); break; case PROP_MVP: g_value_set_boxed (value, (gconstpointer) & filter->mvp_matrix); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static gboolean gst_gl_transformation_set_caps (GstGLFilter * filter, GstCaps * incaps, GstCaps * outcaps) { GstGLTransformation *transformation = GST_GL_TRANSFORMATION (filter); transformation->aspect = (gdouble) GST_VIDEO_INFO_WIDTH (&filter->out_info) / (gdouble) GST_VIDEO_INFO_HEIGHT (&filter->out_info); transformation->caps_change = TRUE; gst_gl_transformation_build_mvp (transformation); return TRUE; } static void gst_gl_transformation_reset_gl (GstGLFilter * filter) { GstGLTransformation *transformation = GST_GL_TRANSFORMATION (filter); const GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable; if (transformation->vao) { gl->DeleteVertexArrays (1, &transformation->vao); transformation->vao = 0; } if (transformation->vertex_buffer) { gl->DeleteBuffers (1, &transformation->vertex_buffer); transformation->vertex_buffer = 0; } if (transformation->vbo_indices) { gl->DeleteBuffers (1, &transformation->vbo_indices); transformation->vbo_indices = 0; } if (transformation->shader) { gst_object_unref (transformation->shader); transformation->shader = NULL; } } static gboolean gst_gl_transformation_stop (GstBaseTransform * trans) { GstGLBaseFilter *basefilter = GST_GL_BASE_FILTER (trans); GstGLTransformation *transformation = GST_GL_TRANSFORMATION (trans); /* blocking call, wait until the opengl thread has destroyed the shader */ if (basefilter->context && transformation->shader) { gst_gl_context_del_shader (basefilter->context, transformation->shader); transformation->shader = NULL; } return GST_BASE_TRANSFORM_CLASS (parent_class)->stop (trans); } static gboolean gst_gl_transformation_init_shader (GstGLFilter * filter) { GstGLTransformation *transformation = GST_GL_TRANSFORMATION (filter); if (transformation->shader) { gst_object_unref (transformation->shader); transformation->shader = NULL; } if (gst_gl_context_get_gl_api (GST_GL_BASE_FILTER (filter)->context)) { /* blocking call, wait until the opengl thread has compiled the shader */ return gst_gl_context_gen_shader (GST_GL_BASE_FILTER (filter)->context, cube_v_src, cube_f_src, &transformation->shader); } return TRUE; } static gboolean gst_gl_transformation_filter_texture (GstGLFilter * filter, guint in_tex, guint out_tex) { GstGLTransformation *transformation = GST_GL_TRANSFORMATION (filter); transformation->in_tex = in_tex; /* blocking call, use a FBO */ gst_gl_context_use_fbo_v2 (GST_GL_BASE_FILTER (filter)->context, GST_VIDEO_INFO_WIDTH (&filter->out_info), GST_VIDEO_INFO_HEIGHT (&filter->out_info), filter->fbo, filter->depthbuffer, out_tex, gst_gl_transformation_callback, (gpointer) transformation); return TRUE; } static const GLushort indices[] = { 0, 1, 2, 3, 0 }; static void _upload_vertices (GstGLTransformation * transformation) { const GstGLFuncs *gl = GST_GL_BASE_FILTER (transformation)->context->gl_vtable; /* *INDENT-OFF* */ GLfloat vertices[] = { -transformation->aspect, 1.0, 0.0, 1.0, 0.0, 1.0, transformation->aspect, 1.0, 0.0, 1.0, 1.0, 1.0, transformation->aspect, -1.0, 0.0, 1.0, 1.0, 0.0, -transformation->aspect, -1.0, 0.0, 1.0, 0.0, 0.0 }; /* *INDENT-ON* */ gl->BindBuffer (GL_ARRAY_BUFFER, transformation->vertex_buffer); gl->BufferData (GL_ARRAY_BUFFER, 4 * 6 * sizeof (GLfloat), vertices, GL_STATIC_DRAW); } static void _bind_buffer (GstGLTransformation * transformation) { const GstGLFuncs *gl = GST_GL_BASE_FILTER (transformation)->context->gl_vtable; gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, transformation->vbo_indices); gl->BindBuffer (GL_ARRAY_BUFFER, transformation->vertex_buffer); /* Load the vertex position */ gl->VertexAttribPointer (transformation->attr_position, 4, GL_FLOAT, GL_FALSE, 6 * sizeof (GLfloat), (void *) 0); /* Load the texture coordinate */ gl->VertexAttribPointer (transformation->attr_texture, 2, GL_FLOAT, GL_FALSE, 6 * sizeof (GLfloat), (void *) (4 * sizeof (GLfloat))); gl->EnableVertexAttribArray (transformation->attr_position); gl->EnableVertexAttribArray (transformation->attr_texture); } static void _unbind_buffer (GstGLTransformation * transformation) { const GstGLFuncs *gl = GST_GL_BASE_FILTER (transformation)->context->gl_vtable; gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0); gl->BindBuffer (GL_ARRAY_BUFFER, 0); gl->DisableVertexAttribArray (transformation->attr_position); gl->DisableVertexAttribArray (transformation->attr_texture); } static void gst_gl_transformation_callback (gpointer stuff) { GstGLFilter *filter = GST_GL_FILTER (stuff); GstGLTransformation *transformation = GST_GL_TRANSFORMATION (filter); GstGLFuncs *gl = GST_GL_BASE_FILTER (filter)->context->gl_vtable; GLfloat temp_matrix[16]; gst_gl_context_clear_shader (GST_GL_BASE_FILTER (filter)->context); gl->BindTexture (GL_TEXTURE_2D, 0); gl->ClearColor (0.f, 0.f, 0.f, 0.f); gl->Clear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); gst_gl_shader_use (transformation->shader); gl->ActiveTexture (GL_TEXTURE0); gl->BindTexture (GL_TEXTURE_2D, transformation->in_tex); gst_gl_shader_set_uniform_1i (transformation->shader, "texture", 0); graphene_matrix_to_float (&transformation->mvp_matrix, temp_matrix); gst_gl_shader_set_uniform_matrix_4fv (transformation->shader, "mvp", 1, GL_FALSE, temp_matrix); if (!transformation->vertex_buffer) { transformation->attr_position = gst_gl_shader_get_attribute_location (transformation->shader, "position"); transformation->attr_texture = gst_gl_shader_get_attribute_location (transformation->shader, "uv"); if (gl->GenVertexArrays) { gl->GenVertexArrays (1, &transformation->vao); gl->BindVertexArray (transformation->vao); } gl->GenBuffers (1, &transformation->vertex_buffer); gl->GenBuffers (1, &transformation->vbo_indices); gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, transformation->vbo_indices); gl->BufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof (indices), indices, GL_STATIC_DRAW); transformation->caps_change = TRUE; } if (gl->GenVertexArrays) gl->BindVertexArray (transformation->vao); if (transformation->caps_change) { _upload_vertices (transformation); _bind_buffer (transformation); } else if (!gl->GenVertexArrays) { _bind_buffer (transformation); } gl->DrawElements (GL_TRIANGLE_STRIP, 5, GL_UNSIGNED_SHORT, 0); if (gl->GenVertexArrays) gl->BindVertexArray (0); else _unbind_buffer (transformation); gst_gl_context_clear_shader (GST_GL_BASE_FILTER (filter)->context); transformation->caps_change = FALSE; }