blob: 4e7374c30245be7eef0e041f876e1ea93e7480d8 [file] [log] [blame]
/*
* 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;
}