static gboolean
gst_gl_filter_glass_init_shader (GstGLFilter * filter)
{
gboolean ret;
GstGLFilterGlass *glass_filter = GST_GL_FILTER_GLASS (filter);
//blocking call, wait the opengl thread has compiled the shader
ret =
gst_gl_context_gen_shader (GST_GL_BASE_FILTER (filter)->context,
glass_vertex_source, glass_fragment_source, &glass_filter->shader);
if (ret)
ret =
gst_gl_context_gen_shader (GST_GL_BASE_FILTER (filter)->context,
passthrough_vertex, passthrough_fragment,
&glass_filter->passthrough_shader);
return ret;
}
static gboolean
gst_gl_deinterlace_init_shader (GstGLFilter * filter)
{
GstGLDeinterlace *deinterlace_filter = GST_GL_DEINTERLACE (filter);
//blocking call, wait the opengl thread has compiled the shader
return gst_gl_context_gen_shader (GST_GL_BASE_FILTER (filter)->context, 0,
greedyh_fragment_source, &deinterlace_filter->shader);
}
static gboolean
gst_gl_bumper_init_shader (GstGLFilter * filter)
{
GstGLBumper *bumper = GST_GL_BUMPER (filter);
//blocking call, wait the opengl thread has compiled the shader
return gst_gl_context_gen_shader (filter->context, bumper_v_src, bumper_f_src,
&bumper->shader);
}
static gboolean
gst_gl_filter_cube_gl_start (GstGLBaseFilter * filter)
{
GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (filter);
/* blocking call, wait 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, &cube_filter->shader);
}
static gboolean
gst_gl_mosaic_init_shader (GstGLMixer * mixer, GstCaps * outcaps)
{
GstGLMosaic *mosaic = GST_GL_MOSAIC (mixer);
g_clear_object (&mosaic->shader);
//blocking call, wait the opengl thread has compiled the shader
return gst_gl_context_gen_shader (GST_GL_BASE_MIXER (mixer)->context,
mosaic_v_src, mosaic_f_src, &mosaic->shader);
}
static gboolean
gst_gl_video_mixer_init_shader (GstGLMixer * mixer, GstCaps * outcaps)
{
GstGLVideoMixer *video_mixer = GST_GL_VIDEO_MIXER (mixer);
if (video_mixer->shader)
gst_gl_context_del_shader (GST_GL_BASE_MIXER (mixer)->context,
video_mixer->shader);
return gst_gl_context_gen_shader (GST_GL_BASE_MIXER (mixer)->context,
video_mixer_v_src, video_mixer_f_src, &video_mixer->shader);
}
static gboolean
gst_gl_filter_cube_init_shader (GstGLFilter * filter)
{
GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (filter);
if (gst_gl_context_get_gl_api (filter->context) & GST_GL_API_GLES2) {
/* blocking call, wait the opengl thread has compiled the shader */
return gst_gl_context_gen_shader (filter->context, cube_v_src, cube_f_src,
&cube_filter->shader);
}
return TRUE;
}
static gboolean
gst_gl_transformation_init_shader (GstGLFilter * filter)
{
GstGLTransformation *transformation = GST_GL_TRANSFORMATION (filter);
if (gst_gl_context_get_gl_api (filter->context)) {
/* blocking call, wait until the opengl thread has compiled the shader */
return gst_gl_context_gen_shader (filter->context, cube_v_src, cube_f_src,
&transformation->shader);
}
return TRUE;
}
static gboolean
_draw_checker_background (GstGLVideoMixer * video_mixer)
{
GstGLMixer *mixer = GST_GL_MIXER (video_mixer);
const GstGLFuncs *gl = GST_GL_BASE_MIXER (mixer)->context->gl_vtable;
gint attr_position_loc = 0;
/* *INDENT-OFF* */
gfloat v_vertices[] = {
-1.0,-1.0,-1.0f,
1.0,-1.0,-1.0f,
1.0, 1.0,-1.0f,
-1.0, 1.0,-1.0f,
};
/* *INDENT-ON* */
if (!video_mixer->checker) {
if (!gst_gl_context_gen_shader (GST_GL_BASE_MIXER (mixer)->context,
checker_v_src, checker_f_src, &video_mixer->checker))
return FALSE;
}
gst_gl_shader_use (video_mixer->checker);
attr_position_loc =
gst_gl_shader_get_attribute_location (video_mixer->checker, "a_position");
_init_vbo_indices (video_mixer);
if (!video_mixer->checker_vbo) {
gl->GenBuffers (1, &video_mixer->checker_vbo);
gl->BindBuffer (GL_ARRAY_BUFFER, video_mixer->checker_vbo);
gl->BufferData (GL_ARRAY_BUFFER, 4 * 3 * sizeof (GLfloat), v_vertices,
GL_STATIC_DRAW);
} else {
gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, video_mixer->vbo_indices);
gl->BindBuffer (GL_ARRAY_BUFFER, video_mixer->checker_vbo);
}
gl->VertexAttribPointer (attr_position_loc, 3, GL_FLOAT,
GL_FALSE, 3 * sizeof (GLfloat), (void *) 0);
gl->EnableVertexAttribArray (attr_position_loc);
gl->DrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
gl->DisableVertexAttribArray (attr_position_loc);
gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
gl->BindBuffer (GL_ARRAY_BUFFER, 0);
return TRUE;
}
static gboolean
_2d_texture_renderer_init (GstAmc2DTextureRenderer * renderer)
{
GstGLFuncs *gl;
gboolean res;
gl = renderer->context->gl_vtable;
if (renderer->initialized)
return TRUE;
if (!gl->CreateProgramObject && !gl->CreateProgram) {
gst_gl_context_set_error (renderer->context,
"Cannot perform conversion without OpenGL shaders");
return FALSE;
}
_gen_oes_texture (renderer->context, &renderer->oes_tex_id);
res =
gst_gl_context_gen_shader (renderer->context, vert_COPY_OES,
frag_COPY_OES, &renderer->shader);
if (!res)
return FALSE;
renderer->shader_attr_position_loc =
gst_gl_shader_get_attribute_location (renderer->shader, "a_position");
renderer->shader_attr_texture_loc =
gst_gl_shader_get_attribute_location (renderer->shader, "a_texcoord");
gst_gl_shader_use (renderer->shader);
gst_gl_shader_set_uniform_1i (renderer->shader, "u_tex", 0);
gst_gl_context_clear_shader (renderer->context);
if (!_2d_texture_renderer_init_fbo (renderer))
return FALSE;
gl->BindTexture (GL_TEXTURE_2D, 0);
renderer->initialized = TRUE;
return TRUE;
}
/* Called in the gl thread */
static gboolean
_init_convert (GstGLColorConvert * convert)
{
GstGLFuncs *gl;
gboolean res;
struct ConvertInfo *info = &convert->priv->convert_info;
gint i;
gl = convert->context->gl_vtable;
if (convert->initted)
return TRUE;
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 (convert->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 (convert);
}
}
if (GST_VIDEO_INFO_IS_YUV (&convert->in_info)) {
if (GST_VIDEO_INFO_IS_RGB (&convert->out_info)) {
_YUV_to_RGB (convert);
}
}
if (GST_VIDEO_INFO_IS_RGB (&convert->in_info)) {
if (GST_VIDEO_INFO_IS_YUV (&convert->out_info)) {
_RGB_to_YUV (convert);
}
}
if (GST_VIDEO_INFO_IS_RGB (&convert->in_info)) {
if (GST_VIDEO_INFO_IS_GRAY (&convert->out_info)) {
_RGB_to_GRAY (convert);
}
}
if (GST_VIDEO_INFO_IS_GRAY (&convert->in_info)) {
if (GST_VIDEO_INFO_IS_RGB (&convert->out_info)) {
_GRAY_to_RGB (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 (convert->context))) {
g_free (info->frag_prog);
GST_ERROR ("Conversion requires output to multiple draw buffers");
goto incompatible_api;
}
/* Requires reading from a RG/LA framebuffer... */
if (USING_GLES2 (convert->context) &&
(GST_VIDEO_INFO_FORMAT (&convert->out_info) == GST_VIDEO_FORMAT_YUY2 ||
GST_VIDEO_INFO_FORMAT (&convert->out_info) ==
GST_VIDEO_FORMAT_UYVY)) {
g_free (info->frag_prog);
GST_ERROR ("Conversion requires reading with an unsupported format");
goto incompatible_api;
}
res =
gst_gl_context_gen_shader (convert->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--) {
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_1f (convert->shader, "width",
GST_VIDEO_INFO_WIDTH (&convert->in_info));
gst_gl_shader_set_uniform_1f (convert->shader, "height",
GST_VIDEO_INFO_HEIGHT (&convert->in_info));
if (info->chroma_sampling[0] > 0.0f && info->chroma_sampling[1] > 0.0f) {
gst_gl_shader_set_uniform_2fv (convert->shader, "chroma_sampling", 1,
info->chroma_sampling);
}
gst_gl_context_clear_shader (convert->context);
if (!_init_convert_fbo (convert)) {
goto error;
}
gl->BindTexture (GL_TEXTURE_2D, 0);
convert->initted = TRUE;
return TRUE;
unhandled_format:
gst_gl_context_set_error (convert->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:
return FALSE;
incompatible_api:
{
gst_gl_context_set_error (convert->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)));
return FALSE;
}
}
