GstAllocator* gst_fsl_vpu_dec_allocator_obtain(void)
{
static GOnce dmabuf_allocator_once = G_ONCE_INIT;
GstAllocator *allocator;
g_once(&dmabuf_allocator_once, (GThreadFunc)gst_fsl_vpu_dec_mem_init, NULL);
allocator = gst_allocator_find(GST_FSL_VPU_DEC_ALLOCATOR_MEM_TYPE);
if (allocator == NULL)
GST_WARNING("No allocator named %s found", GST_FSL_VPU_DEC_ALLOCATOR_MEM_TYPE);
return allocator;
}
/**
* gst_dmabuf_allocator_obtain:
*
* Return a dmabuf allocator.
*
* Returns: (transfer full): a dmabuf allocator, or NULL if the allocator
* isn't available. Use gst_object_unref() to release the allocator after
* usage
*
* Since: 1.2
*/
GstAllocator *
gst_dmabuf_allocator_obtain (void)
{
static GOnce dmabuf_allocator_once = G_ONCE_INIT;
GstAllocator *allocator;
g_once (&dmabuf_allocator_once, (GThreadFunc) gst_dmabuf_mem_init, NULL);
allocator = gst_allocator_find (ALLOCATOR_NAME);
if (!allocator)
GST_WARNING ("No allocator named %s found", ALLOCATOR_NAME);
return allocator;
}
void AllocatorTest::testAllocator()
{
GstAllocator *g_system = gst_allocator_find("SystemMemory");
QGst::AllocatorPtr system(QGst::Allocator::getSystemMemory());
QVERIFY(system);
QCOMPARE(g_system, static_cast<GstAllocator *>(system));
QGst::AllocationParams params;
params.setFlags(QGst::MemoryFlagNotMappable);
QGst::MemoryPtr mem = system->alloc(100, params);
QVERIFY(mem);
QCOMPARE(mem->size(), static_cast<size_t>(100));
system->free(mem);
}
static GstBuffer *
gst_core_media_buffer_new_from_buffer (GstBuffer * buf, GstVideoInfo * info)
{
gboolean ret;
GstBuffer *copy_buf;
GstVideoFrame dest, src;
GstAllocator *allocator;
allocator = gst_allocator_find (GST_ALLOCATOR_SYSMEM);
if (!allocator) {
GST_ERROR ("Could not find SYSMEM allocator");
return NULL;
}
copy_buf = gst_buffer_new_allocate (allocator, info->size, NULL);
gst_object_unref (allocator);
if (!gst_video_frame_map (&dest, info, copy_buf, GST_MAP_WRITE)) {
GST_ERROR ("Could not map destination frame");
goto error;
}
if (!gst_video_frame_map (&src, info, buf, GST_MAP_READ)) {
GST_ERROR ("Could not map source frame");
gst_video_frame_unmap (&dest);
goto error;
}
ret = gst_video_frame_copy (&dest, &src);
gst_video_frame_unmap (&dest);
gst_video_frame_unmap (&src);
if (!ret) {
GST_ERROR ("Could not copy frame");
goto error;
}
return copy_buf;
error:
if (copy_buf) {
gst_buffer_unref (copy_buf);
}
return NULL;
}
static gboolean
_gl_mem_create (GstGLMemoryPBO * gl_mem, GError ** error)
{
GstGLContext *context = gl_mem->mem.mem.context;
GstGLBaseMemoryAllocatorClass *alloc_class;
alloc_class = GST_GL_BASE_MEMORY_ALLOCATOR_CLASS (parent_class);
if (!alloc_class->create ((GstGLBaseMemory *) gl_mem, error))
return FALSE;
if (CONTEXT_SUPPORTS_PBO_DOWNLOAD (context)
|| CONTEXT_SUPPORTS_PBO_UPLOAD (context)) {
GstAllocationParams alloc_params =
{ 0, GST_MEMORY_CAST (gl_mem)->align, 0, 0 };
GstGLBaseMemoryAllocator *buf_allocator;
GstGLBufferAllocationParams *params;
buf_allocator =
GST_GL_BASE_MEMORY_ALLOCATOR (gst_allocator_find
(GST_GL_BUFFER_ALLOCATOR_NAME));
params =
gst_gl_buffer_allocation_params_new (context,
GST_MEMORY_CAST (gl_mem)->size, &alloc_params, GL_PIXEL_UNPACK_BUFFER,
GL_STREAM_DRAW);
/* FIXME: lazy init this for resource constrained platforms
* Will need to fix pbo detection based on the existence of the mem.id then */
gl_mem->pbo = (GstGLBuffer *) gst_gl_base_memory_alloc (buf_allocator,
(GstGLAllocationParams *) params);
gst_gl_allocation_params_free ((GstGLAllocationParams *) params);
gst_object_unref (buf_allocator);
GST_CAT_LOG (GST_CAT_GL_MEMORY, "generated pbo %u", gl_mem->pbo->id);
}
return TRUE;
}
/**
* gst_ts_cache_new:
* @size: cache size
*
* Create a new cache instance. @size will be rounded up to the
* nearest CACHE_SLOT_SIZE multiple and used as the ringbuffer size.
*
* Returns: a new #GstTSCache
*
*/
GstTSCache *
gst_ts_cache_new (gsize size, const gchar * allocator_name)
{
GstTSCache *cache;
guint nslots;
int i;
cache = g_new (GstTSCache, 1);
cache->refcount = 1;
g_mutex_init (&cache->lock);
cache->h_offset = 0;
cache->l_rb_offset = 0;
cache->h_rb_offset = 0;
/* Ring buffer */
cache->alloc = gst_allocator_find (allocator_name);
g_return_val_if_fail (cache->alloc, NULL);
nslots = size / CACHE_SLOT_SIZE;
cache->nslots = nslots;
cache->slots = (Slot *) g_new (Slot, nslots);
for (i = 0; i < cache->nslots; i++) {
GstBuffer *buf =
gst_buffer_new_allocate (cache->alloc, CACHE_SLOT_SIZE, NULL);
g_return_val_if_fail (buf, NULL);
cache->slots[i].buffer = buf;
}
gst_ts_cache_flush (cache);
return cache;
}
static void
test_transfer_allocator (const gchar * allocator_name)
{
GstAllocator *gl_allocator;
GstGLBaseMemoryAllocator *base_mem_alloc;
GstVideoInfo v_info;
GstMemory *mem, *mem2, *mem3;
GstMapInfo map_info;
GstGLVideoAllocationParams *params;
gl_allocator = gst_allocator_find (allocator_name);
fail_if (gl_allocator == NULL);
base_mem_alloc = GST_GL_BASE_MEMORY_ALLOCATOR (gl_allocator);
gst_video_info_set_format (&v_info, GST_VIDEO_FORMAT_RGBA, 1, 1);
params = gst_gl_video_allocation_params_new (context, NULL, &v_info, 0,
NULL, GST_GL_TEXTURE_TARGET_2D, GST_VIDEO_GL_TEXTURE_TYPE_RGBA);
/* texture creation */
mem = (GstMemory *) gst_gl_base_memory_alloc (base_mem_alloc,
(GstGLAllocationParams *) params);
gst_gl_allocation_params_free ((GstGLAllocationParams *) params);
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem,
GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD));
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem,
GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD));
/* test wrapping raw data */
params = gst_gl_video_allocation_params_new_wrapped_data (context, NULL,
&v_info, 0, NULL, GST_GL_TEXTURE_TARGET_2D,
GST_VIDEO_GL_TEXTURE_TYPE_RGBA, rgba_pixel, NULL, NULL);
mem2 =
(GstMemory *) gst_gl_base_memory_alloc (base_mem_alloc,
(GstGLAllocationParams *) params);
gst_gl_allocation_params_free ((GstGLAllocationParams *) params);
fail_if (mem == NULL);
fail_unless (GST_MEMORY_FLAG_IS_SET (mem2,
GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD));
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem2,
GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD));
/* wrapped texture creation */
params = gst_gl_video_allocation_params_new_wrapped_texture (context, NULL,
&v_info, 0, NULL, GST_GL_TEXTURE_TARGET_2D,
GST_VIDEO_GL_TEXTURE_TYPE_RGBA, ((GstGLMemory *) mem)->tex_id, NULL,
NULL);
mem3 =
(GstMemory *) gst_gl_base_memory_alloc (base_mem_alloc,
(GstGLAllocationParams *) params);
gst_gl_allocation_params_free ((GstGLAllocationParams *) params);
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem3,
GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD));
fail_unless (GST_MEMORY_FLAG_IS_SET (mem3,
GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD));
/* check data/flags are correct */
fail_unless (gst_memory_map (mem2, &map_info, GST_MAP_READ));
fail_unless (GST_MEMORY_FLAG_IS_SET (mem2,
GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD));
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem2,
GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD));
fail_unless (memcmp (map_info.data, rgba_pixel,
G_N_ELEMENTS (rgba_pixel)) == 0,
"0x%02x%02x%02x%02x != 0x%02x%02x%02x%02x", map_info.data[0],
map_info.data[1], map_info.data[2], map_info.data[3],
(guint8) rgba_pixel[0], (guint8) rgba_pixel[1], (guint8) rgba_pixel[2],
(guint8) rgba_pixel[3]);
gst_memory_unmap (mem2, &map_info);
fail_unless (GST_MEMORY_FLAG_IS_SET (mem2,
GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD));
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem2,
GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD));
fail_unless (gst_memory_map (mem2, &map_info, GST_MAP_READ | GST_MAP_GL));
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem2,
GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD));
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem2,
GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD));
/* test texture copy */
fail_unless (gst_gl_memory_copy_into ((GstGLMemory *) mem2,
((GstGLMemory *) mem)->tex_id, GST_GL_TEXTURE_TARGET_2D,
GST_VIDEO_GL_TEXTURE_TYPE_RGBA, 1, 1));
GST_MINI_OBJECT_FLAG_SET (mem, GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD);
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem2,
GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD));
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem2,
GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD));
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem,
GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD));
fail_unless (GST_MEMORY_FLAG_IS_SET (mem,
GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD));
gst_memory_unmap (mem2, &map_info);
/* test download of copied texture */
fail_unless (gst_memory_map (mem, &map_info, GST_MAP_READ));
fail_unless (memcmp (map_info.data, rgba_pixel,
G_N_ELEMENTS (rgba_pixel)) == 0,
"0x%02x%02x%02x%02x != 0x%02x%02x%02x%02x", (guint8) map_info.data[0],
(guint8) map_info.data[1], (guint8) map_info.data[2],
(guint8) map_info.data[3], (guint8) rgba_pixel[0], (guint8) rgba_pixel[1],
(guint8) rgba_pixel[2], (guint8) rgba_pixel[3]);
gst_memory_unmap (mem, &map_info);
/* test download of wrapped copied texture */
fail_unless (gst_memory_map (mem3, &map_info, GST_MAP_READ));
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem,
GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD));
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem,
GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD));
fail_unless (memcmp (map_info.data, rgba_pixel,
G_N_ELEMENTS (rgba_pixel)) == 0,
"0x%02x%02x%02x%02x != 0x%02x%02x%02x%02x", (guint8) map_info.data[0],
(guint8) map_info.data[1], (guint8) map_info.data[2],
(guint8) map_info.data[3], (guint8) rgba_pixel[0], (guint8) rgba_pixel[1],
(guint8) rgba_pixel[2], (guint8) rgba_pixel[3]);
gst_memory_unmap (mem3, &map_info);
/* test upload flag */
fail_unless (gst_memory_map (mem3, &map_info, GST_MAP_WRITE));
gst_memory_unmap (mem3, &map_info);
fail_unless (GST_MEMORY_FLAG_IS_SET (mem3,
GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD));
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem3,
GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD));
/* test download flag */
fail_unless (gst_memory_map (mem3, &map_info, GST_MAP_WRITE | GST_MAP_GL));
gst_memory_unmap (mem3, &map_info);
fail_unless (!GST_MEMORY_FLAG_IS_SET (mem3,
GST_GL_BASE_MEMORY_TRANSFER_NEED_UPLOAD));
fail_unless (GST_MEMORY_FLAG_IS_SET (mem3,
GST_GL_BASE_MEMORY_TRANSFER_NEED_DOWNLOAD));
gst_memory_unref (mem);
gst_memory_unref (mem2);
gst_memory_unref (mem3);
gst_object_unref (gl_allocator);
}
static GstPadProbeReturn
query_cb (GstPad * pad, GstPadProbeInfo * info, gpointer user_data)
{
APP_STATE_T *state = (APP_STATE_T *) user_data;
GstQuery *query = GST_PAD_PROBE_INFO_QUERY (info);
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_ALLOCATION:{
GstBufferPool *pool;
GstStructure *config;
GstCaps *caps;
GstVideoInfo info;
gboolean need_pool;
guint size;
GstAllocator *allocator;
GstAllocationParams params;
gst_allocation_params_init (¶ms);
gst_query_parse_allocation (query, &caps, &need_pool);
if (!caps) {
GST_ERROR ("allocation query without caps");
return GST_PAD_PROBE_OK;
}
if (!gst_video_info_from_caps (&info, caps)) {
GST_ERROR ("allocation query with invalid caps");
return GST_PAD_PROBE_OK;
}
g_mutex_lock (state->queue_lock);
pool = state->pool ? gst_object_ref (state->pool) : NULL;
g_mutex_unlock (state->queue_lock);
if (pool) {
GstCaps *pcaps;
/* we had a pool, check caps */
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_get_params (config, &pcaps, &size, NULL, NULL);
GST_DEBUG ("check existing pool caps %" GST_PTR_FORMAT
" with new caps %" GST_PTR_FORMAT, pcaps, caps);
if (!gst_caps_is_equal (caps, pcaps)) {
GST_DEBUG ("pool has different caps");
/* different caps, we can't use this pool */
gst_object_unref (pool);
pool = NULL;
}
gst_structure_free (config);
}
GST_DEBUG ("pool %p", pool);
if (pool == NULL && need_pool) {
GstVideoInfo info;
if (!gst_video_info_from_caps (&info, caps)) {
GST_ERROR ("allocation query has invalid caps %"
GST_PTR_FORMAT, caps);
return GST_PAD_PROBE_OK;
}
GST_DEBUG ("create new pool");
state->pool = pool =
gst_egl_image_buffer_pool_new (state, state->display);
GST_DEBUG ("done create new pool %p", pool);
/* the normal size of a frame */
size = info.size;
config = gst_buffer_pool_get_config (pool);
/* we need at least 2 buffer because we hold on to the last one */
gst_buffer_pool_config_set_params (config, caps, size, 2, 0);
gst_buffer_pool_config_set_allocator (config, NULL, ¶ms);
if (!gst_buffer_pool_set_config (pool, config)) {
gst_object_unref (pool);
GST_ERROR ("failed to set pool configuration");
return GST_PAD_PROBE_OK;
}
}
if (pool) {
/* we need at least 2 buffer because we hold on to the last one */
gst_query_add_allocation_pool (query, pool, size, 2, 0);
gst_object_unref (pool);
}
/* First the default allocator */
if (!gst_egl_image_memory_is_mappable ()) {
allocator = gst_allocator_find (NULL);
gst_query_add_allocation_param (query, allocator, ¶ms);
gst_object_unref (allocator);
}
allocator = gst_egl_image_allocator_obtain ();
GST_WARNING ("Allocator obtained %p", allocator);
if (!gst_egl_image_memory_is_mappable ())
params.flags |= GST_MEMORY_FLAG_NOT_MAPPABLE;
gst_query_add_allocation_param (query, allocator, ¶ms);
gst_object_unref (allocator);
gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
gst_query_add_allocation_meta (query, GST_VIDEO_CROP_META_API_TYPE, NULL);
gst_query_add_allocation_meta (query,
GST_VIDEO_GL_TEXTURE_UPLOAD_META_API_TYPE, NULL);
GST_DEBUG ("done alocation");
return GST_PAD_PROBE_OK;
}
break;
default:
break;
}
return GST_PAD_PROBE_OK;
}
static gboolean
gst_gl_mixer_propose_allocation (GstGLMixer * mix,
GstQuery * decide_query, GstQuery * query)
{
GstBufferPool *pool;
GstStructure *config;
GstCaps *caps;
guint size = 0;
gboolean need_pool;
GError *error = NULL;
GstStructure *gl_context;
gchar *platform, *gl_apis;
gpointer handle;
GstAllocator *allocator = NULL;
GstAllocationParams params;
gst_query_parse_allocation (query, &caps, &need_pool);
if (caps == NULL)
goto no_caps;
if ((pool = mix->priv->pool))
gst_object_ref (pool);
if (pool != NULL) {
GstCaps *pcaps;
/* we had a pool, check caps */
GST_DEBUG_OBJECT (mix, "check existing pool caps");
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_get_params (config, &pcaps, &size, NULL, NULL);
if (!gst_caps_is_equal (caps, pcaps)) {
GST_DEBUG_OBJECT (mix, "pool has different caps");
/* different caps, we can't use this pool */
gst_object_unref (pool);
pool = NULL;
}
gst_structure_free (config);
}
if (!gst_gl_ensure_display (mix, &mix->display))
return FALSE;
if (!mix->context) {
mix->context = gst_gl_context_new (mix->display);
if (!gst_gl_context_create (mix->context, NULL, &error))
goto context_error;
}
if (pool == NULL && need_pool) {
GstVideoInfo info;
if (!gst_video_info_from_caps (&info, caps))
goto invalid_caps;
GST_DEBUG_OBJECT (mix, "create new pool");
pool = gst_gl_buffer_pool_new (mix->context);
/* the normal size of a frame */
size = info.size;
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, 0, 0);
if (!gst_buffer_pool_set_config (pool, config))
goto config_failed;
}
if (pool) {
gst_query_add_allocation_pool (query, pool, size, 1, 0);
gst_object_unref (pool);
}
/* we also support various metadata */
gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, 0);
gl_apis = gst_gl_api_to_string (gst_gl_context_get_gl_api (mix->context));
platform =
gst_gl_platform_to_string (gst_gl_context_get_gl_platform (mix->context));
handle = (gpointer) gst_gl_context_get_gl_context (mix->context);
gl_context =
gst_structure_new ("GstVideoGLTextureUploadMeta", "gst.gl.GstGLContext",
GST_GL_TYPE_CONTEXT, mix->context, "gst.gl.context.handle",
G_TYPE_POINTER, handle, "gst.gl.context.type", G_TYPE_STRING, platform,
"gst.gl.context.apis", G_TYPE_STRING, gl_apis, NULL);
gst_query_add_allocation_meta (query,
GST_VIDEO_GL_TEXTURE_UPLOAD_META_API_TYPE, gl_context);
g_free (gl_apis);
g_free (platform);
gst_structure_free (gl_context);
gst_allocation_params_init (¶ms);
allocator = gst_allocator_find (GST_GL_MEMORY_ALLOCATOR);
gst_query_add_allocation_param (query, allocator, ¶ms);
gst_object_unref (allocator);
return TRUE;
/* ERRORS */
no_caps:
{
GST_DEBUG_OBJECT (mix, "no caps specified");
return FALSE;
}
invalid_caps:
{
GST_DEBUG_OBJECT (mix, "invalid caps specified");
return FALSE;
}
config_failed:
{
GST_DEBUG_OBJECT (mix, "failed setting config");
return FALSE;
}
context_error:
{
GST_ELEMENT_ERROR (mix, RESOURCE, NOT_FOUND, ("%s", error->message),
(NULL));
return FALSE;
}
}
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;
GstAllocator *allocator = NULL;
GstAllocationParams alloc_params;
gboolean reset = 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;
if (priv->allocator)
gst_object_unref (priv->allocator);
if (!allocator) {
gst_gl_memory_init ();
priv->allocator = gst_allocator_find (GST_GL_MEMORY_ALLOCATOR);
} else {
priv->allocator = gst_object_ref (allocator);
}
priv->params = alloc_params;
priv->im_format = GST_VIDEO_INFO_FORMAT (&info);
if (priv->im_format == -1)
goto unknown_format;
if (priv->caps)
reset = !gst_caps_is_equal (priv->caps, caps);
gst_caps_replace (&priv->caps, caps);
priv->info = info;
priv->add_videometa = gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_META);
priv->add_uploadmeta = gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META);
priv->add_glsyncmeta = gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_GL_SYNC_META);
#if GST_GL_HAVE_PLATFORM_EGL
g_assert (priv->allocator != NULL);
priv->want_eglimage =
(g_strcmp0 (priv->allocator->mem_type, GST_EGL_IMAGE_MEMORY_TYPE) == 0);
#else
priv->want_eglimage = FALSE;
#endif
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->valign);
gst_video_info_align (&priv->info, &priv->valign);
gst_buffer_pool_config_set_video_alignment (config, &priv->valign);
} else {
gst_video_alignment_reset (&priv->valign);
}
if (reset) {
if (glpool->upload)
gst_object_unref (glpool->upload);
glpool->upload = gst_gl_upload_meta_new (glpool->context);
}
/* Recalulate the size as we don't add padding between planes. */
priv->info.size = 0;
for (p = 0; p < GST_VIDEO_INFO_N_PLANES (&priv->info); p++) {
priv->info.size +=
gst_gl_get_plane_data_size (&priv->info, &priv->valign, p);
}
gst_buffer_pool_config_set_params (config, caps, priv->info.size,
min_buffers, max_buffers);
return GST_BUFFER_POOL_CLASS (parent_class)->set_config (pool, config);
/* 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;
}
unknown_format:
{
GST_WARNING_OBJECT (glpool, "failed to get format from caps %"
GST_PTR_FORMAT, caps);
GST_ELEMENT_ERROR (glpool, RESOURCE, WRITE,
("Failed to create output image buffer of %dx%d pixels",
priv->info.width, priv->info.height),
("Invalid input caps %" GST_PTR_FORMAT, caps));
return FALSE;
}
}
static gboolean
gst_mir_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
{
GstMirSink *sink = GST_MIR_SINK (bsink);
GstBufferPool *pool;
GstStructure *config;
GstCaps *caps;
guint size = 0;
gboolean need_pool;
GstAllocator *allocator;
GstAllocationParams params;
GST_DEBUG_OBJECT (sink, "Proposing ALLOCATION params");
gst_allocation_params_init (¶ms);
gst_query_parse_allocation (query, &caps, &need_pool);
if (!caps)
goto no_caps;
GST_OBJECT_LOCK (sink);
pool = sink->pool ? gst_object_ref (sink->pool) : NULL;
GST_OBJECT_UNLOCK (sink);
GST_DEBUG_OBJECT (sink, "pool: %p, need_pool: %d", pool, need_pool);
if (pool) {
GstCaps *pcaps;
GST_WARNING_OBJECT (sink, "already have a pool");
/* We had a pool, check caps */
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_get_params (config, &pcaps, &size, NULL, NULL);
if (!gst_caps_is_equal (caps, pcaps)) {
/* Different caps, we can't use this pool */
gst_object_unref (pool);
pool = NULL;
}
gst_structure_free (config);
}
if (pool == NULL && need_pool) {
GstVideoInfo info;
info.size = 0;
if (!gst_video_info_from_caps (&info, caps))
goto invalid_caps;
GST_DEBUG_OBJECT (sink, "size: %d", size);
GST_DEBUG_OBJECT (sink, "caps %" GST_PTR_FORMAT, caps);
GST_DEBUG_OBJECT (sink, "create new pool");
pool = gst_mir_buffer_pool_new (sink);
/* The normal size of a frame */
size = (info.size == 0) ? info.height * info.width : info.size;
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, 2, 0);
if (!gst_buffer_pool_set_config (pool, config))
goto config_failed;
}
if (pool) {
/* We are doing hardware rendering */
gst_mir_buffer_pool_set_hardware_rendering (pool, TRUE);
// FIXME: How many buffers min do we need? It's 2 right now.
GST_DEBUG_OBJECT (sink, "size: %d", size);
GST_DEBUG_OBJECT (sink, "adding allocation pool");
gst_query_add_allocation_pool (query, pool, size, 2, 0);
gst_object_unref (pool);
}
/* First the default allocator */
if (!gst_mir_image_memory_is_mappable ()) {
allocator = gst_allocator_find (NULL);
gst_query_add_allocation_param (query, allocator, ¶ms);
gst_object_unref (allocator);
}
allocator = gst_mir_image_allocator_obtain ();
if (!gst_mir_image_memory_is_mappable ())
params.flags |= GST_MEMORY_FLAG_NOT_MAPPABLE;
gst_query_add_allocation_param (query, allocator, ¶ms);
gst_object_unref (allocator);
//gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
return TRUE;
/* ERRORS */
no_caps:
{
GST_DEBUG_OBJECT (bsink, "no caps specified");
return FALSE;
}
invalid_caps:
{
GST_DEBUG_OBJECT (bsink, "invalid caps specified");
return FALSE;
}
config_failed:
{
GST_DEBUG_OBJECT (bsink, "failed setting config");
gst_object_unref (pool);
return FALSE;
}
}
GstAllocator *
gst_wl_shm_allocator_get (void)
{
return gst_allocator_find (GST_ALLOCATOR_WL_SHM);
}
static gboolean
gst_glimage_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
{
GstGLImageSink *glimage_sink = GST_GLIMAGE_SINK (bsink);
GstBufferPool *pool;
GstStructure *config;
GstCaps *caps;
guint size;
gboolean need_pool;
GstStructure *gl_context;
gchar *platform, *gl_apis;
gpointer handle;
GstAllocator *allocator = NULL;
GstAllocationParams params;
if (!_ensure_gl_setup (glimage_sink))
return FALSE;
gst_query_parse_allocation (query, &caps, &need_pool);
if (caps == NULL)
goto no_caps;
if ((pool = glimage_sink->pool))
gst_object_ref (pool);
if (pool != NULL) {
GstCaps *pcaps;
/* we had a pool, check caps */
GST_DEBUG_OBJECT (glimage_sink, "check existing pool caps");
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_get_params (config, &pcaps, &size, NULL, NULL);
if (!gst_caps_is_equal (caps, pcaps)) {
GST_DEBUG_OBJECT (glimage_sink, "pool has different caps");
/* different caps, we can't use this pool */
gst_object_unref (pool);
pool = NULL;
}
gst_structure_free (config);
}
if (pool == NULL && need_pool) {
GstVideoInfo info;
if (!gst_video_info_from_caps (&info, caps))
goto invalid_caps;
GST_DEBUG_OBJECT (glimage_sink, "create new pool");
pool = gst_gl_buffer_pool_new (glimage_sink->context);
/* the normal size of a frame */
size = info.size;
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, 0, 0);
if (!gst_buffer_pool_set_config (pool, config))
goto config_failed;
}
/* we need at least 2 buffer because we hold on to the last one */
if (pool) {
gst_query_add_allocation_pool (query, pool, size, 2, 0);
gst_object_unref (pool);
}
/* we also support various metadata */
gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, 0);
gl_apis =
gst_gl_api_to_string (gst_gl_context_get_gl_api (glimage_sink->context));
platform =
gst_gl_platform_to_string (gst_gl_context_get_gl_platform
(glimage_sink->context));
handle = (gpointer) gst_gl_context_get_gl_context (glimage_sink->context);
gl_context =
gst_structure_new ("GstVideoGLTextureUploadMeta", "gst.gl.GstGLContext",
GST_GL_TYPE_CONTEXT, glimage_sink->context, "gst.gl.context.handle",
G_TYPE_POINTER, handle, "gst.gl.context.type", G_TYPE_STRING, platform,
"gst.gl.context.apis", G_TYPE_STRING, gl_apis, NULL);
gst_query_add_allocation_meta (query,
GST_VIDEO_GL_TEXTURE_UPLOAD_META_API_TYPE, gl_context);
g_free (gl_apis);
g_free (platform);
gst_structure_free (gl_context);
gst_allocation_params_init (¶ms);
allocator = gst_allocator_find (GST_GL_MEMORY_ALLOCATOR);
gst_query_add_allocation_param (query, allocator, ¶ms);
gst_object_unref (allocator);
#if GST_GL_HAVE_PLATFORM_EGL
if (gst_gl_context_check_feature (glimage_sink->context,
"EGL_KHR_image_base")) {
allocator = gst_allocator_find (GST_EGL_IMAGE_MEMORY_TYPE);
gst_query_add_allocation_param (query, allocator, ¶ms);
gst_object_unref (allocator);
}
#endif
return TRUE;
/* ERRORS */
no_caps:
{
GST_DEBUG_OBJECT (bsink, "no caps specified");
return FALSE;
}
invalid_caps:
{
GST_DEBUG_OBJECT (bsink, "invalid caps specified");
return FALSE;
}
config_failed:
{
GST_DEBUG_OBJECT (bsink, "failed setting config");
return FALSE;
}
}
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;
gboolean reset = TRUE, 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;
if (priv->allocator)
gst_object_unref (priv->allocator);
if (!allocator) {
gst_gl_memory_init ();
priv->allocator = gst_allocator_find (GST_GL_MEMORY_ALLOCATOR);
} else {
priv->allocator = gst_object_ref (allocator);
}
priv->params = alloc_params;
priv->im_format = GST_VIDEO_INFO_FORMAT (&info);
if (priv->im_format == -1)
goto unknown_format;
if (priv->caps)
reset = !gst_caps_is_equal (priv->caps, caps);
gst_caps_replace (&priv->caps, caps);
priv->info = info;
priv->add_videometa = gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_META);
priv->add_uploadmeta = gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META);
priv->add_glsyncmeta = gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_GL_SYNC_META);
#if GST_GL_HAVE_PLATFORM_EGL
g_assert (priv->allocator != NULL);
priv->want_eglimage =
(g_strcmp0 (priv->allocator->mem_type, GST_EGL_IMAGE_MEMORY_TYPE) == 0);
#else
priv->want_eglimage = FALSE;
#endif
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->valign);
for (n = 0; n < GST_VIDEO_MAX_PLANES; ++n)
max_align |= priv->valign.stride_align[n];
for (n = 0; n < GST_VIDEO_MAX_PLANES; ++n)
priv->valign.stride_align[n] = max_align;
gst_video_info_align (&priv->info, &priv->valign);
gst_buffer_pool_config_set_video_alignment (config, &priv->valign);
} else {
gst_video_alignment_reset (&priv->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);
priv->params = alloc_params;
}
if (reset) {
if (glpool->upload)
gst_object_unref (glpool->upload);
glpool->upload = gst_gl_upload_meta_new (glpool->context);
}
priv->tex_target = 0;
{
GstStructure *s = gst_caps_get_structure (caps, 0);
const gchar *target_str = gst_structure_get_string (s, "texture-target");
gboolean multiple_texture_targets = FALSE;
if (target_str)
priv->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 (priv->tex_target)
multiple_texture_targets = TRUE;
priv->tex_target = GST_GL_TEXTURE_TARGET_2D;
}
if (gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_GL_TEXTURE_TARGET_RECTANGLE)) {
if (priv->tex_target)
multiple_texture_targets = TRUE;
priv->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 (priv->tex_target)
multiple_texture_targets = TRUE;
priv->tex_target = GST_GL_TEXTURE_TARGET_EXTERNAL_OES;
}
if (!priv->tex_target)
priv->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;
}
}
/* Recalulate the size and offset as we don't add padding between planes. */
priv->info.size = 0;
for (p = 0; p < GST_VIDEO_INFO_N_PLANES (&priv->info); p++) {
priv->info.offset[p] = priv->info.size;
priv->info.size +=
gst_gl_get_plane_data_size (&priv->info, &priv->valign, p);
}
gst_buffer_pool_config_set_params (config, caps, priv->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;
}
unknown_format:
{
GST_WARNING_OBJECT (glpool, "failed to get format from caps %"
GST_PTR_FORMAT, caps);
GST_ELEMENT_ERROR (glpool, RESOURCE, WRITE,
("Failed to create output image buffer of %dx%d pixels",
priv->info.width, priv->info.height),
("Invalid input caps %" GST_PTR_FORMAT, caps));
return FALSE;
}
}
static void
check_conversion (TestFrame * frames, guint size)
{
GstGLBaseMemoryAllocator *base_mem_alloc;
gint i, j, k, l;
gint ref_count = 0;
base_mem_alloc =
GST_GL_BASE_MEMORY_ALLOCATOR (gst_allocator_find
(GST_GL_MEMORY_ALLOCATOR_NAME));
for (i = 0; i < size; i++) {
GstBuffer *inbuf;
GstVideoInfo in_info;
gint in_width = frames[i].width;
gint in_height = frames[i].height;
GstVideoFormat in_v_format = frames[i].v_format;
GstVideoFrame in_frame;
GstCaps *in_caps;
gst_video_info_set_format (&in_info, in_v_format, in_width, in_height);
in_caps = gst_video_info_to_caps (&in_info);
gst_caps_set_features (in_caps, 0,
gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_GL_MEMORY));
/* create GL buffer */
inbuf = gst_buffer_new ();
for (j = 0; j < GST_VIDEO_INFO_N_PLANES (&in_info); j++) {
GstVideoGLTextureType tex_type = gst_gl_texture_type_from_format (context,
GST_VIDEO_INFO_FORMAT (&in_info), j);
GstGLVideoAllocationParams *params;
GstGLBaseMemory *mem;
ref_count++;
params = gst_gl_video_allocation_params_new_wrapped_data (context, NULL,
&in_info, j, NULL, GST_GL_TEXTURE_TARGET_2D, tex_type,
frames[i].data[j], &ref_count, _frame_unref);
mem = gst_gl_base_memory_alloc (base_mem_alloc,
(GstGLAllocationParams *) params);
gst_buffer_append_memory (inbuf, GST_MEMORY_CAST (mem));
gst_gl_allocation_params_free ((GstGLAllocationParams *) params);
}
fail_unless (gst_video_frame_map (&in_frame, &in_info, inbuf,
GST_MAP_READ));
/* sanity check that the correct values were wrapped */
for (j = 0; j < GST_VIDEO_INFO_N_PLANES (&in_info); j++) {
for (k = 0; k < _video_info_plane_size (&in_info, j); k++) {
if (frames[i].data[j][k] != IGNORE_MAGIC)
fail_unless (((gchar *) in_frame.data[j])[k] == frames[i].data[j][k]);
}
}
for (j = 0; j < size; j++) {
GstBuffer *outbuf;
GstVideoInfo out_info;
gint out_width = frames[j].width;
gint out_height = frames[j].height;
GstVideoFormat out_v_format = frames[j].v_format;
gchar *out_data[GST_VIDEO_MAX_PLANES] = { 0 };
GstVideoFrame out_frame;
GstCaps *out_caps;
gst_video_info_set_format (&out_info, out_v_format, out_width,
out_height);
out_caps = gst_video_info_to_caps (&out_info);
gst_caps_set_features (out_caps, 0,
gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_GL_MEMORY));
for (k = 0; k < GST_VIDEO_INFO_N_PLANES (&out_info); k++) {
out_data[k] = frames[j].data[k];
}
gst_gl_color_convert_set_caps (convert, in_caps, out_caps);
/* convert the data */
outbuf = gst_gl_color_convert_perform (convert, inbuf);
if (outbuf == NULL) {
const gchar *in_str = gst_video_format_to_string (in_v_format);
const gchar *out_str = gst_video_format_to_string (out_v_format);
GST_WARNING ("failed to convert from %s to %s", in_str, out_str);
}
fail_unless (gst_video_frame_map (&out_frame, &out_info, outbuf,
GST_MAP_READ));
/* check that the converted values are correct */
for (k = 0; k < GST_VIDEO_INFO_N_PLANES (&out_info); k++) {
for (l = 0; l < _video_info_plane_size (&out_info, k); l++) {
gchar out_pixel = ((gchar *) out_frame.data[k])[l];
if (out_data[k][l] != IGNORE_MAGIC && out_pixel != IGNORE_MAGIC)
fail_unless (out_pixel == out_data[k][l]);
/* FIXME: check alpha clobbering */
}
}
gst_caps_unref (out_caps);
gst_video_frame_unmap (&out_frame);
gst_buffer_unref (outbuf);
}
gst_caps_unref (in_caps);
gst_video_frame_unmap (&in_frame);
gst_buffer_unref (inbuf);
fail_unless_equals_int (ref_count, 0);
}
gst_object_unref (base_mem_alloc);
}
static gboolean webkitVideoSinkProposeAllocation(GstBaseSink* baseSink, GstQuery* query)
{
WebKitVideoSink* sink = WEBKIT_VIDEO_SINK(baseSink);
GstCaps* caps = NULL;
gboolean need_pool;
gst_query_parse_allocation(query, &caps, &need_pool);
if (!caps)
return FALSE;
if (!gst_video_info_from_caps(&sink->priv->info, caps))
return FALSE;
#if USE(OPENGL_ES_2) && GST_CHECK_VERSION(1, 3, 0)
// Code adapted from gst-plugins-bad's glimagesink.
GstBufferPool* pool;
GstStructure* config;
guint size;
GstAllocator* allocator = 0;
GstAllocationParams params;
if (!_ensure_gl_setup(sink))
return FALSE;
if ((pool = sink->priv->pool))
gst_object_ref(pool);
if (pool) {
GstCaps* pcaps;
// We had a pool, check its caps.
GST_DEBUG_OBJECT (sink, "check existing pool caps");
config = gst_buffer_pool_get_config(pool);
gst_buffer_pool_config_get_params(config, &pcaps, &size, 0, 0);
if (!gst_caps_is_equal(caps, pcaps)) {
GST_DEBUG_OBJECT(sink, "pool has different caps");
// Different caps, we can't use this pool.
gst_object_unref(pool);
pool = 0;
}
gst_structure_free(config);
}
if (need_pool && !pool) {
GstVideoInfo info;
if (!gst_video_info_from_caps(&info, caps)) {
GST_DEBUG_OBJECT(sink, "invalid caps specified");
return FALSE;
}
GST_DEBUG_OBJECT(sink, "create new pool");
pool = gst_gl_buffer_pool_new(sink->priv->context);
// The normal size of a frame.
size = info.size;
config = gst_buffer_pool_get_config(pool);
gst_buffer_pool_config_set_params(config, caps, size, 0, 0);
if (!gst_buffer_pool_set_config(pool, config)) {
GST_DEBUG_OBJECT(sink, "failed setting config");
return FALSE;
}
}
// [WiP] Let's require 8 buffers for now. The player holds to the last 3
// ones and the sink holds only the last one so in theory 5 should
// be enough.
if (pool) {
gst_query_add_allocation_pool(query, pool, size, 8, 0);
gst_object_unref(pool);
}
gst_query_add_allocation_meta(query, GST_VIDEO_META_API_TYPE, 0);
gst_allocation_params_init(¶ms);
allocator = gst_allocator_find(GST_EGL_IMAGE_MEMORY_TYPE);
gst_query_add_allocation_param(query, allocator, ¶ms);
gst_object_unref(allocator);
#else
gst_query_add_allocation_meta(query, GST_VIDEO_META_API_TYPE, 0);
gst_query_add_allocation_meta(query, GST_VIDEO_CROP_META_API_TYPE, 0);
gst_query_add_allocation_meta(query, GST_VIDEO_GL_TEXTURE_UPLOAD_META_API_TYPE, 0);
#endif
return TRUE;
}
