void
gst_amc_2d_texture_renderer_free (GstAmc2DTextureRenderer * renderer)
{
GError *error = NULL;
if (renderer->surface_texture) {
_surface_texture_detach_from_gl_context_perform (renderer, &error);
g_object_unref (renderer->surface_texture);
}
if (renderer->fbo || renderer->depth_buffer) {
gst_gl_context_del_fbo (renderer->context, renderer->fbo,
renderer->depth_buffer);
}
if (renderer->shader) {
gst_object_unref (renderer->shader);
}
if (renderer->oes_tex_id) {
gst_gl_context_del_texture (renderer->context, &renderer->oes_tex_id);
}
if (renderer->context) {
gst_object_unref (renderer->context);
}
g_free (renderer);
}
static void
gst_egl_image_memory_del_gl_texture (GstGLContext * context, gpointer tex)
{
GLuint textures[1] = { GPOINTER_TO_UINT (tex) };
gst_gl_context_del_texture (context, textures);
}
static void
gst_gl_upload_reset (GstGLUpload * upload)
{
guint i;
if (upload->priv->tex_id) {
gst_gl_context_del_texture (upload->context, &upload->priv->tex_id);
upload->priv->tex_id = 0;
}
if (upload->convert) {
gst_object_unref (upload->convert);
upload->convert = NULL;
}
if (upload->out_tex) {
gst_memory_unref ((GstMemory *) upload->out_tex);
upload->out_tex = NULL;
}
for (i = 0; i < GST_VIDEO_MAX_PLANES; i++) {
if (upload->in_tex[i]) {
gst_memory_unref ((GstMemory *) upload->in_tex[i]);
upload->in_tex[i] = NULL;
}
}
gst_gl_upload_release_buffer (upload);
}
static gboolean
gst_glimage_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
{
GstGLImageSink *glimage_sink;
gint width;
gint height;
gboolean ok;
gint par_n, par_d;
gint display_par_n, display_par_d;
guint display_ratio_num, display_ratio_den;
GstVideoInfo vinfo;
GstStructure *structure;
GstBufferPool *newpool, *oldpool;
GST_DEBUG ("set caps with %" GST_PTR_FORMAT, caps);
glimage_sink = GST_GLIMAGE_SINK (bsink);
ok = gst_video_info_from_caps (&vinfo, caps);
if (!ok)
return FALSE;
width = GST_VIDEO_INFO_WIDTH (&vinfo);
height = GST_VIDEO_INFO_HEIGHT (&vinfo);
if (glimage_sink->tex_id)
gst_gl_context_del_texture (glimage_sink->context, &glimage_sink->tex_id);
//FIXME: this texture seems to be never deleted when going to STATE_NULL
gst_gl_context_gen_texture (glimage_sink->context, &glimage_sink->tex_id,
GST_VIDEO_INFO_FORMAT (&vinfo), width, height);
par_n = GST_VIDEO_INFO_PAR_N (&vinfo);
par_d = GST_VIDEO_INFO_PAR_D (&vinfo);
if (!par_n)
par_n = 1;
/* get display's PAR */
if (glimage_sink->par_n != 0 && glimage_sink->par_d != 0) {
display_par_n = glimage_sink->par_n;
display_par_d = glimage_sink->par_d;
} else {
display_par_n = 1;
display_par_d = 1;
}
ok = gst_video_calculate_display_ratio (&display_ratio_num,
&display_ratio_den, width, height, par_n, par_d, display_par_n,
display_par_d);
if (!ok)
return FALSE;
GST_TRACE ("PAR: %u/%u DAR:%u/%u", par_n, par_d, display_par_n,
display_par_d);
if (height % display_ratio_den == 0) {
GST_DEBUG ("keeping video height");
GST_VIDEO_SINK_WIDTH (glimage_sink) = (guint)
gst_util_uint64_scale_int (height, display_ratio_num,
display_ratio_den);
GST_VIDEO_SINK_HEIGHT (glimage_sink) = height;
} else if (width % display_ratio_num == 0) {
GST_DEBUG ("keeping video width");
GST_VIDEO_SINK_WIDTH (glimage_sink) = width;
GST_VIDEO_SINK_HEIGHT (glimage_sink) = (guint)
gst_util_uint64_scale_int (width, display_ratio_den, display_ratio_num);
} else {
GST_DEBUG ("approximating while keeping video height");
GST_VIDEO_SINK_WIDTH (glimage_sink) = (guint)
gst_util_uint64_scale_int (height, display_ratio_num,
display_ratio_den);
GST_VIDEO_SINK_HEIGHT (glimage_sink) = height;
}
GST_DEBUG ("scaling to %dx%d", GST_VIDEO_SINK_WIDTH (glimage_sink),
GST_VIDEO_SINK_HEIGHT (glimage_sink));
glimage_sink->info = vinfo;
newpool = gst_gl_buffer_pool_new (glimage_sink->context);
structure = gst_buffer_pool_get_config (newpool);
gst_buffer_pool_config_set_params (structure, caps, vinfo.size, 2, 0);
gst_buffer_pool_set_config (newpool, structure);
oldpool = glimage_sink->pool;
/* we don't activate the pool yet, this will be done by downstream after it
* has configured the pool. If downstream does not want our pool we will
* activate it when we render into it */
glimage_sink->pool = newpool;
/* unref the old sink */
if (oldpool) {
/* we don't deactivate, some elements might still be using it, it will
* be deactivated when the last ref is gone */
gst_object_unref (oldpool);
}
return TRUE;
}
static gboolean
gst_gl_mixer_decide_allocation (GstGLMixer * mix, GstQuery * query)
{
GstGLMixerClass *mixer_class = GST_GL_MIXER_GET_CLASS (mix);
GstBufferPool *pool = NULL;
GstStructure *config;
GstCaps *caps;
guint min, max, size;
gboolean update_pool;
GError *error = NULL;
guint idx;
guint out_width, out_height;
GstGLContext *other_context = NULL;
GstVideoAggregator *vagg = GST_VIDEO_AGGREGATOR (mix);
gst_query_parse_allocation (query, &caps, NULL);
if (gst_query_get_n_allocation_pools (query) > 0) {
gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
update_pool = TRUE;
} else {
GstVideoInfo vinfo;
gst_video_info_init (&vinfo);
gst_video_info_from_caps (&vinfo, caps);
size = vinfo.size;
min = max = 0;
update_pool = FALSE;
}
if (!gst_gl_ensure_display (mix, &mix->display))
return FALSE;
if (gst_query_find_allocation_meta (query,
GST_VIDEO_GL_TEXTURE_UPLOAD_META_API_TYPE, &idx)) {
GstGLContext *context;
const GstStructure *upload_meta_params;
gpointer handle;
gchar *type;
gchar *apis;
gst_query_parse_nth_allocation_meta (query, idx, &upload_meta_params);
if (upload_meta_params) {
if (gst_structure_get (upload_meta_params, "gst.gl.GstGLContext",
GST_GL_TYPE_CONTEXT, &context, NULL) && context) {
GstGLContext *old = mix->context;
mix->context = context;
if (old)
gst_object_unref (old);
} else if (gst_structure_get (upload_meta_params, "gst.gl.context.handle",
G_TYPE_POINTER, &handle, "gst.gl.context.type", G_TYPE_STRING,
&type, "gst.gl.context.apis", G_TYPE_STRING, &apis, NULL)
&& handle) {
GstGLPlatform platform = GST_GL_PLATFORM_NONE;
GstGLAPI gl_apis;
GST_DEBUG ("got GL context handle 0x%p with type %s and apis %s",
handle, type, apis);
platform = gst_gl_platform_from_string (type);
gl_apis = gst_gl_api_from_string (apis);
if (gl_apis && platform)
other_context =
gst_gl_context_new_wrapped (mix->display, (guintptr) handle,
platform, gl_apis);
}
}
}
if (!mix->context) {
mix->context = gst_gl_context_new (mix->display);
if (!gst_gl_context_create (mix->context, other_context, &error))
goto context_error;
}
out_width = GST_VIDEO_INFO_WIDTH (&vagg->info);
out_height = GST_VIDEO_INFO_HEIGHT (&vagg->info);
g_mutex_lock (&mix->priv->gl_resource_lock);
mix->priv->gl_resource_ready = FALSE;
if (mix->fbo) {
gst_gl_context_del_fbo (mix->context, mix->fbo, mix->depthbuffer);
mix->fbo = 0;
mix->depthbuffer = 0;
}
if (!gst_gl_context_gen_fbo (mix->context, out_width, out_height,
&mix->fbo, &mix->depthbuffer)) {
g_cond_signal (&mix->priv->gl_resource_cond);
g_mutex_unlock (&mix->priv->gl_resource_lock);
goto context_error;
}
if (mix->out_tex_id)
gst_gl_context_del_texture (mix->context, &mix->out_tex_id);
gst_gl_context_gen_texture (mix->context, &mix->out_tex_id,
GST_VIDEO_FORMAT_RGBA, out_width, out_height);
if (mixer_class->set_caps)
mixer_class->set_caps (mix, caps);
mix->priv->gl_resource_ready = TRUE;
g_cond_signal (&mix->priv->gl_resource_cond);
g_mutex_unlock (&mix->priv->gl_resource_lock);
if (!pool)
pool = gst_gl_buffer_pool_new (mix->context);
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, min, max);
gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
gst_buffer_pool_set_config (pool, config);
if (update_pool)
gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
else
gst_query_add_allocation_pool (query, pool, size, min, max);
gst_object_unref (pool);
return TRUE;
context_error:
{
GST_ELEMENT_ERROR (mix, RESOURCE, NOT_FOUND, ("%s", error->message),
(NULL));
return FALSE;
}
}
gboolean
gst_egl_image_memory_setup_buffer (GstGLContext * ctx, GstVideoInfo * info,
GstBuffer * buffer)
{
gint i = 0;
gint stride[3];
gsize offset[3];
GstMemory *mem[3] = { NULL, NULL, NULL };
guint n_mem = 0;
GstMemoryFlags flags = 0;
EGLImageKHR image = EGL_NO_IMAGE_KHR;
EGLClientBuffer client_buffer_tex[3] = { 0, 0, 0 };
GstVideoGLTextureType texture_types[] = { 0, 0, 0, 0 };
GstEGLImageAllocator *allocator = gst_egl_image_allocator_obtain ();
GstGLContextEGL *context = GST_GL_CONTEXT_EGL (ctx);
g_return_val_if_fail (ctx, FALSE);
g_return_val_if_fail (info, FALSE);
g_return_val_if_fail (buffer, FALSE);
g_return_val_if_fail (gst_gl_context_check_feature (ctx,
"EGL_KHR_image_base"), FALSE);
memset (stride, 0, sizeof (stride));
memset (offset, 0, sizeof (offset));
flags |= GST_MEMORY_FLAG_NOT_MAPPABLE;
flags |= GST_MEMORY_FLAG_NO_SHARE;
switch (GST_VIDEO_INFO_FORMAT (info)) {
case GST_VIDEO_FORMAT_RGB:
case GST_VIDEO_FORMAT_BGR:
case GST_VIDEO_FORMAT_RGB16:
case GST_VIDEO_FORMAT_RGBA:
case GST_VIDEO_FORMAT_BGRA:
case GST_VIDEO_FORMAT_ARGB:
case GST_VIDEO_FORMAT_ABGR:
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
case GST_VIDEO_FORMAT_AYUV:
{
gsize size = 0;
switch (GST_VIDEO_INFO_FORMAT (info)) {
case GST_VIDEO_FORMAT_RGB:
case GST_VIDEO_FORMAT_BGR:
case GST_VIDEO_FORMAT_RGB16:
{
texture_types[0] = GST_VIDEO_GL_TEXTURE_TYPE_RGB;
break;
}
case GST_VIDEO_FORMAT_RGBA:
case GST_VIDEO_FORMAT_BGRA:
case GST_VIDEO_FORMAT_ARGB:
case GST_VIDEO_FORMAT_ABGR:
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
case GST_VIDEO_FORMAT_AYUV:
{
texture_types[0] = GST_VIDEO_GL_TEXTURE_TYPE_RGBA;
break;
}
default:
g_assert_not_reached ();
break;
}
#if 0
mem[0] =
gst_egl_image_allocator_alloc (allocator, context,
texture_types[0], GST_VIDEO_INFO_WIDTH (info),
GST_VIDEO_INFO_HEIGHT (info), size);
if (mem[0]) {
stride[0] = size / GST_VIDEO_INFO_HEIGHT (info);
n_mem = 1;
GST_MINI_OBJECT_FLAG_SET (mem[0], GST_MEMORY_FLAG_NO_SHARE);
} else
#endif
{
gst_gl_generate_texture_full (GST_GL_CONTEXT (context), info, 0, stride,
offset, &size, (GLuint *) & client_buffer_tex[0]);
image = context->eglCreateImage (context->egl_display,
context->egl_context, EGL_GL_TEXTURE_2D_KHR, client_buffer_tex[0],
NULL);
if (eglGetError () != EGL_SUCCESS)
goto mem_error;
mem[0] =
gst_egl_image_allocator_wrap (allocator, context,
image, texture_types[0], flags, size, client_buffer_tex[0],
(GstEGLImageDestroyNotify) gst_egl_image_memory_del_gl_texture);
n_mem = 1;
}
break;
}
case GST_VIDEO_FORMAT_NV12:
case GST_VIDEO_FORMAT_NV21:
{
gsize size[2];
texture_types[0] = GST_VIDEO_GL_TEXTURE_TYPE_LUMINANCE;
texture_types[1] = GST_VIDEO_GL_TEXTURE_TYPE_LUMINANCE_ALPHA;
#if 0
mem[0] =
gst_egl_image_allocator_alloc (allocator, context,
texture_types[0], GST_VIDEO_INFO_COMP_WIDTH (info,
0), GST_VIDEO_INFO_COMP_HEIGHT (info, 0), size[0]);
mem[1] =
gst_egl_image_allocator_alloc (allocator, context,
texture_types[1],
GST_VIDEO_INFO_COMP_WIDTH (info, 1),
GST_VIDEO_INFO_COMP_HEIGHT (info, 1), size[1]);
if (mem[0] && mem[1]) {
stride[0] = size[0] / GST_VIDEO_INFO_HEIGHT (info);
offset[1] = size[0];
stride[1] = size[1] / GST_VIDEO_INFO_HEIGHT (info);
n_mem = 2;
GST_MINI_OBJECT_FLAG_SET (mem[0], GST_MEMORY_FLAG_NO_SHARE);
GST_MINI_OBJECT_FLAG_SET (mem[1], GST_MEMORY_FLAG_NO_SHARE);
} else {
if (mem[0])
gst_memory_unref (mem[0]);
if (mem[1])
gst_memory_unref (mem[1]);
mem[0] = mem[1] = NULL;
}
#endif
{
for (i = 0; i < 2; i++) {
gst_gl_generate_texture_full (GST_GL_CONTEXT (context), info, 0,
stride, offset, size, (GLuint *) & client_buffer_tex[i]);
image = context->eglCreateImage (context->egl_display,
context->egl_context, EGL_GL_TEXTURE_2D_KHR, client_buffer_tex[i],
NULL);
if (eglGetError () != EGL_SUCCESS)
goto mem_error;
mem[i] =
gst_egl_image_allocator_wrap (allocator, context,
image, texture_types[i], flags, size[i], client_buffer_tex[i],
(GstEGLImageDestroyNotify) gst_egl_image_memory_del_gl_texture);
}
n_mem = 2;
}
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:
{
gsize size[3];
texture_types[0] = GST_VIDEO_GL_TEXTURE_TYPE_LUMINANCE;
texture_types[1] = GST_VIDEO_GL_TEXTURE_TYPE_LUMINANCE;
texture_types[2] = GST_VIDEO_GL_TEXTURE_TYPE_LUMINANCE;
#if 0
mem[0] =
gst_egl_image_allocator_alloc (allocator, context,
texture_types[0], GST_VIDEO_INFO_COMP_WIDTH (info,
0), GST_VIDEO_INFO_COMP_HEIGHT (info, 0), size[0]);
mem[1] =
gst_egl_image_allocator_alloc (allocator, context,
texture_types[1], GST_VIDEO_INFO_COMP_WIDTH (info,
1), GST_VIDEO_INFO_COMP_HEIGHT (info, 1), size[1]);
mem[2] =
gst_egl_image_allocator_alloc (allocator, context,
texture_types[2], GST_VIDEO_INFO_COMP_WIDTH (info,
2), GST_VIDEO_INFO_COMP_HEIGHT (info, 2), size[2]);
if (mem[0] && mem[1] && mem[2]) {
stride[0] = size[0] / GST_VIDEO_INFO_HEIGHT (info);
offset[1] = size[0];
stride[1] = size[1] / GST_VIDEO_INFO_HEIGHT (info);
offset[2] = size[1];
stride[2] = size[2] / GST_VIDEO_INFO_HEIGHT (info);
n_mem = 3;
GST_MINI_OBJECT_FLAG_SET (mem[0], GST_MEMORY_FLAG_NO_SHARE);
GST_MINI_OBJECT_FLAG_SET (mem[1], GST_MEMORY_FLAG_NO_SHARE);
GST_MINI_OBJECT_FLAG_SET (mem[2], GST_MEMORY_FLAG_NO_SHARE);
} else {
if (mem[0])
gst_memory_unref (mem[0]);
if (mem[1])
gst_memory_unref (mem[1]);
if (mem[2])
gst_memory_unref (mem[2]);
mem[0] = mem[1] = mem[2] = NULL;
}
#endif
{
for (i = 0; i < 3; i++) {
gst_gl_generate_texture_full (GST_GL_CONTEXT (context), info, i,
stride, offset, size, (GLuint *) & client_buffer_tex[i]);
image = context->eglCreateImage (context->egl_display,
context->egl_context, EGL_GL_TEXTURE_2D_KHR, client_buffer_tex[i],
NULL);
if (eglGetError () != EGL_SUCCESS)
goto mem_error;
mem[i] =
gst_egl_image_allocator_wrap (allocator, context,
image, texture_types[i], flags, size[i], client_buffer_tex[i],
(GstEGLImageDestroyNotify) gst_egl_image_memory_del_gl_texture);
}
n_mem = 3;
}
break;
}
default:
g_assert_not_reached ();
break;
}
gst_buffer_add_video_meta_full (buffer, 0, GST_VIDEO_INFO_FORMAT (info),
GST_VIDEO_INFO_WIDTH (info), GST_VIDEO_INFO_HEIGHT (info),
GST_VIDEO_INFO_N_PLANES (info), offset, stride);
gst_buffer_add_video_gl_texture_upload_meta (buffer,
gst_egl_image_memory_get_orientation (mem[0]), n_mem, texture_types,
gst_eglimage_to_gl_texture_upload_meta, NULL, NULL, NULL);
for (i = 0; i < n_mem; i++)
gst_buffer_append_memory (buffer, mem[i]);
return TRUE;
mem_error:
{
GST_CAT_ERROR (GST_CAT_DEFAULT, "Failed to create EGLImage");
for (i = 0; i < 3; i++) {
if (client_buffer_tex[i])
gst_gl_context_del_texture (ctx, (GLuint *) & client_buffer_tex[i]);
if (mem[i])
gst_memory_unref (mem[i]);
}
return FALSE;
}
}
