| /* |
| * GStreamer |
| * 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. |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include "gstglslstage.h" |
| |
| #include "gl.h" |
| #include "gstglfuncs.h" |
| #include "gstglsl_private.h" |
| |
| #ifndef GL_GEOMETRY_SHADER |
| #define GL_GEOMETRY_SHADER 0x8DD9 |
| #endif |
| #ifndef GL_COMPUTE_SHADER |
| #define GL_COMPUTE_SHADER 0x91B9 |
| #endif |
| #ifndef GL_TESS_CONTROL_SHADER |
| #define GL_TESS_CONTROL_SHADER 0x8E88 |
| #endif |
| #ifndef GL_TESS_EVALUATION_SHADER |
| #define GL_TESS_EVALUATION_SHADER 0x8E87 |
| #endif |
| |
| /** |
| * SECTION:gstglslstage |
| * @short_description: object for dealing with OpenGL shader stages |
| * @title: GstGLSLStage |
| * @see_also: #GstGLShader |
| * |
| * #GstGLSLStage holds and represents a single OpenGL shader stage. |
| */ |
| |
| static const gchar *es2_version_header = "#version 100\n"; |
| |
| GST_DEBUG_CATEGORY_STATIC (gst_glsl_stage_debug); |
| #define GST_CAT_DEFAULT gst_glsl_stage_debug |
| |
| G_DEFINE_TYPE_WITH_CODE (GstGLSLStage, gst_glsl_stage, GST_TYPE_OBJECT, |
| GST_DEBUG_CATEGORY_INIT (gst_glsl_stage_debug, "glslstage", 0, |
| "GLSL Stage"); |
| ); |
| |
| #define GST_GLSL_STAGE_GET_PRIVATE(o) \ |
| (G_TYPE_INSTANCE_GET_PRIVATE((o), GST_TYPE_GLSL_STAGE, GstGLSLStagePrivate)) |
| |
| struct _GstGLSLStagePrivate |
| { |
| GstGLSLFuncs vtable; |
| |
| GLenum type; |
| GLhandleARB handle; |
| GstGLSLVersion version; |
| GstGLSLProfile profile; |
| gchar **strings; |
| gint n_strings; |
| |
| gboolean compiled; |
| }; |
| |
| static void |
| gst_glsl_stage_finalize (GObject * object) |
| { |
| GstGLSLStage *stage = GST_GLSL_STAGE (object); |
| gint i; |
| |
| if (stage->context) { |
| gst_object_unref (stage->context); |
| stage->context = NULL; |
| } |
| |
| for (i = 0; i < stage->priv->n_strings; i++) { |
| g_free (stage->priv->strings[i]); |
| } |
| g_free (stage->priv->strings); |
| stage->priv->strings = NULL; |
| |
| G_OBJECT_CLASS (gst_glsl_stage_parent_class)->finalize (object); |
| } |
| |
| static void |
| gst_glsl_stage_set_property (GObject * object, |
| guint prop_id, const GValue * value, GParamSpec * pspec) |
| { |
| switch (prop_id) { |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
| break; |
| } |
| } |
| |
| static void |
| gst_glsl_stage_get_property (GObject * object, |
| guint prop_id, GValue * value, GParamSpec * pspec) |
| { |
| switch (prop_id) { |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
| break; |
| } |
| |
| } |
| |
| static void |
| gst_glsl_stage_class_init (GstGLSLStageClass * klass) |
| { |
| GObjectClass *obj_class = G_OBJECT_CLASS (klass); |
| |
| g_type_class_add_private (klass, sizeof (GstGLSLStagePrivate)); |
| |
| obj_class->finalize = gst_glsl_stage_finalize; |
| obj_class->set_property = gst_glsl_stage_set_property; |
| obj_class->get_property = gst_glsl_stage_get_property; |
| } |
| |
| static void |
| gst_glsl_stage_init (GstGLSLStage * stage) |
| { |
| stage->priv = GST_GLSL_STAGE_GET_PRIVATE (stage); |
| } |
| |
| static gboolean |
| _is_valid_shader_type (GLenum type) |
| { |
| switch (type) { |
| case GL_VERTEX_SHADER: |
| case GL_FRAGMENT_SHADER: |
| case GL_TESS_CONTROL_SHADER: |
| case GL_TESS_EVALUATION_SHADER: |
| case GL_GEOMETRY_SHADER: |
| case GL_COMPUTE_SHADER: |
| return TRUE; |
| default: |
| return FALSE; |
| } |
| } |
| |
| static const gchar * |
| _shader_type_to_string (GLenum type) |
| { |
| switch (type) { |
| case GL_VERTEX_SHADER: |
| return "vertex"; |
| case GL_FRAGMENT_SHADER: |
| return "fragment"; |
| case GL_TESS_CONTROL_SHADER: |
| return "tesselation control"; |
| case GL_TESS_EVALUATION_SHADER: |
| return "tesselation evaluation"; |
| case GL_GEOMETRY_SHADER: |
| return "geometry"; |
| case GL_COMPUTE_SHADER: |
| return "compute"; |
| default: |
| return "unknown"; |
| } |
| } |
| |
| static gboolean |
| _ensure_shader (GstGLSLStage * stage) |
| { |
| if (stage->priv->handle) |
| return TRUE; |
| |
| if (!(stage->priv->handle = |
| stage->priv->vtable.CreateShader (stage->priv->type))) |
| return FALSE; |
| |
| return stage->priv->handle != 0; |
| } |
| |
| /** |
| * gst_glsl_stage_new_with_strings: |
| * @context: a #GstGLContext |
| * @type: the GL enum shader stage type |
| * @version: the #GstGLSLVersion |
| * @profile: the #GstGLSLProfile |
| * @n_strings: the number of strings in @str |
| * @str: (array length=n_strings): |
| * an array of strings concatted together to produce a shader |
| * |
| * Returns: (transfer floating): a new #GstGLSLStage of the specified @type |
| * |
| * Since: 1.8 |
| */ |
| GstGLSLStage * |
| gst_glsl_stage_new_with_strings (GstGLContext * context, guint type, |
| GstGLSLVersion version, GstGLSLProfile profile, gint n_strings, |
| const gchar ** str) |
| { |
| GstGLSLStage *stage; |
| |
| g_return_val_if_fail (GST_IS_GL_CONTEXT (context), NULL); |
| g_return_val_if_fail (_is_valid_shader_type (type), NULL); |
| |
| stage = g_object_new (GST_TYPE_GLSL_STAGE, NULL); |
| /* FIXME: GInittable */ |
| if (!_gst_glsl_funcs_fill (&stage->priv->vtable, context)) { |
| gst_object_unref (stage); |
| return NULL; |
| } |
| |
| stage->context = gst_object_ref (context); |
| stage->priv->type = type; |
| if (!gst_glsl_stage_set_strings (stage, version, profile, n_strings, str)) { |
| gst_object_unref (stage); |
| return NULL; |
| } |
| |
| return stage; |
| } |
| |
| /** |
| * gst_glsl_stage_new_with_string: |
| * @context: a #GstGLContext |
| * @type: the GL enum shader stage type |
| * @version: the #GstGLSLVersion |
| * @profile: the #GstGLSLProfile |
| * @str: a shader string |
| * |
| * Returns: (transfer floating): a new #GstGLSLStage of the specified @type |
| * |
| * Since: 1.8 |
| */ |
| GstGLSLStage * |
| gst_glsl_stage_new_with_string (GstGLContext * context, guint type, |
| GstGLSLVersion version, GstGLSLProfile profile, const gchar * str) |
| { |
| return gst_glsl_stage_new_with_strings (context, type, version, profile, 1, |
| &str); |
| } |
| |
| /** |
| * gst_glsl_stage_new: |
| * @context: a #GstGLContext |
| * @type: the GL enum shader stage type |
| * |
| * Returns: (transfer floating): a new #GstGLSLStage of the specified @type |
| * |
| * Since: 1.8 |
| */ |
| GstGLSLStage * |
| gst_glsl_stage_new (GstGLContext * context, guint type) |
| { |
| return gst_glsl_stage_new_with_string (context, type, GST_GLSL_VERSION_NONE, |
| GST_GLSL_PROFILE_NONE, NULL); |
| } |
| |
| /** |
| * gst_glsl_stage_new_with_default_vertex: |
| * @context: a #GstGLContext |
| * |
| * Returns: (transfer floating): a new #GstGLSLStage with the default vertex shader |
| * |
| * Since: 1.8 |
| */ |
| GstGLSLStage * |
| gst_glsl_stage_new_default_vertex (GstGLContext * context) |
| { |
| return gst_glsl_stage_new_with_string (context, GL_VERTEX_SHADER, |
| GST_GLSL_VERSION_NONE, |
| GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY, |
| gst_gl_shader_string_vertex_default); |
| } |
| |
| /** |
| * gst_glsl_stage_new_with_default_fragment: |
| * @context: a #GstGLContext |
| * |
| * Returns: (transfer floating): a new #GstGLSLStage with the default fragment shader |
| * |
| * Since: 1.8 |
| */ |
| GstGLSLStage * |
| gst_glsl_stage_new_default_fragment (GstGLContext * context) |
| { |
| return gst_glsl_stage_new_with_string (context, GL_FRAGMENT_SHADER, |
| GST_GLSL_VERSION_NONE, |
| GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY, |
| gst_gl_shader_string_fragment_default); |
| } |
| |
| /** |
| * gst_glsl_stage_set_strings: |
| * @stage: a #GstGLSLStage |
| * @version: a #GstGLSLVersion |
| * @profile: a #GstGLSLProfile |
| * @n_strings: number of strings in @str |
| * @str: (array length=n_strings) (transfer none): a GLSL shader string |
| * |
| * Replaces the current shader string with @str. |
| * |
| * Since: 1.8 |
| */ |
| gboolean |
| gst_glsl_stage_set_strings (GstGLSLStage * stage, GstGLSLVersion version, |
| GstGLSLProfile profile, gint n_strings, const gchar ** str) |
| { |
| gint i; |
| |
| g_return_val_if_fail (GST_IS_GLSL_STAGE (stage), FALSE); |
| g_return_val_if_fail (n_strings > 0, FALSE); |
| g_return_val_if_fail (str != NULL, FALSE); |
| |
| if (!gst_gl_context_supports_glsl_profile_version (stage->context, version, |
| profile)) { |
| const gchar *version_str = gst_glsl_version_to_string (version); |
| const gchar *profile_str = gst_glsl_profile_to_string (profile); |
| GST_ERROR_OBJECT (stage, "GL context does not support version %s and " |
| "profile %s", version_str, profile_str); |
| return FALSE; |
| } |
| |
| stage->priv->version = version; |
| stage->priv->profile = profile; |
| |
| for (i = 0; i < stage->priv->n_strings; i++) { |
| g_free (stage->priv->strings[i]); |
| } |
| |
| if (stage->priv->n_strings < n_strings) { |
| /* only realloc if we need more space */ |
| g_free (stage->priv->strings); |
| stage->priv->strings = g_new0 (gchar *, n_strings); |
| } |
| |
| for (i = 0; i < n_strings; i++) |
| stage->priv->strings[i] = g_strdup (str[i]); |
| stage->priv->n_strings = n_strings; |
| |
| return TRUE; |
| } |
| |
| /** |
| * gst_glsl_stage_get_shader_type: |
| * @stage: a #GstGLSLStage |
| * |
| * Returns: The GL shader type for this shader stage |
| * |
| * Since: 1.8 |
| */ |
| guint |
| gst_glsl_stage_get_shader_type (GstGLSLStage * stage) |
| { |
| g_return_val_if_fail (GST_IS_GLSL_STAGE (stage), 0); |
| |
| return stage->priv->type; |
| } |
| |
| /** |
| * gst_glsl_stage_get_handle: |
| * @stage: a #GstGLSLStage |
| * |
| * Returns: The GL handle for this shader stage |
| * |
| * Since: 1.8 |
| */ |
| guint |
| gst_glsl_stage_get_handle (GstGLSLStage * stage) |
| { |
| g_return_val_if_fail (GST_IS_GLSL_STAGE (stage), 0); |
| g_return_val_if_fail (stage->priv->compiled, 0); |
| |
| return stage->priv->handle; |
| } |
| |
| /** |
| * gst_glsl_stage_get_version: |
| * @stage: a #GstGLSLStage |
| * |
| * Returns: The GLSL version for the current shader stage |
| * |
| * Since: 1.8 |
| */ |
| GstGLSLVersion |
| gst_glsl_stage_get_version (GstGLSLStage * stage) |
| { |
| g_return_val_if_fail (GST_IS_GLSL_STAGE (stage), 0); |
| |
| return stage->priv->version; |
| } |
| |
| /** |
| * gst_glsl_stage_get_profile: |
| * @stage: a #GstGLSLStage |
| * |
| * Returns: The GLSL profile for the current shader stage |
| * |
| * Since: 1.8 |
| */ |
| GstGLSLProfile |
| gst_glsl_stage_get_profile (GstGLSLStage * stage) |
| { |
| g_return_val_if_fail (GST_IS_GLSL_STAGE (stage), 0); |
| |
| return stage->priv->profile; |
| } |
| |
| static void |
| _maybe_prepend_version (GstGLSLStage * stage, gchar ** shader_str, |
| gint * n_vertex_sources, const gchar *** vertex_sources) |
| { |
| gint n = *n_vertex_sources; |
| gboolean add_header = FALSE; |
| gint i, j; |
| |
| /* FIXME: this all an educated guess */ |
| if (gst_gl_context_check_gl_version (stage->context, GST_GL_API_OPENGL3, 3, 0) |
| && (stage->priv->profile & GST_GLSL_PROFILE_ES) != 0 |
| && !_gst_glsl_shader_string_find_version (shader_str[0])) { |
| add_header = TRUE; |
| n++; |
| } |
| |
| *vertex_sources = g_malloc0 (n * sizeof (gchar *)); |
| |
| i = 0; |
| if (add_header) |
| (*vertex_sources)[i++] = es2_version_header; |
| |
| for (j = 0; j < stage->priv->n_strings; i++, j++) |
| (*vertex_sources)[i] = shader_str[j]; |
| *n_vertex_sources = n; |
| } |
| |
| struct compile |
| { |
| GstGLSLStage *stage; |
| GError **error; |
| gboolean result; |
| }; |
| |
| static void |
| _compile_shader (GstGLContext * context, struct compile *data) |
| { |
| GstGLSLStagePrivate *priv = data->stage->priv; |
| GstGLSLFuncs *vtable = &data->stage->priv->vtable; |
| const GstGLFuncs *gl = context->gl_vtable; |
| const gchar **vertex_sources; |
| gchar info_buffer[2048]; |
| gint n_vertex_sources; |
| GLint status; |
| gint len; |
| gint i; |
| |
| if (data->stage->priv->compiled) { |
| data->result = TRUE; |
| return; |
| } |
| |
| if (!_ensure_shader (data->stage)) { |
| g_set_error (data->error, GST_GLSL_ERROR, GST_GLSL_ERROR_COMPILE, |
| "Failed to create shader object"); |
| data->result = FALSE; |
| return; |
| } |
| |
| n_vertex_sources = data->stage->priv->n_strings; |
| _maybe_prepend_version (data->stage, priv->strings, &n_vertex_sources, |
| &vertex_sources); |
| |
| GST_TRACE_OBJECT (data->stage, "compiling shader:"); |
| for (i = 0; i < n_vertex_sources; i++) { |
| GST_TRACE_OBJECT (data->stage, "%s", vertex_sources[i]); |
| } |
| |
| gl->ShaderSource (priv->handle, n_vertex_sources, |
| (const gchar **) vertex_sources, NULL); |
| gl->CompileShader (priv->handle); |
| g_free (vertex_sources); |
| /* FIXME: supported threaded GLSL compilers and don't destroy compilation |
| * performance by getting the compilation result directly after compilation */ |
| status = GL_FALSE; |
| vtable->GetShaderiv (priv->handle, GL_COMPILE_STATUS, &status); |
| |
| len = 0; |
| vtable->GetShaderInfoLog (priv->handle, sizeof (info_buffer) - 1, &len, |
| info_buffer); |
| info_buffer[len] = '\0'; |
| |
| if (status != GL_TRUE) { |
| GST_ERROR_OBJECT (data->stage, "%s shader compilation failed:%s", |
| _shader_type_to_string (priv->type), info_buffer); |
| |
| g_set_error (data->error, GST_GLSL_ERROR, GST_GLSL_ERROR_COMPILE, |
| "%s shader compilation failed:%s", |
| _shader_type_to_string (priv->type), info_buffer); |
| |
| vtable->DeleteShader (priv->handle); |
| data->result = FALSE; |
| return; |
| } else if (len > 1) { |
| GST_FIXME_OBJECT (data->stage, "%s shader info log:%s", |
| _shader_type_to_string (priv->type), info_buffer); |
| } |
| |
| data->result = TRUE; |
| } |
| |
| /** |
| * gst_glsl_stage_compile: |
| * @stage: a #GstGLSLStage |
| * @error: a #GError to use on failure |
| * |
| * Returns: whether the compilation suceeded |
| * |
| * Since: 1.8 |
| */ |
| gboolean |
| gst_glsl_stage_compile (GstGLSLStage * stage, GError ** error) |
| { |
| struct compile data; |
| |
| g_return_val_if_fail (GST_IS_GLSL_STAGE (stage), FALSE); |
| |
| if (!stage->priv->strings) { |
| g_set_error (error, GST_GLSL_ERROR, GST_GLSL_ERROR_COMPILE, |
| "No shader source to compile"); |
| return FALSE; |
| } |
| |
| data.stage = stage; |
| data.error = error; |
| |
| gst_gl_context_thread_add (stage->context, |
| (GstGLContextThreadFunc) _compile_shader, &data); |
| |
| stage->priv->compiled = TRUE; |
| |
| return data.result; |
| } |