| /* |
| * GStreamer |
| * Copyright (C) 2012 Matthew Waters <> |
| * |
| * 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 "gstglbufferpool.h" |
| |
| #include "gstglmemory.h" |
| #include "gstglsyncmeta.h" |
| #include "gstglutils.h" |
| |
| /** |
| * SECTION:gstglbufferpool |
| * @title: GstGLBufferPool |
| * @short_description: buffer pool for #GstGLBaseMemory objects |
| * @see_also: #GstBufferPool, #GstGLBaseMemory, #GstGLMemory |
| * |
| * a #GstGLBufferPool is an object that allocates buffers with #GstGLBaseMemory |
| * |
| * A #GstGLBufferPool is created with gst_gl_buffer_pool_new() |
| * |
| * #GstGLBufferPool implements the VideoMeta buffer pool option |
| * %GST_BUFFER_POOL_OPTION_VIDEO_META, the VideoAligment buffer pool option |
| * %GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT as well as the OpenGL specific |
| * %GST_BUFFER_POOL_OPTION_GL_SYNC_META buffer pool option. |
| */ |
| |
| /* bufferpool */ |
| struct _GstGLBufferPoolPrivate |
| { |
| GstAllocator *allocator; |
| GstGLVideoAllocationParams *gl_params; |
| GstCaps *caps; |
| gboolean add_videometa; |
| gboolean add_glsyncmeta; |
| }; |
| |
| static void gst_gl_buffer_pool_finalize (GObject * object); |
| |
| GST_DEBUG_CATEGORY_STATIC (GST_CAT_GL_BUFFER_POOL); |
| #define GST_CAT_DEFAULT GST_CAT_GL_BUFFER_POOL |
| |
| #define GST_GL_BUFFER_POOL_GET_PRIVATE(obj) \ |
| (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_GL_BUFFER_POOL, GstGLBufferPoolPrivate)) |
| |
| #define gst_gl_buffer_pool_parent_class parent_class |
| G_DEFINE_TYPE_WITH_CODE (GstGLBufferPool, gst_gl_buffer_pool, |
| GST_TYPE_BUFFER_POOL, GST_DEBUG_CATEGORY_INIT (GST_CAT_GL_BUFFER_POOL, |
| "glbufferpool", 0, "GL Buffer Pool")); |
| |
| static const gchar ** |
| gst_gl_buffer_pool_get_options (GstBufferPool * pool) |
| { |
| static const gchar *options[] = { GST_BUFFER_POOL_OPTION_VIDEO_META, |
| GST_BUFFER_POOL_OPTION_GL_SYNC_META, |
| GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT, |
| GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_2D, |
| GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_RECTANGLE, |
| NULL |
| }; |
| |
| return options; |
| } |
| |
| static gboolean |
| gst_gl_buffer_pool_set_config (GstBufferPool * pool, GstStructure * config) |
| { |
| GstGLBufferPool *glpool = GST_GL_BUFFER_POOL_CAST (pool); |
| GstGLBufferPoolPrivate *priv = glpool->priv; |
| GstVideoInfo info; |
| GstCaps *caps = NULL; |
| guint min_buffers, max_buffers; |
| guint max_align, n; |
| GstAllocator *allocator = NULL; |
| GstAllocationParams alloc_params; |
| GstGLTextureTarget tex_target; |
| gboolean ret = TRUE; |
| gint p; |
| |
| if (!gst_buffer_pool_config_get_params (config, &caps, NULL, &min_buffers, |
| &max_buffers)) |
| goto wrong_config; |
| |
| if (caps == NULL) |
| goto no_caps; |
| |
| /* now parse the caps from the config */ |
| if (!gst_video_info_from_caps (&info, caps)) |
| goto wrong_caps; |
| |
| GST_LOG_OBJECT (pool, "%dx%d, caps %" GST_PTR_FORMAT, info.width, info.height, |
| caps); |
| |
| if (!gst_buffer_pool_config_get_allocator (config, &allocator, &alloc_params)) |
| goto wrong_config; |
| |
| gst_caps_replace (&priv->caps, caps); |
| |
| if (priv->allocator) |
| gst_object_unref (priv->allocator); |
| |
| if (allocator) { |
| if (!GST_IS_GL_MEMORY_ALLOCATOR (allocator)) { |
| gst_object_unref (allocator); |
| goto wrong_allocator; |
| } else { |
| priv->allocator = gst_object_ref (allocator); |
| } |
| } else { |
| priv->allocator = |
| GST_ALLOCATOR (gst_gl_memory_allocator_get_default (glpool->context)); |
| g_assert (priv->allocator); |
| } |
| |
| priv->add_videometa = gst_buffer_pool_config_has_option (config, |
| GST_BUFFER_POOL_OPTION_VIDEO_META); |
| priv->add_glsyncmeta = gst_buffer_pool_config_has_option (config, |
| GST_BUFFER_POOL_OPTION_GL_SYNC_META); |
| |
| if (priv->gl_params) |
| gst_gl_allocation_params_free ((GstGLAllocationParams *) priv->gl_params); |
| priv->gl_params = (GstGLVideoAllocationParams *) |
| gst_buffer_pool_config_get_gl_allocation_params (config); |
| if (!priv->gl_params) |
| priv->gl_params = gst_gl_video_allocation_params_new (glpool->context, |
| &alloc_params, &info, -1, NULL, 0, 0); |
| |
| max_align = alloc_params.align; |
| |
| if (gst_buffer_pool_config_has_option (config, |
| GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT)) { |
| priv->add_videometa = TRUE; |
| |
| gst_buffer_pool_config_get_video_alignment (config, |
| priv->gl_params->valign); |
| |
| for (n = 0; n < GST_VIDEO_MAX_PLANES; ++n) |
| max_align |= priv->gl_params->valign->stride_align[n]; |
| |
| for (n = 0; n < GST_VIDEO_MAX_PLANES; ++n) |
| priv->gl_params->valign->stride_align[n] = max_align; |
| |
| gst_video_info_align (priv->gl_params->v_info, priv->gl_params->valign); |
| |
| gst_buffer_pool_config_set_video_alignment (config, |
| priv->gl_params->valign); |
| } |
| |
| if (alloc_params.align < max_align) { |
| GST_WARNING_OBJECT (pool, "allocation params alignment %u is smaller " |
| "than the max specified video stride alignment %u, fixing", |
| (guint) alloc_params.align, max_align); |
| |
| alloc_params.align = max_align; |
| gst_buffer_pool_config_set_allocator (config, allocator, &alloc_params); |
| if (priv->gl_params->parent.alloc_params) |
| gst_allocation_params_free (priv->gl_params->parent.alloc_params); |
| priv->gl_params->parent.alloc_params = |
| gst_allocation_params_copy (&alloc_params); |
| } |
| |
| { |
| GstStructure *s = gst_caps_get_structure (caps, 0); |
| const gchar *target_str = gst_structure_get_string (s, "texture-target"); |
| gboolean multiple_texture_targets = FALSE; |
| |
| tex_target = priv->gl_params->target; |
| if (target_str) |
| tex_target = gst_gl_texture_target_from_string (target_str); |
| |
| if (gst_buffer_pool_config_has_option (config, |
| GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_2D)) { |
| if (tex_target && tex_target != GST_GL_TEXTURE_TARGET_2D) |
| multiple_texture_targets = TRUE; |
| tex_target = GST_GL_TEXTURE_TARGET_2D; |
| } |
| if (gst_buffer_pool_config_has_option (config, |
| GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_RECTANGLE)) { |
| if (tex_target && tex_target != GST_GL_TEXTURE_TARGET_RECTANGLE) |
| multiple_texture_targets = TRUE; |
| tex_target = GST_GL_TEXTURE_TARGET_RECTANGLE; |
| } |
| if (gst_buffer_pool_config_has_option (config, |
| GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_EXTERNAL_OES)) { |
| if (tex_target && tex_target != GST_GL_TEXTURE_TARGET_EXTERNAL_OES) |
| multiple_texture_targets = TRUE; |
| tex_target = GST_GL_TEXTURE_TARGET_EXTERNAL_OES; |
| } |
| |
| if (!tex_target) |
| tex_target = GST_GL_TEXTURE_TARGET_2D; |
| |
| if (multiple_texture_targets) { |
| GST_WARNING_OBJECT (pool, "Multiple texture targets configured either " |
| "through caps or buffer pool options"); |
| ret = FALSE; |
| } |
| |
| priv->gl_params->target = tex_target; |
| } |
| |
| /* Recalulate the size and offset as we don't add padding between planes. */ |
| priv->gl_params->v_info->size = 0; |
| for (p = 0; p < GST_VIDEO_INFO_N_PLANES (priv->gl_params->v_info); p++) { |
| priv->gl_params->v_info->offset[p] = priv->gl_params->v_info->size; |
| priv->gl_params->v_info->size += |
| gst_gl_get_plane_data_size (priv->gl_params->v_info, |
| priv->gl_params->valign, p); |
| } |
| |
| gst_buffer_pool_config_set_params (config, caps, |
| priv->gl_params->v_info->size, min_buffers, max_buffers); |
| |
| return GST_BUFFER_POOL_CLASS (parent_class)->set_config (pool, config) && ret; |
| |
| /* ERRORS */ |
| wrong_config: |
| { |
| GST_WARNING_OBJECT (pool, "invalid config"); |
| return FALSE; |
| } |
| no_caps: |
| { |
| GST_WARNING_OBJECT (pool, "no caps in config"); |
| return FALSE; |
| } |
| wrong_caps: |
| { |
| GST_WARNING_OBJECT (pool, |
| "failed getting geometry from caps %" GST_PTR_FORMAT, caps); |
| return FALSE; |
| } |
| wrong_allocator: |
| { |
| GST_WARNING_OBJECT (pool, "Incorrect allocator type for this pool"); |
| return FALSE; |
| } |
| } |
| |
| static gboolean |
| gst_gl_buffer_pool_start (GstBufferPool * pool) |
| { |
| return GST_BUFFER_POOL_CLASS (parent_class)->start (pool); |
| } |
| |
| /* This function handles GstBuffer creation */ |
| static GstFlowReturn |
| gst_gl_buffer_pool_alloc (GstBufferPool * pool, GstBuffer ** buffer, |
| GstBufferPoolAcquireParams * params) |
| { |
| GstGLMemoryAllocator *alloc; |
| GstGLBufferPool *glpool = GST_GL_BUFFER_POOL_CAST (pool); |
| GstGLBufferPoolPrivate *priv = glpool->priv; |
| GstBuffer *buf; |
| |
| if (!(buf = gst_buffer_new ())) { |
| goto no_buffer; |
| } |
| |
| alloc = GST_GL_MEMORY_ALLOCATOR (priv->allocator); |
| if (!gst_gl_memory_setup_buffer (alloc, buf, priv->gl_params, NULL, NULL, 0)) |
| goto mem_create_failed; |
| |
| if (priv->add_glsyncmeta) |
| gst_buffer_add_gl_sync_meta (glpool->context, buf); |
| |
| *buffer = buf; |
| |
| return GST_FLOW_OK; |
| |
| /* ERROR */ |
| no_buffer: |
| { |
| GST_WARNING_OBJECT (pool, "can't create image"); |
| return GST_FLOW_ERROR; |
| } |
| mem_create_failed: |
| { |
| GST_WARNING_OBJECT (pool, "Could not create GL Memory"); |
| return GST_FLOW_ERROR; |
| } |
| } |
| |
| /** |
| * gst_gl_buffer_pool_new: |
| * @context: the #GstGLContext to use |
| * |
| * Returns: a #GstBufferPool that allocates buffers with #GstGLMemory |
| */ |
| GstBufferPool * |
| gst_gl_buffer_pool_new (GstGLContext * context) |
| { |
| GstGLBufferPool *pool; |
| |
| pool = g_object_new (GST_TYPE_GL_BUFFER_POOL, NULL); |
| gst_object_ref_sink (pool); |
| pool->context = gst_object_ref (context); |
| |
| GST_LOG_OBJECT (pool, "new GL buffer pool for context %" GST_PTR_FORMAT, |
| context); |
| |
| return GST_BUFFER_POOL_CAST (pool); |
| } |
| |
| static void |
| gst_gl_buffer_pool_class_init (GstGLBufferPoolClass * klass) |
| { |
| GObjectClass *gobject_class = (GObjectClass *) klass; |
| GstBufferPoolClass *gstbufferpool_class = (GstBufferPoolClass *) klass; |
| |
| g_type_class_add_private (klass, sizeof (GstGLBufferPoolPrivate)); |
| |
| gobject_class->finalize = gst_gl_buffer_pool_finalize; |
| |
| gstbufferpool_class->get_options = gst_gl_buffer_pool_get_options; |
| gstbufferpool_class->set_config = gst_gl_buffer_pool_set_config; |
| gstbufferpool_class->alloc_buffer = gst_gl_buffer_pool_alloc; |
| gstbufferpool_class->start = gst_gl_buffer_pool_start; |
| } |
| |
| static void |
| gst_gl_buffer_pool_init (GstGLBufferPool * pool) |
| { |
| GstGLBufferPoolPrivate *priv = NULL; |
| |
| pool->priv = GST_GL_BUFFER_POOL_GET_PRIVATE (pool); |
| priv = pool->priv; |
| |
| priv->allocator = NULL; |
| priv->caps = NULL; |
| priv->add_videometa = TRUE; |
| priv->add_glsyncmeta = FALSE; |
| } |
| |
| static void |
| gst_gl_buffer_pool_finalize (GObject * object) |
| { |
| GstGLBufferPool *pool = GST_GL_BUFFER_POOL_CAST (object); |
| GstGLBufferPoolPrivate *priv = pool->priv; |
| |
| GST_LOG_OBJECT (pool, "finalize GL buffer pool %p", pool); |
| |
| if (priv->caps) |
| gst_caps_unref (priv->caps); |
| |
| G_OBJECT_CLASS (gst_gl_buffer_pool_parent_class)->finalize (object); |
| |
| /* only release the context once all our memory have been deleted */ |
| if (pool->context) { |
| gst_object_unref (pool->context); |
| pool->context = NULL; |
| } |
| |
| if (priv->allocator) { |
| gst_object_unref (priv->allocator); |
| priv->allocator = NULL; |
| } |
| |
| if (priv->gl_params) |
| gst_gl_allocation_params_free ((GstGLAllocationParams *) priv->gl_params); |
| priv->gl_params = NULL; |
| } |
| |
| /** |
| * gst_buffer_pool_config_get_gl_allocation_params: |
| * @config: a buffer pool config |
| * |
| * Returns: (transfer full): the currently set #GstGLAllocationParams or %NULL |
| */ |
| GstGLAllocationParams * |
| gst_buffer_pool_config_get_gl_allocation_params (GstStructure * config) |
| { |
| GstGLAllocationParams *ret; |
| |
| if (!gst_structure_get (config, "gl-allocation-params", |
| GST_TYPE_GL_ALLOCATION_PARAMS, &ret, NULL)) |
| ret = NULL; |
| |
| return ret; |
| } |
| |
| /** |
| * gst_buffer_pool_config_set_gl_allocation_params: |
| * @config: a buffer pool config |
| * @params: (transfer none): a #GstGLAllocationParams |
| * |
| * Sets @params on @config |
| */ |
| void |
| gst_buffer_pool_config_set_gl_allocation_params (GstStructure * config, |
| GstGLAllocationParams * params) |
| { |
| g_return_if_fail (config != NULL); |
| g_return_if_fail (params != NULL); |
| |
| gst_structure_set (config, "gl-allocation-params", |
| GST_TYPE_GL_ALLOCATION_PARAMS, params, NULL); |
| } |