/**
* gst_vaapi_plugin_base_propose_allocation:
* @plugin: a #GstVaapiPluginBase
* @query: the allocation query to configure
*
* Proposes allocation parameters to the upstream elements.
*
* Returns: %TRUE if successful, %FALSE otherwise.
*/
gboolean
gst_vaapi_plugin_base_propose_allocation (GstVaapiPluginBase * plugin,
GstQuery * query)
{
GstCaps *caps = NULL;
gboolean need_pool;
gst_query_parse_allocation (query, &caps, &need_pool);
if (!caps)
goto error_no_caps;
if (need_pool) {
if (!ensure_sinkpad_buffer_pool (plugin, caps))
return FALSE;
gst_query_add_allocation_pool (query, plugin->sinkpad_buffer_pool,
plugin->sinkpad_buffer_size, BUFFER_POOL_SINK_MIN_BUFFERS, 0);
gst_query_add_allocation_param (query, plugin->sinkpad_allocator, NULL);
}
gst_query_add_allocation_meta (query, GST_VAAPI_VIDEO_META_API_TYPE, NULL);
gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
return TRUE;
/* ERRORS */
error_no_caps:
{
GST_INFO_OBJECT (plugin, "no caps specified");
return FALSE;
}
}
static gboolean gst_imx_blitter_video_sink_propose_allocation(GstBaseSink *sink, GstQuery *query)
{
GstCaps *caps;
GstVideoInfo info;
GstBufferPool *pool;
guint size;
gst_query_parse_allocation(query, &caps, NULL);
if (caps == NULL)
{
GST_DEBUG_OBJECT(sink, "no caps specified");
return FALSE;
}
if (!gst_video_info_from_caps(&info, caps))
return FALSE;
size = GST_VIDEO_INFO_SIZE(&info);
if (gst_query_get_n_allocation_pools(query) == 0)
{
GstStructure *structure;
GstAllocationParams params;
GstAllocator *allocator = NULL;
memset(¶ms, 0, sizeof(params));
params.flags = 0;
params.align = 15;
params.prefix = 0;
params.padding = 0;
if (gst_query_get_n_allocation_params(query) > 0)
gst_query_parse_nth_allocation_param(query, 0, &allocator, ¶ms);
else
gst_query_add_allocation_param(query, allocator, ¶ms);
pool = gst_video_buffer_pool_new();
structure = gst_buffer_pool_get_config(pool);
gst_buffer_pool_config_set_params(structure, caps, size, 0, 0);
gst_buffer_pool_config_set_allocator(structure, allocator, ¶ms);
if (allocator)
gst_object_unref(allocator);
if (!gst_buffer_pool_set_config(pool, structure))
{
GST_ERROR_OBJECT(sink, "failed to set config");
gst_object_unref(pool);
return FALSE;
}
gst_query_add_allocation_pool(query, pool, size, 0, 0);
gst_object_unref(pool);
gst_query_add_allocation_meta(query, GST_VIDEO_META_API_TYPE, NULL);
}
return TRUE;
}
static gboolean
gst_shmdata_sink_propose_allocation (GstBaseSink * sink, GstQuery * query)
{
GstShmdataSink *self = GST_SHMDATA_SINK (sink);
if (self->allocator)
gst_query_add_allocation_param (query, GST_ALLOCATOR (self->allocator),
NULL);
return TRUE;
}
static gboolean
gst_decklink_video_sink_propose_allocation (GstBaseSink * bsink,
GstQuery * query)
{
GstCaps *caps;
GstVideoInfo info;
GstBufferPool *pool;
guint size;
gst_query_parse_allocation (query, &caps, NULL);
if (caps == NULL)
return FALSE;
if (!gst_video_info_from_caps (&info, caps))
return FALSE;
size = GST_VIDEO_INFO_SIZE (&info);
if (gst_query_get_n_allocation_pools (query) == 0) {
GstStructure *structure;
GstAllocator *allocator = NULL;
GstAllocationParams params = { (GstMemoryFlags) 0, 15, 0, 0 };
if (gst_query_get_n_allocation_params (query) > 0)
gst_query_parse_nth_allocation_param (query, 0, &allocator, ¶ms);
else
gst_query_add_allocation_param (query, allocator, ¶ms);
pool = gst_video_buffer_pool_new ();
structure = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (structure, caps, size, 0, 0);
gst_buffer_pool_config_set_allocator (structure, allocator, ¶ms);
if (allocator)
gst_object_unref (allocator);
if (!gst_buffer_pool_set_config (pool, structure))
goto config_failed;
gst_query_add_allocation_pool (query, pool, size, 0, 0);
gst_object_unref (pool);
gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
}
return TRUE;
// ERRORS
config_failed:
{
GST_ERROR_OBJECT (bsink, "failed to set config");
gst_object_unref (pool);
return FALSE;
}
}
static gboolean
gst_ffmpegauddec_propose_allocation (GstAudioDecoder * decoder,
GstQuery * query)
{
GstAllocationParams params;
gst_allocation_params_init (¶ms);
params.flags = GST_MEMORY_FLAG_ZERO_PADDED;
params.align = 15;
params.padding = FF_INPUT_BUFFER_PADDING_SIZE;
/* we would like to have some padding so that we don't have to
* memcpy. We don't suggest an allocator. */
gst_query_add_allocation_param (query, NULL, ¶ms);
return GST_AUDIO_DECODER_CLASS (parent_class)->propose_allocation (decoder,
query);
}
static gboolean
gst_wayland_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
{
GstWaylandSink *sink = GST_WAYLAND_SINK (bsink);
GstStructure *config;
guint size, min_bufs, max_bufs;
config = gst_buffer_pool_get_config (sink->pool);
gst_buffer_pool_config_get_params (config, NULL, &size, &min_bufs, &max_bufs);
/* we do have a pool for sure (created in set_caps),
* so let's propose it anyway, but also propose the allocator on its own */
gst_query_add_allocation_pool (query, sink->pool, size, min_bufs, max_bufs);
gst_query_add_allocation_param (query, gst_wl_shm_allocator_get (), NULL);
gst_structure_free (config);
return TRUE;
}
GstPadProbeReturn GStreamerReader::QueryProbe(GstPad* aPad, GstPadProbeInfo* aInfo, gpointer aUserData)
{
GstQuery *query = gst_pad_probe_info_get_query(aInfo);
GstPadProbeReturn ret = GST_PAD_PROBE_OK;
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_ALLOCATION:
GstCaps *caps;
GstVideoInfo info;
gboolean need_pool;
gst_query_parse_allocation(query, &caps, &need_pool);
gst_video_info_init(&info);
gst_video_info_from_caps(&info, caps);
gst_query_add_allocation_param(query, mAllocator, nullptr);
gst_query_add_allocation_pool(query, mBufferPool, info.size, 0, 0);
break;
default:
break;
}
return ret;
}
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_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;
}
}
/**
* gst_vaapi_plugin_base_decide_allocation:
* @plugin: a #GstVaapiPluginBase
* @query: the allocation query to parse
* @feature: the desired #GstVaapiCapsFeature, or zero to find the
* preferred one
*
* Decides allocation parameters for the downstream elements.
*
* Returns: %TRUE if successful, %FALSE otherwise.
*/
gboolean
gst_vaapi_plugin_base_decide_allocation (GstVaapiPluginBase * plugin,
GstQuery * query)
{
GstCaps *caps = NULL;
GstBufferPool *pool;
GstVideoInfo vi;
guint size, min, max, pool_options;
gboolean update_pool = FALSE, update_allocator = FALSE;
#if (USE_GLX || USE_EGL)
guint idx;
#endif
gst_query_parse_allocation (query, &caps, NULL);
if (!caps)
goto error_no_caps;
pool_options = 0;
if (gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL))
pool_options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META;
#if (USE_GLX || USE_EGL)
if (gst_query_find_allocation_meta (query,
GST_VIDEO_GL_TEXTURE_UPLOAD_META_API_TYPE, &idx) &&
gst_vaapi_caps_feature_contains (caps,
GST_VAAPI_CAPS_FEATURE_GL_TEXTURE_UPLOAD_META))
pool_options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_GL_TEXTURE_UPLOAD;
#if USE_GST_GL_HELPERS
if (!plugin->gl_context &&
(pool_options & GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_GL_TEXTURE_UPLOAD)) {
const GstStructure *params;
GstObject *gl_context;
gst_query_parse_nth_allocation_meta (query, idx, ¶ms);
if (params) {
if (gst_structure_get (params, "gst.gl.GstGLContext", GST_TYPE_GL_CONTEXT,
&gl_context, NULL) && gl_context) {
gst_vaapi_plugin_base_set_gl_context (plugin, gl_context);
gst_object_unref (gl_context);
}
}
}
#endif
#endif
/* Make sure the display we pass down to the buffer pool is actually
the expected one, especially when the downstream element requires
a GLX or EGL display */
if (!gst_vaapi_plugin_base_ensure_display (plugin))
goto error_ensure_display;
if (!gst_video_info_from_caps (&vi, caps))
goto error_invalid_caps;
gst_video_info_force_nv12_if_encoded (&vi);
if (gst_query_get_n_allocation_params (query) > 0)
update_allocator = TRUE;
if (gst_query_get_n_allocation_pools (query) > 0) {
gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
update_pool = TRUE;
size = MAX (size, GST_VIDEO_INFO_SIZE (&vi));
if (pool) {
/* Check whether downstream element proposed a bufferpool but did
not provide a correct propose_allocation() implementation */
if (gst_buffer_pool_has_option (pool,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT))
pool_options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT;
/* GstVaapiVideoMeta is mandatory, and this implies VA surface memory */
if (!gst_buffer_pool_has_option (pool,
GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META)) {
GST_INFO_OBJECT (plugin, "ignoring non-VAAPI pool: %" GST_PTR_FORMAT,
pool);
g_clear_object (&pool);
}
}
} else {
pool = NULL;
size = GST_VIDEO_INFO_SIZE (&vi);
min = max = 0;
}
if (!pool) {
if (!ensure_srcpad_allocator (plugin, &vi, caps))
goto error;
pool = gst_vaapi_plugin_base_create_pool (plugin, caps, size, min, max,
pool_options, plugin->srcpad_allocator);
if (!pool)
goto error;
}
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);
if (update_allocator)
gst_query_set_nth_allocation_param (query, 0, plugin->srcpad_allocator,
NULL);
else
gst_query_add_allocation_param (query, plugin->srcpad_allocator, NULL);
g_clear_object (&plugin->srcpad_buffer_pool);
plugin->srcpad_buffer_pool = pool;
return TRUE;
/* ERRORS */
error_no_caps:
{
GST_ERROR_OBJECT (plugin, "no caps specified");
return FALSE;
}
error_invalid_caps:
{
GST_ERROR_OBJECT (plugin, "invalid caps %" GST_PTR_FORMAT, caps);
return FALSE;
}
error_ensure_display:
{
GST_ERROR_OBJECT (plugin, "failed to ensure display of type %d",
plugin->display_type_req);
return FALSE;
}
error:
{
/* error message already sent */
return FALSE;
}
}
static gboolean
gst_mpeg2dec_decide_allocation (GstVideoDecoder * decoder, GstQuery * query)
{
GstMpeg2dec *dec = GST_MPEG2DEC (decoder);
GstVideoCodecState *state;
GstBufferPool *pool;
guint size, min, max;
GstStructure *config;
GstAllocator *allocator;
GstAllocationParams params;
gboolean update_allocator;
/* Set allocation parameters to guarantee 16-byte aligned output buffers */
if (gst_query_get_n_allocation_params (query) > 0) {
gst_query_parse_nth_allocation_param (query, 0, &allocator, ¶ms);
update_allocator = TRUE;
} else {
allocator = NULL;
gst_allocation_params_init (¶ms);
update_allocator = FALSE;
}
params.align = MAX (params.align, 15);
if (update_allocator)
gst_query_set_nth_allocation_param (query, 0, allocator, ¶ms);
else
gst_query_add_allocation_param (query, allocator, ¶ms);
if (allocator)
gst_object_unref (allocator);
/* Now chain up to the parent class to guarantee that we can
* get a buffer pool from the query */
if (!GST_VIDEO_DECODER_CLASS (parent_class)->decide_allocation (decoder,
query))
return FALSE;
state = gst_video_decoder_get_output_state (decoder);
gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
dec->has_cropping = FALSE;
config = gst_buffer_pool_get_config (pool);
if (gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL)) {
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_META);
dec->has_cropping =
gst_query_find_allocation_meta (query, GST_VIDEO_CROP_META_API_TYPE,
NULL);
}
if (dec->has_cropping) {
GstCaps *caps;
/* Calculate uncropped size */
size = MAX (size, dec->decoded_info.size);
caps = gst_video_info_to_caps (&dec->decoded_info);
gst_buffer_pool_config_set_params (config, caps, size, min, max);
gst_caps_unref (caps);
}
gst_buffer_pool_set_config (pool, config);
gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
gst_object_unref (pool);
gst_video_codec_state_unref (state);
return TRUE;
}
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_mpeg2dec_decide_allocation (GstVideoDecoder * decoder, GstQuery * query)
{
GstMpeg2dec *dec = GST_MPEG2DEC (decoder);
GstBufferPool *pool;
guint size, min, max;
GstStructure *config, *down_config = NULL;
GstAllocator *allocator;
GstAllocationParams params;
gboolean update_allocator;
gboolean has_videometa = FALSE;
GstCaps *caps;
/* Get rid of ancient pool */
if (dec->downstream_pool) {
gst_buffer_pool_set_active (dec->downstream_pool, FALSE);
gst_object_unref (dec->downstream_pool);
dec->downstream_pool = NULL;
}
/* Get negotiated allocation caps */
gst_query_parse_allocation (query, &caps, NULL);
/* Set allocation parameters to guarantee 16-byte aligned output buffers */
if (gst_query_get_n_allocation_params (query) > 0) {
gst_query_parse_nth_allocation_param (query, 0, &allocator, ¶ms);
update_allocator = TRUE;
} else {
allocator = NULL;
gst_allocation_params_init (¶ms);
update_allocator = FALSE;
}
params.align = MAX (params.align, 15);
if (update_allocator)
gst_query_set_nth_allocation_param (query, 0, allocator, ¶ms);
else
gst_query_add_allocation_param (query, allocator, ¶ms);
/* Now chain up to the parent class to guarantee that we can
* get a buffer pool from the query */
if (!GST_VIDEO_DECODER_CLASS (parent_class)->decide_allocation (decoder,
query)) {
if (allocator)
gst_object_unref (allocator);
return FALSE;
}
gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
config = gst_buffer_pool_get_config (pool);
if (gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL)) {
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_META);
has_videometa = TRUE;
}
if (dec->need_alignment) {
/* If downstream does not support video meta, we will have to copy, keep
* the downstream pool to avoid double copying */
if (!has_videometa) {
dec->downstream_pool = pool;
pool = NULL;
down_config = config;
config = NULL;
min = 2;
max = 0;
}
/* In case downstream support video meta, but the downstream pool does not
* have alignment support, discard downstream pool and use video pool */
else if (!gst_buffer_pool_has_option (pool,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT)) {
gst_object_unref (pool);
pool = NULL;
gst_structure_free (config);
config = NULL;
}
if (!pool)
pool = gst_mpeg2dec_create_generic_pool (allocator, ¶ms, caps, size,
min, max, &config);
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
gst_buffer_pool_config_set_video_alignment (config, &dec->valign);
}
if (allocator)
gst_object_unref (allocator);
/* If we are copying out, we'll need to setup and activate the other pool */
if (dec->downstream_pool) {
if (!gst_buffer_pool_set_config (dec->downstream_pool, down_config)) {
down_config = gst_buffer_pool_get_config (dec->downstream_pool);
if (!gst_buffer_pool_config_validate_params (down_config, caps, size, min,
max)) {
gst_structure_free (down_config);
goto config_failed;
}
if (!gst_buffer_pool_set_config (dec->downstream_pool, down_config))
goto config_failed;
}
if (!gst_buffer_pool_set_active (dec->downstream_pool, TRUE))
goto activate_failed;
}
/* Now configure the pool, if the pool had made some changes, it will
* return FALSE. Validate the changes ...*/
if (!gst_buffer_pool_set_config (pool, config)) {
config = gst_buffer_pool_get_config (pool);
/* Check basic params */
if (!gst_buffer_pool_config_validate_params (config, caps, size, min, max)) {
gst_structure_free (config);
goto config_failed;
}
/* If needed, check that resulting alignment is still valid */
if (dec->need_alignment) {
GstVideoAlignment valign;
if (!gst_buffer_pool_config_get_video_alignment (config, &valign)) {
gst_structure_free (config);
goto config_failed;
}
if (valign.padding_left != 0 || valign.padding_top != 0
|| valign.padding_right < dec->valign.padding_right
|| valign.padding_bottom < dec->valign.padding_bottom) {
gst_structure_free (config);
goto config_failed;
}
}
if (!gst_buffer_pool_set_config (pool, config))
goto config_failed;
}
/* For external pools, we need to check strides */
if (!GST_IS_VIDEO_BUFFER_POOL (pool) && has_videometa) {
GstBuffer *buffer;
const GstVideoFormatInfo *finfo;
GstVideoMeta *vmeta;
gint uv_stride;
if (!gst_buffer_pool_set_active (pool, TRUE))
goto activate_failed;
if (gst_buffer_pool_acquire_buffer (pool, &buffer, NULL) != GST_FLOW_OK) {
gst_buffer_pool_set_active (pool, FALSE);
goto acquire_failed;
}
vmeta = gst_buffer_get_video_meta (buffer);
finfo = gst_video_format_get_info (vmeta->format);
/* Check that strides are compatible. In this case, we can scale the
* stride directly since all the pixel strides for the formats we support
* is 1 */
uv_stride = GST_VIDEO_FORMAT_INFO_SCALE_WIDTH (finfo, 1, vmeta->stride[0]);
if (uv_stride != vmeta->stride[1] || uv_stride != vmeta->stride[2]) {
gst_buffer_pool_set_active (pool, FALSE);
gst_object_unref (pool);
pool = gst_mpeg2dec_create_generic_pool (allocator, ¶ms, caps, size,
min, max, &config);
if (dec->need_alignment) {
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
gst_buffer_pool_config_set_video_alignment (config, &dec->valign);
}
/* Generic pool don't fail on _set_config() */
gst_buffer_pool_set_config (pool, config);
}
gst_buffer_unref (buffer);
}
gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
gst_object_unref (pool);
return TRUE;
config_failed:
gst_object_unref (pool);
GST_ELEMENT_ERROR (dec, RESOURCE, SETTINGS,
("Failed to configure buffer pool"),
("Configuration is most likely invalid, please report this issue."));
return FALSE;
activate_failed:
gst_object_unref (pool);
GST_ELEMENT_ERROR (dec, RESOURCE, SETTINGS,
("Failed to activate buffer pool"), (NULL));
return FALSE;
acquire_failed:
gst_object_unref (pool);
GST_ELEMENT_ERROR (dec, RESOURCE, SETTINGS,
("Failed to acquire a buffer"), (NULL));
return FALSE;
}
/* Answer the allocation query downstream. */
static gboolean
gst_video_filter_propose_allocation (GstBaseTransform * trans,
GstQuery * decide_query, GstQuery * query)
{
GstVideoFilter *filter = GST_VIDEO_FILTER_CAST (trans);
GstVideoInfo info;
GstBufferPool *pool;
GstCaps *caps;
guint size;
if (!GST_BASE_TRANSFORM_CLASS (parent_class)->propose_allocation (trans,
decide_query, query))
return FALSE;
/* passthrough, we're done */
if (decide_query == NULL)
return TRUE;
gst_query_parse_allocation (query, &caps, NULL);
if (caps == NULL)
return FALSE;
if (!gst_video_info_from_caps (&info, caps))
return FALSE;
size = GST_VIDEO_INFO_SIZE (&info);
if (gst_query_get_n_allocation_pools (query) == 0) {
GstStructure *structure;
GstAllocator *allocator = NULL;
GstAllocationParams params = { 0, 15, 0, 0, };
if (gst_query_get_n_allocation_params (query) > 0)
gst_query_parse_nth_allocation_param (query, 0, &allocator, ¶ms);
else
gst_query_add_allocation_param (query, allocator, ¶ms);
pool = gst_video_buffer_pool_new ();
structure = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (structure, caps, size, 0, 0);
gst_buffer_pool_config_set_allocator (structure, allocator, ¶ms);
if (allocator)
gst_object_unref (allocator);
if (!gst_buffer_pool_set_config (pool, structure))
goto config_failed;
gst_query_add_allocation_pool (query, pool, size, 0, 0);
gst_object_unref (pool);
gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
}
return TRUE;
/* ERRORS */
config_failed:
{
GST_ERROR_OBJECT (filter, "failed to set config");
gst_object_unref (pool);
return FALSE;
}
}
static gboolean
gst_msdkvpp_decide_allocation (GstBaseTransform * trans, GstQuery * query)
{
GstMsdkVPP *thiz = GST_MSDKVPP (trans);
GstVideoInfo info;
GstBufferPool *pool = NULL;
GstStructure *config = NULL;
GstCaps *caps;
guint size = 0, min_buffers = 0, max_buffers = 0;
GstAllocator *allocator = NULL;
GstAllocationParams params;
gboolean update_pool = FALSE;
gst_query_parse_allocation (query, &caps, NULL);
if (!caps) {
GST_ERROR_OBJECT (thiz, "Failed to parse the decide_allocation caps");
return FALSE;
}
if (!gst_video_info_from_caps (&info, caps)) {
GST_ERROR_OBJECT (thiz, "Failed to get video info");
return FALSE;
}
/* if downstream allocation query supports dmabuf-capsfeatures,
* we do allocate dmabuf backed memory */
if (_gst_caps_has_feature (caps, GST_CAPS_FEATURE_MEMORY_DMABUF)) {
GST_INFO_OBJECT (thiz, "MSDK VPP srcpad uses DMABuf memory");
thiz->use_srcpad_dmabuf = TRUE;
}
if (gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL))
thiz->add_video_meta = TRUE;
else
thiz->add_video_meta = FALSE;
/* Check whether the query has pool */
if (gst_query_get_n_allocation_pools (query) > 0)
update_pool = TRUE;
/* increase the min_buffers with number of concurrent vpp operations */
min_buffers += thiz->async_depth;
/* invalidate the cached pool if there is an allocation_query */
if (thiz->srcpad_buffer_pool)
gst_object_unref (thiz->srcpad_buffer_pool);
/* Always create a pool for vpp out buffers. Each of the msdk element
* has to create it's own mfxsurfacepool which is an msdk contraint.
* For eg: Each Msdk component (vpp, dec and enc) will invoke the external
* Frame allocator for video-memory usage.So sharing the pool between
* gst-msdk elements might not be a good idea, rather each element
* can check the buffer type (whether it is from msdk-buffer pool)
* to make sure there is no copy. Since we share the context between
* msdk elements, using buffers from one sdk's framealloator in another
* sdk-components is perfectly fine */
pool = gst_msdkvpp_create_buffer_pool (thiz, GST_PAD_SRC, caps, min_buffers);
thiz->srcpad_buffer_pool = pool;
/* get the configured pool properties inorder to set in query */
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_get_params (config, &caps, &size, &min_buffers,
&max_buffers);
if (gst_buffer_pool_config_get_allocator (config, &allocator, ¶ms))
gst_query_add_allocation_param (query, allocator, ¶ms);
gst_structure_free (config);
if (update_pool)
gst_query_set_nth_allocation_pool (query, 0, pool, size, min_buffers,
max_buffers);
else
gst_query_add_allocation_pool (query, pool, size, min_buffers, max_buffers);
gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
/* Fixme if downstream doesn't have videometa support, msdkvpp should
* copy the output buffers */
return TRUE;
}
static gboolean
gst_msdkvpp_propose_allocation (GstBaseTransform * trans,
GstQuery * decide_query, GstQuery * query)
{
GstMsdkVPP *thiz = GST_MSDKVPP (trans);
GstVideoInfo info;
GstBufferPool *pool = NULL;
GstAllocator *allocator = NULL;
GstCaps *caps;
GstStructure *config;
gboolean need_pool;
GstAllocationParams params;
guint size;
guint min_buffers = thiz->async_depth + 1;
gst_query_parse_allocation (query, &caps, &need_pool);
if (!caps) {
GST_ERROR_OBJECT (thiz, "Failed to parse the allocation caps");
return FALSE;
}
if (!gst_video_info_from_caps (&info, caps)) {
GST_ERROR_OBJECT (thiz, "Failed to get video info");
return FALSE;
}
/* if upstream allocation query supports dmabuf-capsfeatures,
* we do allocate dmabuf backed memory */
if (_gst_caps_has_feature (caps, GST_CAPS_FEATURE_MEMORY_DMABUF)) {
GST_INFO_OBJECT (thiz, "MSDK VPP srcpad uses DMABuf memory");
thiz->use_sinkpad_dmabuf = TRUE;
}
if (need_pool) {
/* alwys provide a new pool for upstream to help re-negotiation
* more info here: https://bugzilla.gnome.org/show_bug.cgi?id=748344 */
pool = gst_msdkvpp_create_buffer_pool (thiz, GST_PAD_SINK, caps,
min_buffers);
}
/* Update the internal pool if any allocation attribute changed */
if (!gst_video_info_is_equal (&thiz->sinkpad_buffer_pool_info, &info)) {
gst_object_unref (thiz->sinkpad_buffer_pool);
thiz->sinkpad_buffer_pool = gst_msdkvpp_create_buffer_pool (thiz,
GST_PAD_SINK, caps, min_buffers);
}
/* get the size and allocator params from configured pool and set it in query */
if (!need_pool)
pool = gst_object_ref (thiz->sinkpad_buffer_pool);
config = gst_buffer_pool_get_config (GST_BUFFER_POOL_CAST (pool));
gst_buffer_pool_config_get_params (config, NULL, &size, NULL, NULL);
if (gst_buffer_pool_config_get_allocator (config, &allocator, ¶ms))
gst_query_add_allocation_param (query, allocator, ¶ms);
gst_structure_free (config);
/* if upstream does't have a pool requirement, set only
* size, min_buffers and max_buffers in query */
gst_query_add_allocation_pool (query, need_pool ? pool : NULL, size,
min_buffers, 0);
gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
gst_object_unref (pool);
return GST_BASE_TRANSFORM_CLASS (parent_class)->propose_allocation (trans,
decide_query, query);
}
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;
}