static GstBufferPool *
gst_kms_sink_create_pool (GstKMSSink * self, GstCaps * caps, gsize size,
gint min)
{
GstBufferPool *pool;
GstStructure *config;
pool = gst_kms_buffer_pool_new ();
if (!pool)
goto pool_failed;
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, min, 0);
gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
ensure_kms_allocator (self);
gst_buffer_pool_config_set_allocator (config, self->allocator, NULL);
if (!gst_buffer_pool_set_config (pool, config))
goto config_failed;
return pool;
/* ERRORS */
pool_failed:
{
GST_ERROR_OBJECT (self, "failed to create buffer pool");
return NULL;
}
config_failed:
{
GST_ERROR_OBJECT (self, "failed to set config");
gst_object_unref (pool);
return NULL;
}
}
static GstBufferPool *
gst_msdkvpp_create_buffer_pool (GstMsdkVPP * thiz, GstPadDirection direction,
GstCaps * caps, guint min_num_buffers)
{
GstBufferPool *pool = NULL;
GstStructure *config;
GstAllocator *allocator = NULL;
GstVideoInfo info;
GstVideoInfo *pool_info = NULL;
GstVideoAlignment align;
GstAllocationParams params = { 0, 31, 0, 0, };
mfxFrameAllocResponse *alloc_resp = NULL;
gboolean use_dmabuf = FALSE;
if (direction == GST_PAD_SINK) {
alloc_resp = &thiz->in_alloc_resp;
pool_info = &thiz->sinkpad_buffer_pool_info;
use_dmabuf = thiz->use_sinkpad_dmabuf;
} else if (direction == GST_PAD_SRC) {
alloc_resp = &thiz->out_alloc_resp;
pool_info = &thiz->srcpad_buffer_pool_info;
use_dmabuf = thiz->use_srcpad_dmabuf;
}
pool = gst_msdk_buffer_pool_new (thiz->context, alloc_resp);
if (!pool)
goto error_no_pool;
if (!gst_video_info_from_caps (&info, caps))
goto error_no_video_info;
gst_msdk_set_video_alignment (&info, &align);
gst_video_info_align (&info, &align);
if (use_dmabuf)
allocator =
gst_msdk_dmabuf_allocator_new (thiz->context, &info, alloc_resp);
else if (thiz->use_video_memory)
allocator = gst_msdk_video_allocator_new (thiz->context, &info, alloc_resp);
else
allocator = gst_msdk_system_allocator_new (&info);
if (!allocator)
goto error_no_allocator;
config = gst_buffer_pool_get_config (GST_BUFFER_POOL_CAST (pool));
gst_buffer_pool_config_set_params (config, caps, info.size, min_num_buffers,
0);
gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
if (thiz->use_video_memory) {
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_MSDK_USE_VIDEO_MEMORY);
if (use_dmabuf)
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_MSDK_USE_DMABUF);
}
gst_buffer_pool_config_set_video_alignment (config, &align);
gst_buffer_pool_config_set_allocator (config, allocator, ¶ms);
gst_object_unref (allocator);
if (!gst_buffer_pool_set_config (pool, config))
goto error_pool_config;
/* Updating pool_info with algined info of allocator */
*pool_info = info;
return pool;
error_no_pool:
{
GST_INFO_OBJECT (thiz, "Failed to create bufferpool");
return NULL;
}
error_no_video_info:
{
GST_INFO_OBJECT (thiz, "Failed to get Video info from caps");
return NULL;
}
error_no_allocator:
{
GST_INFO_OBJECT (thiz, "Failed to create allocator");
if (pool)
gst_object_unref (pool);
return NULL;
}
error_pool_config:
{
GST_INFO_OBJECT (thiz, "Failed to set config");
if (pool)
gst_object_unref (pool);
if (allocator)
gst_object_unref (allocator);
return NULL;
}
}
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_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_mir_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
{
GstMirSink *sink = GST_MIR_SINK (bsink);
GstBufferPool *newpool, *oldpool;
GstMirBufferPool *m_pool;
GstVideoInfo info;
GstStructure *config;
static GstAllocationParams params = {
0, 0, 0, 15,
};
guint size;
sink = GST_MIR_SINK (bsink);
GST_DEBUG_OBJECT (sink, "set caps %" GST_PTR_FORMAT, caps);
if (!gst_video_info_from_caps (&info, caps))
goto invalid_format;
sink->video_width = info.width;
sink->video_height = info.height;
size = info.size;
GST_DEBUG_OBJECT (sink, "Creating new GstMirBufferPool");
/* Create a new pool for the new configuration */
newpool = gst_mir_buffer_pool_new (sink);
if (!newpool) {
GST_ERROR_OBJECT (sink, "Failed to create new pool");
return FALSE;
}
GST_DEBUG_OBJECT (sink,
"Setting SurfaceTextureClientHybris instance in m_pool");
/* Add the SurfaceTextureClientHybris instance to the pool for later use */
gst_mir_buffer_pool_set_surface_texture_client (newpool,
sink->surface_texture_client);
GST_WARNING_OBJECT (sink, "SurfaceTextureClientHybris: %p",
sink->surface_texture_client);
m_pool = GST_MIR_BUFFER_POOL_CAST (newpool);
GST_WARNING_OBJECT (sink, "m_pool SurfaceTextureClientHybris: %p",
m_pool->surface_texture_client);
m_pool->width = sink->video_width;
m_pool->height = sink->video_height;
config = gst_buffer_pool_get_config (newpool);
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 (newpool, config))
goto config_failed;
GST_OBJECT_LOCK (sink);
oldpool = sink->pool;
sink->pool = newpool;
GST_OBJECT_UNLOCK (sink);
GST_DEBUG_OBJECT (sink, "Finishing up set_caps");
if (oldpool)
gst_object_unref (oldpool);
return TRUE;
invalid_format:
{
GST_DEBUG_OBJECT (sink,
"Could not locate image format from caps %" GST_PTR_FORMAT, caps);
return FALSE;
}
config_failed:
{
GST_DEBUG_OBJECT (bsink, "failed setting config");
return FALSE;
}
}
/**
* gst_vaapi_plugin_base_create_pool:
* @plugin: a #GstVaapiPluginBase
* @caps: the initial #GstCaps for the resulting buffer pool
* @size: the size of each buffer, not including prefix and padding
* @options: a set of #GstVaapiVideoBufferPoolOption encoded as bit-wise
* @allocator: (allow-none): the #GstAllocator to use or %NULL
*
* Create an instance of #GstVaapiVideoBufferPool
*
* Returns: (transfer full): a new allocated #GstBufferPool
**/
static GstBufferPool *
gst_vaapi_plugin_base_create_pool (GstVaapiPluginBase * plugin, GstCaps * caps,
gsize size, guint min_buffers, guint max_buffers, guint options,
GstAllocator * allocator)
{
GstBufferPool *pool;
GstStructure *config;
if (!(pool = gst_vaapi_video_buffer_pool_new (plugin->display)))
goto error_create_pool;
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, min_buffers,
max_buffers);
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META);
if (options & GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META) {
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_META);
}
if (options & GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT) {
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
}
#if (USE_GLX || USE_EGL)
if (options & GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_GL_TEXTURE_UPLOAD) {
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META);
}
#endif
if (allocator)
gst_buffer_pool_config_set_allocator (config, allocator, NULL);
if (!gst_buffer_pool_set_config (pool, config)) {
config = gst_buffer_pool_get_config (pool);
if (!gst_buffer_pool_config_validate_params (config, caps, size,
min_buffers, max_buffers)) {
gst_structure_free (config);
goto error_pool_config;
}
if (!gst_buffer_pool_set_config (pool, config))
goto error_pool_config;
}
return pool;
/* ERRORS */
error_create_pool:
{
GST_ERROR_OBJECT (plugin, "failed to create buffer pool");
return NULL;
}
error_pool_config:
{
gst_object_unref (pool);
GST_ELEMENT_ERROR (plugin, RESOURCE, SETTINGS,
("Failed to configure the buffer pool"),
("Configuration is most likely invalid, please report this issue."));
return NULL;
}
}
static gboolean
gst_wayland_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
{
GstWaylandSink *sink;
GstBufferPool *newpool;
GstVideoInfo info;
enum wl_shm_format format;
GArray *formats;
gint i;
GstStructure *structure;
sink = GST_WAYLAND_SINK (bsink);
GST_DEBUG_OBJECT (sink, "set caps %" GST_PTR_FORMAT, caps);
/* extract info from caps */
if (!gst_video_info_from_caps (&info, caps))
goto invalid_format;
format = gst_video_format_to_wl_shm_format (GST_VIDEO_INFO_FORMAT (&info));
if ((gint) format == -1)
goto invalid_format;
/* verify we support the requested format */
formats = sink->display->shm_formats;
for (i = 0; i < formats->len; i++) {
if (g_array_index (formats, uint32_t, i) == format)
break;
}
if (i >= formats->len)
goto unsupported_format;
/* create a new pool for the new configuration */
newpool = gst_video_buffer_pool_new ();
if (!newpool)
goto pool_failed;
structure = gst_buffer_pool_get_config (newpool);
gst_buffer_pool_config_set_params (structure, caps, info.size, 2, 0);
gst_buffer_pool_config_set_allocator (structure, gst_wl_shm_allocator_get (),
NULL);
if (!gst_buffer_pool_set_config (newpool, structure))
goto config_failed;
/* store the video info */
sink->video_info = info;
sink->video_info_changed = TRUE;
gst_object_replace ((GstObject **) & sink->pool, (GstObject *) newpool);
gst_object_unref (newpool);
return TRUE;
invalid_format:
{
GST_DEBUG_OBJECT (sink,
"Could not locate image format from caps %" GST_PTR_FORMAT, caps);
return FALSE;
}
unsupported_format:
{
GST_DEBUG_OBJECT (sink, "Format %s is not available on the display",
gst_wl_shm_format_to_string (format));
return FALSE;
}
pool_failed:
{
GST_DEBUG_OBJECT (sink, "Failed to create new pool");
return FALSE;
}
config_failed:
{
GST_DEBUG_OBJECT (bsink, "failed setting config");
gst_object_unref (newpool);
return FALSE;
}
}
static GstFlowReturn gst_fsl_vpu_base_enc_handle_frame(GstVideoEncoder *encoder, GstVideoCodecFrame *frame)
{
VpuEncRetCode enc_ret;
VpuEncEncParam enc_enc_param;
GstFslPhysMemMeta *phys_mem_meta;
GstFslVpuBaseEncClass *klass;
GstFslVpuBaseEnc *vpu_base_enc;
VpuFrameBuffer input_framebuf;
GstBuffer *input_buffer;
vpu_base_enc = GST_FSL_VPU_BASE_ENC(encoder);
klass = GST_FSL_VPU_BASE_ENC_CLASS(G_OBJECT_GET_CLASS(vpu_base_enc));
g_assert(klass->set_frame_enc_params != NULL);
memset(&enc_enc_param, 0, sizeof(enc_enc_param));
memset(&input_framebuf, 0, sizeof(input_framebuf));
phys_mem_meta = GST_FSL_PHYS_MEM_META_GET(frame->input_buffer);
if (phys_mem_meta == NULL)
{
GstVideoFrame temp_input_video_frame, temp_incoming_video_frame;
if (vpu_base_enc->internal_input_buffer == NULL)
{
/* The internal input buffer is the temp input frame's DMA memory.
* If it does not exist yet, it needs to be created here. The temp input
* frame is then mapped. */
GstFlowReturn flow_ret;
if (vpu_base_enc->internal_bufferpool == NULL)
{
/* Internal bufferpool does not exist yet - create it now,
* so that it can in turn create the internal input buffer */
GstStructure *config;
GstCaps *caps;
GstAllocator *allocator;
caps = gst_video_info_to_caps(&(vpu_base_enc->video_info));
vpu_base_enc->internal_bufferpool = gst_fsl_phys_mem_buffer_pool_new(FALSE);
allocator = gst_fsl_vpu_enc_allocator_obtain();
config = gst_buffer_pool_get_config(vpu_base_enc->internal_bufferpool);
gst_buffer_pool_config_set_params(config, caps, vpu_base_enc->video_info.size, 2, 0);
gst_buffer_pool_config_set_allocator(config, allocator, NULL);
gst_buffer_pool_config_add_option(config, GST_BUFFER_POOL_OPTION_FSL_PHYS_MEM);
gst_buffer_pool_config_add_option(config, GST_BUFFER_POOL_OPTION_VIDEO_META);
gst_buffer_pool_set_config(vpu_base_enc->internal_bufferpool, config);
gst_caps_unref(caps);
if (vpu_base_enc->internal_bufferpool == NULL)
{
GST_ERROR_OBJECT(vpu_base_enc, "failed to create internal bufferpool");
return FALSE;
}
}
/* Future versions of this code may propose the internal bufferpool upstream;
* hence the is_active check */
if (!gst_buffer_pool_is_active(vpu_base_enc->internal_bufferpool))
gst_buffer_pool_set_active(vpu_base_enc->internal_bufferpool, TRUE);
/* Create the internal input buffer */
flow_ret = gst_buffer_pool_acquire_buffer(vpu_base_enc->internal_bufferpool, &(vpu_base_enc->internal_input_buffer), NULL);
if (flow_ret != GST_FLOW_OK)
{
GST_ERROR_OBJECT(vpu_base_enc, "error acquiring input frame buffer: %s", gst_pad_mode_get_name(flow_ret));
return FALSE;
}
}
gst_video_frame_map(&temp_incoming_video_frame, &(vpu_base_enc->video_info), frame->input_buffer, GST_MAP_READ);
gst_video_frame_map(&temp_input_video_frame, &(vpu_base_enc->video_info), vpu_base_enc->internal_input_buffer, GST_MAP_WRITE);
gst_video_frame_copy(&temp_input_video_frame, &temp_incoming_video_frame);
gst_video_frame_unmap(&temp_incoming_video_frame);
gst_video_frame_unmap(&temp_input_video_frame);
input_buffer = vpu_base_enc->internal_input_buffer;
phys_mem_meta = GST_FSL_PHYS_MEM_META_GET(vpu_base_enc->internal_input_buffer);
}
else
input_buffer = frame->input_buffer;
{
gsize *plane_offsets;
gint *plane_strides;
GstVideoMeta *video_meta;
unsigned char *phys_ptr;
video_meta = gst_buffer_get_video_meta(input_buffer);
if (video_meta != NULL)
{
plane_offsets = video_meta->offset;
plane_strides = video_meta->stride;
}
else
{
plane_offsets = vpu_base_enc->video_info.offset;
plane_strides = vpu_base_enc->video_info.stride;
}
phys_ptr = (unsigned char*)(phys_mem_meta->phys_addr);
input_framebuf.pbufY = phys_ptr;
input_framebuf.pbufCb = phys_ptr + plane_offsets[1];
input_framebuf.pbufCr = phys_ptr + plane_offsets[2];
input_framebuf.pbufMvCol = NULL;
input_framebuf.nStrideY = plane_strides[0];
input_framebuf.nStrideC = plane_strides[1];
GST_TRACE_OBJECT(vpu_base_enc, "width: %d height: %d stride 0: %d stride 1: %d offset 0: %d offset 1: %d offset 2: %d", GST_VIDEO_INFO_WIDTH(&(vpu_base_enc->video_info)), GST_VIDEO_INFO_HEIGHT(&(vpu_base_enc->video_info)), plane_strides[0], plane_strides[1], plane_offsets[0], plane_offsets[1], plane_offsets[2]);
if (vpu_base_enc->framebuffers == NULL)
{
GstFslVpuFramebufferParams fbparams;
gst_fsl_vpu_framebuffers_enc_init_info_to_params(&(vpu_base_enc->init_info), &fbparams);
fbparams.pic_width = vpu_base_enc->open_param.nPicWidth;
fbparams.pic_height = vpu_base_enc->open_param.nPicHeight;
vpu_base_enc->framebuffers = gst_fsl_vpu_framebuffers_new(&fbparams, gst_fsl_vpu_enc_allocator_obtain());
gst_fsl_vpu_framebuffers_register_with_encoder(vpu_base_enc->framebuffers, vpu_base_enc->handle, plane_strides[0]);
}
if (vpu_base_enc->output_phys_buffer == NULL)
{
vpu_base_enc->output_phys_buffer = (GstFslPhysMemory *)gst_allocator_alloc(gst_fsl_vpu_enc_allocator_obtain(), vpu_base_enc->framebuffers->total_size, NULL);
if (vpu_base_enc->output_phys_buffer == NULL)
{
GST_ERROR_OBJECT(vpu_base_enc, "could not allocate physical buffer for output data");
return GST_FLOW_ERROR;
}
}
}
enc_enc_param.nInVirtOutput = (unsigned int)(vpu_base_enc->output_phys_buffer->mapped_virt_addr); /* TODO */
enc_enc_param.nInPhyOutput = (unsigned int)(vpu_base_enc->output_phys_buffer->phys_addr);
enc_enc_param.nInOutputBufLen = vpu_base_enc->output_phys_buffer->mem.size;
enc_enc_param.nPicWidth = vpu_base_enc->framebuffers->pic_width;
enc_enc_param.nPicHeight = vpu_base_enc->framebuffers->pic_height;
enc_enc_param.nFrameRate = vpu_base_enc->open_param.nFrameRate;
enc_enc_param.pInFrame = &input_framebuf;
if (!klass->set_frame_enc_params(vpu_base_enc, &enc_enc_param, &(vpu_base_enc->open_param)))
{
GST_ERROR_OBJECT(vpu_base_enc, "derived class could not frame enc params");
return GST_FLOW_ERROR;
}
enc_ret = VPU_EncEncodeFrame(vpu_base_enc->handle, &enc_enc_param);
if (enc_ret != VPU_ENC_RET_SUCCESS)
{
GST_ERROR_OBJECT(vpu_base_enc, "failed to encode frame: %s", gst_fsl_vpu_strerror(enc_ret));
VPU_EncReset(vpu_base_enc->handle);
return GST_FLOW_ERROR;
}
GST_LOG_OBJECT(vpu_base_enc, "out ret code: 0x%x out size: %u", enc_enc_param.eOutRetCode, enc_enc_param.nOutOutputSize);
if ((enc_enc_param.eOutRetCode & VPU_ENC_OUTPUT_DIS) || (enc_enc_param.eOutRetCode & VPU_ENC_OUTPUT_SEQHEADER))
{
gst_video_encoder_allocate_output_frame(encoder, frame, enc_enc_param.nOutOutputSize);
gst_buffer_fill(frame->output_buffer, 0, vpu_base_enc->output_phys_buffer->mapped_virt_addr, enc_enc_param.nOutOutputSize);
gst_video_encoder_finish_frame(encoder, frame);
}
return GST_FLOW_OK;
}
static gboolean
gst_vaapi_video_buffer_pool_set_config (GstBufferPool * pool,
GstStructure * config)
{
GstVaapiVideoBufferPoolPrivate *const priv =
GST_VAAPI_VIDEO_BUFFER_POOL (pool)->priv;
GstCaps *caps;
GstVideoInfo new_allocation_vinfo;
const GstVideoInfo *allocator_vinfo;
const GstVideoInfo *negotiated_vinfo;
GstVideoAlignment align;
GstAllocator *allocator;
gboolean ret, updated = FALSE;
guint size, min_buffers, max_buffers;
guint surface_alloc_flags;
GST_DEBUG_OBJECT (pool, "config %" GST_PTR_FORMAT, config);
caps = NULL;
if (!gst_buffer_pool_config_get_params (config, &caps, &size, &min_buffers,
&max_buffers))
goto error_invalid_config;
if (!caps)
goto error_no_caps;
if (!gst_video_info_from_caps (&new_allocation_vinfo, caps))
goto error_invalid_caps;
allocator = NULL;
if (!gst_buffer_pool_config_get_allocator (config, &allocator, NULL))
goto error_invalid_allocator;
/* it is a valid allocator? */
if (allocator
&& (g_strcmp0 (allocator->mem_type, GST_VAAPI_VIDEO_MEMORY_NAME) != 0
&& g_strcmp0 (allocator->mem_type,
GST_VAAPI_DMABUF_ALLOCATOR_NAME) != 0))
allocator = NULL;
/* get the allocator properties */
if (allocator) {
priv->use_dmabuf_memory = gst_vaapi_is_dmabuf_allocator (allocator);
negotiated_vinfo =
gst_allocator_get_vaapi_negotiated_video_info (allocator);
allocator_vinfo =
gst_allocator_get_vaapi_video_info (allocator, &surface_alloc_flags);
} else {
priv->use_dmabuf_memory = FALSE;
negotiated_vinfo = NULL;
allocator_vinfo = NULL;
surface_alloc_flags = 0;
}
/* reset or update the allocator if video resolution changed */
if (allocator_vinfo
&& gst_video_info_changed (allocator_vinfo, &new_allocation_vinfo)) {
gst_object_replace ((GstObject **) & priv->allocator, NULL);
if (allocator && priv->use_dmabuf_memory) {
gst_allocator_set_vaapi_video_info (allocator, &new_allocation_vinfo,
surface_alloc_flags);
} else {
allocator = NULL;
}
}
if (!gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META))
goto error_no_vaapi_video_meta_option;
/* create a new allocator if needed */
if (!allocator) {
if (priv->use_dmabuf_memory) {
allocator = gst_vaapi_dmabuf_allocator_new (priv->display,
&new_allocation_vinfo, /* FIXME: */ 0, GST_PAD_SRC);
} else {
allocator = gst_vaapi_video_allocator_new (priv->display,
&new_allocation_vinfo, surface_alloc_flags, 0);
}
if (!allocator)
goto error_no_allocator;
if (negotiated_vinfo) {
gst_allocator_set_vaapi_negotiated_video_info (allocator,
negotiated_vinfo);
}
GST_INFO_OBJECT (pool, "created new allocator %" GST_PTR_FORMAT, allocator);
gst_buffer_pool_config_set_allocator (config, allocator, NULL);
gst_object_unref (allocator);
}
/* use the allocator and set the video info for the vmeta */
if (allocator) {
if (priv->allocator)
gst_object_unref (priv->allocator);
if ((priv->allocator = allocator))
gst_object_ref (allocator);
negotiated_vinfo =
gst_allocator_get_vaapi_negotiated_video_info (priv->allocator);
allocator_vinfo = gst_allocator_get_vaapi_video_info (allocator, NULL);
priv->vmeta_vinfo = (negotiated_vinfo) ?
*negotiated_vinfo : *allocator_vinfo;
/* last resource to set the correct buffer size */
if (GST_VIDEO_INFO_SIZE (allocator_vinfo) != size) {
gst_buffer_pool_config_set_params (config, caps,
GST_VIDEO_INFO_SIZE (allocator_vinfo), min_buffers, max_buffers);
}
}
if (!priv->allocator)
goto error_no_allocator;
priv->options = 0;
if (gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_META)) {
priv->options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META;
} else {
gint i;
for (i = 0; i < GST_VIDEO_INFO_N_PLANES (&new_allocation_vinfo); i++) {
if (GST_VIDEO_INFO_PLANE_OFFSET (&new_allocation_vinfo, i) !=
GST_VIDEO_INFO_PLANE_OFFSET (&priv->vmeta_vinfo, i) ||
GST_VIDEO_INFO_PLANE_STRIDE (&new_allocation_vinfo, i) !=
GST_VIDEO_INFO_PLANE_STRIDE (&priv->vmeta_vinfo, i)) {
priv->options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_VIDEO_META;
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_META);
updated = TRUE;
break;
}
}
}
if (gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT)) {
fill_video_alignment (GST_VAAPI_VIDEO_BUFFER_POOL (pool), &align);
gst_buffer_pool_config_set_video_alignment (config, &align);
}
if (!priv->use_dmabuf_memory && gst_buffer_pool_config_has_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META))
priv->options |= GST_VAAPI_VIDEO_BUFFER_POOL_OPTION_GL_TEXTURE_UPLOAD;
ret =
GST_BUFFER_POOL_CLASS
(gst_vaapi_video_buffer_pool_parent_class)->set_config (pool, config);
return !updated && ret;
/* ERRORS */
error_invalid_config:
{
GST_ERROR_OBJECT (pool, "invalid config");
return FALSE;
}
error_no_caps:
{
GST_ERROR_OBJECT (pool, "no caps in config");
return FALSE;
}
error_invalid_caps:
{
GST_ERROR_OBJECT (pool, "invalid caps %" GST_PTR_FORMAT, caps);
return FALSE;
}
error_invalid_allocator:
{
GST_ERROR_OBJECT (pool, "no allocator in config");
return FALSE;
}
error_no_vaapi_video_meta_option:
{
GST_ERROR_OBJECT (pool, "no GstVaapiVideoMeta option in config");
return FALSE;
}
error_no_allocator:
{
GST_ERROR_OBJECT (pool, "no allocator defined");
return FALSE;
}
}
static void
gst_droidcamsrc_stream_window_reset_buffer_pool_locked
(GstDroidCamSrcStreamWindow * win)
{
GstStructure *config;
GstCaps *caps;
GstCapsFeatures *feature;
GST_DEBUG ("stream window configure buffer pool");
if (win->pool) {
/* we will ignore the error here */
if (!gst_buffer_pool_set_active (GST_BUFFER_POOL (win->pool), FALSE)) {
GST_WARNING ("Failed to deactivate buffer pool");
}
gst_object_unref (win->pool);
}
win->pool = gst_droid_cam_src_buffer_pool_new (win->info);
if (!win->count || !win->width || !win->height || !win->usage || !win->format) {
GST_ERROR ("incomplete configuration");
goto clean_and_out;
}
config = gst_buffer_pool_get_config (GST_BUFFER_POOL (win->pool));
if (!config) {
GST_ERROR ("failed to get buffer pool config");
goto clean_and_out;
}
/* TODO: 30 is hardcoded */
caps = gst_caps_new_simple ("video/x-raw",
"format", G_TYPE_STRING, "ENCODED",
"width", G_TYPE_INT, win->width,
"height", G_TYPE_INT, win->height,
"framerate", GST_TYPE_FRACTION, 30, 1, NULL);
feature = gst_caps_features_new (GST_CAPS_FEATURE_MEMORY_DROID_HANDLE, NULL);
gst_caps_set_features (caps, 0, feature);
gst_buffer_pool_config_set_params (config, caps, 0, win->count, win->count);
gst_buffer_pool_config_set_allocator (config, win->allocator, NULL);
gst_structure_set (config,
GST_DROIDCAMSRC_BUFFER_POOL_USAGE_KEY, G_TYPE_INT, win->usage,
GST_DROIDCAMSRC_BUFFER_POOL_WIDTH_KEY, G_TYPE_INT, win->width,
GST_DROIDCAMSRC_BUFFER_POOL_HEIGHT_KEY, G_TYPE_INT, win->height,
GST_DROIDCAMSRC_BUFFER_POOL_FORMAT_KEY, G_TYPE_INT, win->format, NULL);
gst_caps_unref (caps);
if (!gst_buffer_pool_set_config (GST_BUFFER_POOL (win->pool), config)) {
GST_ERROR ("failed to set buffer pool config");
goto clean_and_out;
}
if (!gst_buffer_pool_set_active (GST_BUFFER_POOL (win->pool), TRUE)) {
GST_ERROR ("failed to activate buffer pool");
goto clean_and_out;
}
win->needs_reconfigure = FALSE;
return;
clean_and_out:
if (win->pool) {
gst_object_unref (win->pool);
win->pool = NULL;
}
}
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;
}
}
/* 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 GstFlowReturn gst_imx_vpu_base_enc_handle_frame(GstVideoEncoder *encoder, GstVideoCodecFrame *frame)
{
VpuEncRetCode enc_ret;
VpuEncEncParam enc_enc_param;
GstImxPhysMemMeta *phys_mem_meta;
GstImxVpuBaseEncClass *klass;
GstImxVpuBaseEnc *vpu_base_enc;
VpuFrameBuffer input_framebuf;
GstBuffer *input_buffer;
gint src_stride;
vpu_base_enc = GST_IMX_VPU_BASE_ENC(encoder);
klass = GST_IMX_VPU_BASE_ENC_CLASS(G_OBJECT_GET_CLASS(vpu_base_enc));
g_assert(klass->set_frame_enc_params != NULL);
memset(&enc_enc_param, 0, sizeof(enc_enc_param));
memset(&input_framebuf, 0, sizeof(input_framebuf));
phys_mem_meta = GST_IMX_PHYS_MEM_META_GET(frame->input_buffer);
/* If the incoming frame's buffer is not using physically contiguous memory,
* it needs to be copied to the internal input buffer, otherwise the VPU
* encoder cannot read the frame */
if (phys_mem_meta == NULL)
{
/* No physical memory metadata found -> buffer is not physically contiguous */
GstVideoFrame temp_input_video_frame, temp_incoming_video_frame;
GST_LOG_OBJECT(vpu_base_enc, "input buffer not physically contiguous - frame copy is necessary");
if (vpu_base_enc->internal_input_buffer == NULL)
{
/* The internal input buffer is the temp input frame's DMA memory.
* If it does not exist yet, it needs to be created here. The temp input
* frame is then mapped. */
GstFlowReturn flow_ret;
if (vpu_base_enc->internal_bufferpool == NULL)
{
/* Internal bufferpool does not exist yet - create it now,
* so that it can in turn create the internal input buffer */
GstStructure *config;
GstCaps *caps;
GstAllocator *allocator;
GST_DEBUG_OBJECT(vpu_base_enc, "creating internal bufferpool");
caps = gst_video_info_to_caps(&(vpu_base_enc->video_info));
vpu_base_enc->internal_bufferpool = gst_imx_phys_mem_buffer_pool_new(FALSE);
allocator = gst_imx_vpu_enc_allocator_obtain();
config = gst_buffer_pool_get_config(vpu_base_enc->internal_bufferpool);
gst_buffer_pool_config_set_params(config, caps, vpu_base_enc->video_info.size, 2, 0);
gst_buffer_pool_config_set_allocator(config, allocator, NULL);
gst_buffer_pool_config_add_option(config, GST_BUFFER_POOL_OPTION_IMX_PHYS_MEM);
gst_buffer_pool_config_add_option(config, GST_BUFFER_POOL_OPTION_VIDEO_META);
gst_buffer_pool_set_config(vpu_base_enc->internal_bufferpool, config);
gst_caps_unref(caps);
if (vpu_base_enc->internal_bufferpool == NULL)
{
GST_ERROR_OBJECT(vpu_base_enc, "failed to create internal bufferpool");
return GST_FLOW_ERROR;
}
}
/* Future versions of this code may propose the internal bufferpool upstream;
* hence the is_active check */
if (!gst_buffer_pool_is_active(vpu_base_enc->internal_bufferpool))
gst_buffer_pool_set_active(vpu_base_enc->internal_bufferpool, TRUE);
/* Create the internal input buffer */
flow_ret = gst_buffer_pool_acquire_buffer(vpu_base_enc->internal_bufferpool, &(vpu_base_enc->internal_input_buffer), NULL);
if (flow_ret != GST_FLOW_OK)
{
GST_ERROR_OBJECT(vpu_base_enc, "error acquiring input frame buffer: %s", gst_pad_mode_get_name(flow_ret));
return flow_ret;
}
}
/* The internal input buffer exists at this point. Since the incoming frame
* is not stored in physical memory, copy its pixels to the internal
* input buffer, so the encoder can read them. */
gst_video_frame_map(&temp_incoming_video_frame, &(vpu_base_enc->video_info), frame->input_buffer, GST_MAP_READ);
gst_video_frame_map(&temp_input_video_frame, &(vpu_base_enc->video_info), vpu_base_enc->internal_input_buffer, GST_MAP_WRITE);
gst_video_frame_copy(&temp_input_video_frame, &temp_incoming_video_frame);
gst_video_frame_unmap(&temp_incoming_video_frame);
gst_video_frame_unmap(&temp_input_video_frame);
/* Set the internal input buffer as the encoder's input */
input_buffer = vpu_base_enc->internal_input_buffer;
/* And use the internal input buffer's physical memory metadata */
phys_mem_meta = GST_IMX_PHYS_MEM_META_GET(vpu_base_enc->internal_input_buffer);
}
else
{
/* Physical memory metadata found -> buffer is physically contiguous
* It can be used directly as input for the VPU encoder */
input_buffer = frame->input_buffer;
}
/* Set up physical addresses for the input framebuffer */
{
gsize *plane_offsets;
gint *plane_strides;
GstVideoMeta *video_meta;
unsigned char *phys_ptr;
/* Try to use plane offset and stride information from the video
* metadata if present, since these can be more accurate than
* the information from the video info */
video_meta = gst_buffer_get_video_meta(input_buffer);
if (video_meta != NULL)
{
plane_offsets = video_meta->offset;
plane_strides = video_meta->stride;
}
else
{
plane_offsets = vpu_base_enc->video_info.offset;
plane_strides = vpu_base_enc->video_info.stride;
}
phys_ptr = (unsigned char*)(phys_mem_meta->phys_addr);
input_framebuf.pbufY = phys_ptr;
input_framebuf.pbufCb = phys_ptr + plane_offsets[1];
input_framebuf.pbufCr = phys_ptr + plane_offsets[2];
input_framebuf.pbufMvCol = NULL; /* not used by the VPU encoder */
input_framebuf.nStrideY = plane_strides[0];
input_framebuf.nStrideC = plane_strides[1];
/* this is needed for framebuffers registration below */
src_stride = plane_strides[0];
GST_TRACE_OBJECT(vpu_base_enc, "width: %d height: %d stride 0: %d stride 1: %d offset 0: %d offset 1: %d offset 2: %d", GST_VIDEO_INFO_WIDTH(&(vpu_base_enc->video_info)), GST_VIDEO_INFO_HEIGHT(&(vpu_base_enc->video_info)), plane_strides[0], plane_strides[1], plane_offsets[0], plane_offsets[1], plane_offsets[2]);
}
/* Create framebuffers structure (if not already present) */
if (vpu_base_enc->framebuffers == NULL)
{
GstImxVpuFramebufferParams fbparams;
gst_imx_vpu_framebuffers_enc_init_info_to_params(&(vpu_base_enc->init_info), &fbparams);
fbparams.pic_width = vpu_base_enc->open_param.nPicWidth;
fbparams.pic_height = vpu_base_enc->open_param.nPicHeight;
vpu_base_enc->framebuffers = gst_imx_vpu_framebuffers_new(&fbparams, gst_imx_vpu_enc_allocator_obtain());
if (vpu_base_enc->framebuffers == NULL)
{
GST_ELEMENT_ERROR(vpu_base_enc, RESOURCE, NO_SPACE_LEFT, ("could not create framebuffers structure"), (NULL));
return GST_FLOW_ERROR;
}
gst_imx_vpu_framebuffers_register_with_encoder(vpu_base_enc->framebuffers, vpu_base_enc->handle, src_stride);
}
/* Allocate physical buffer for output data (if not already present) */
if (vpu_base_enc->output_phys_buffer == NULL)
{
vpu_base_enc->output_phys_buffer = (GstImxPhysMemory *)gst_allocator_alloc(gst_imx_vpu_enc_allocator_obtain(), vpu_base_enc->framebuffers->total_size, NULL);
if (vpu_base_enc->output_phys_buffer == NULL)
{
GST_ERROR_OBJECT(vpu_base_enc, "could not allocate physical buffer for output data");
return GST_FLOW_ERROR;
}
}
/* Set up encoding parameters */
enc_enc_param.nInVirtOutput = (unsigned int)(vpu_base_enc->output_phys_buffer->mapped_virt_addr); /* TODO */
enc_enc_param.nInPhyOutput = (unsigned int)(vpu_base_enc->output_phys_buffer->phys_addr);
enc_enc_param.nInOutputBufLen = vpu_base_enc->output_phys_buffer->mem.size;
enc_enc_param.nPicWidth = vpu_base_enc->framebuffers->pic_width;
enc_enc_param.nPicHeight = vpu_base_enc->framebuffers->pic_height;
enc_enc_param.nFrameRate = vpu_base_enc->open_param.nFrameRate;
enc_enc_param.pInFrame = &input_framebuf;
enc_enc_param.nForceIPicture = 0;
/* Force I-frame if either IS_FORCE_KEYFRAME or IS_FORCE_KEYFRAME_HEADERS is set for the current frame. */
if (GST_VIDEO_CODEC_FRAME_IS_FORCE_KEYFRAME(frame) || GST_VIDEO_CODEC_FRAME_IS_FORCE_KEYFRAME_HEADERS(frame))
{
enc_enc_param.nForceIPicture = 1;
GST_LOG_OBJECT(vpu_base_enc, "got request to make this a keyframe - forcing I frame");
GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT(frame);
}
/* Give the derived class a chance to set up encoding parameters too */
if (!klass->set_frame_enc_params(vpu_base_enc, &enc_enc_param, &(vpu_base_enc->open_param)))
{
GST_ERROR_OBJECT(vpu_base_enc, "derived class could not frame enc params");
return GST_FLOW_ERROR;
}
/* Main encoding block */
{
GstBuffer *output_buffer = NULL;
gsize output_buffer_offset = 0;
gboolean frame_finished = FALSE;
frame->output_buffer = NULL;
/* Run in a loop until the VPU reports the input as used */
do
{
/* Feed input data */
enc_ret = VPU_EncEncodeFrame(vpu_base_enc->handle, &enc_enc_param);
if (enc_ret != VPU_ENC_RET_SUCCESS)
{
GST_ERROR_OBJECT(vpu_base_enc, "failed to encode frame: %s", gst_imx_vpu_strerror(enc_ret));
VPU_EncReset(vpu_base_enc->handle);
return GST_FLOW_ERROR;
}
if (frame_finished)
{
GST_WARNING_OBJECT(vpu_base_enc, "frame was already finished for the current input, but input not yet marked as used");
continue;
}
if (enc_enc_param.eOutRetCode & (VPU_ENC_OUTPUT_DIS | VPU_ENC_OUTPUT_SEQHEADER))
{
/* Create an output buffer on demand */
if (output_buffer == NULL)
{
output_buffer = gst_video_encoder_allocate_output_buffer(
encoder,
vpu_base_enc->output_phys_buffer->mem.size
);
frame->output_buffer = output_buffer;
}
GST_LOG_OBJECT(vpu_base_enc, "processing output data: %u bytes, output buffer offset %u", enc_enc_param.nOutOutputSize, output_buffer_offset);
if (klass->fill_output_buffer != NULL)
{
/* Derived class fills data on its own */
gsize cur_offset = output_buffer_offset;
output_buffer_offset += klass->fill_output_buffer(
vpu_base_enc,
frame,
cur_offset,
vpu_base_enc->output_phys_buffer->mapped_virt_addr,
enc_enc_param.nOutOutputSize,
enc_enc_param.eOutRetCode & VPU_ENC_OUTPUT_SEQHEADER
);
}
else
{
/* Use default data filling (= copy input to output) */
gst_buffer_fill(
output_buffer,
output_buffer_offset,
vpu_base_enc->output_phys_buffer->mapped_virt_addr,
enc_enc_param.nOutOutputSize
);
output_buffer_offset += enc_enc_param.nOutOutputSize;
}
if (enc_enc_param.eOutRetCode & VPU_ENC_OUTPUT_DIS)
{
g_assert(output_buffer != NULL);
/* Set the output buffer's size to the actual number of bytes
* filled by the derived class */
gst_buffer_set_size(output_buffer, output_buffer_offset);
/* Set the frame DTS */
frame->dts = frame->pts;
/* And finish the frame, handing the output data over to the base class */
gst_video_encoder_finish_frame(encoder, frame);
output_buffer = NULL;
frame_finished = TRUE;
if (!(enc_enc_param.eOutRetCode & VPU_ENC_INPUT_USED))
GST_WARNING_OBJECT(vpu_base_enc, "frame finished, but VPU did not report the input as used");
break;
}
}
}
while (!(enc_enc_param.eOutRetCode & VPU_ENC_INPUT_USED)); /* VPU_ENC_INPUT_NOT_USED has value 0x0 - cannot use it for flag checks */
/* If output_buffer is NULL at this point, it means VPU_ENC_OUTPUT_DIS was never communicated
* by the VPU, and the buffer is unfinished. -> Drop it. */
if (output_buffer != NULL)
{
GST_WARNING_OBJECT(vpu_base_enc, "frame unfinished ; dropping");
gst_buffer_unref(output_buffer);
frame->output_buffer = NULL; /* necessary to make finish_frame() drop the frame */
gst_video_encoder_finish_frame(encoder, frame);
}
}
return GST_FLOW_OK;
}
static GstFlowReturn
gst_y4m_dec_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{
GstY4mDec *y4mdec;
int n_avail;
GstFlowReturn flow_ret = GST_FLOW_OK;
#define MAX_HEADER_LENGTH 80
char header[MAX_HEADER_LENGTH];
int i;
int len;
y4mdec = GST_Y4M_DEC (parent);
GST_DEBUG_OBJECT (y4mdec, "chain");
if (GST_BUFFER_IS_DISCONT (buffer)) {
GST_DEBUG ("got discont");
gst_adapter_clear (y4mdec->adapter);
}
gst_adapter_push (y4mdec->adapter, buffer);
n_avail = gst_adapter_available (y4mdec->adapter);
if (!y4mdec->have_header) {
gboolean ret;
GstCaps *caps;
GstQuery *query;
if (n_avail < MAX_HEADER_LENGTH)
return GST_FLOW_OK;
gst_adapter_copy (y4mdec->adapter, (guint8 *) header, 0, MAX_HEADER_LENGTH);
header[MAX_HEADER_LENGTH - 1] = 0;
for (i = 0; i < MAX_HEADER_LENGTH; i++) {
if (header[i] == 0x0a)
header[i] = 0;
}
ret = gst_y4m_dec_parse_header (y4mdec, header);
if (!ret) {
GST_ELEMENT_ERROR (y4mdec, STREAM, DECODE,
("Failed to parse YUV4MPEG header"), (NULL));
return GST_FLOW_ERROR;
}
y4mdec->header_size = strlen (header) + 1;
gst_adapter_flush (y4mdec->adapter, y4mdec->header_size);
caps = gst_video_info_to_caps (&y4mdec->info);
ret = gst_pad_set_caps (y4mdec->srcpad, caps);
query = gst_query_new_allocation (caps, FALSE);
y4mdec->video_meta = FALSE;
if (y4mdec->pool) {
gst_buffer_pool_set_active (y4mdec->pool, FALSE);
gst_object_unref (y4mdec->pool);
}
y4mdec->pool = NULL;
if (gst_pad_peer_query (y4mdec->srcpad, query)) {
y4mdec->video_meta =
gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
/* We only need a pool if we need to do stride conversion for downstream */
if (!y4mdec->video_meta && memcmp (&y4mdec->info, &y4mdec->out_info,
sizeof (y4mdec->info)) != 0) {
GstBufferPool *pool = NULL;
GstAllocator *allocator = NULL;
GstAllocationParams params;
GstStructure *config;
guint size, min, max;
if (gst_query_get_n_allocation_params (query) > 0) {
gst_query_parse_nth_allocation_param (query, 0, &allocator, ¶ms);
} else {
allocator = NULL;
gst_allocation_params_init (¶ms);
}
if (gst_query_get_n_allocation_pools (query) > 0) {
gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min,
&max);
size = MAX (size, y4mdec->out_info.size);
} else {
pool = NULL;
size = y4mdec->out_info.size;
min = max = 0;
}
if (pool == NULL) {
pool = gst_video_buffer_pool_new ();
}
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, min, max);
gst_buffer_pool_config_set_allocator (config, allocator, ¶ms);
gst_buffer_pool_set_config (pool, config);
if (allocator)
gst_object_unref (allocator);
y4mdec->pool = pool;
}
} else if (memcmp (&y4mdec->info, &y4mdec->out_info,
sizeof (y4mdec->info)) != 0) {
GstBufferPool *pool;
GstStructure *config;
/* No pool, create our own if we need to do stride conversion */
pool = gst_video_buffer_pool_new ();
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, y4mdec->out_info.size, 0,
0);
gst_buffer_pool_set_config (pool, config);
y4mdec->pool = pool;
}
if (y4mdec->pool) {
gst_buffer_pool_set_active (y4mdec->pool, TRUE);
}
gst_query_unref (query);
gst_caps_unref (caps);
if (!ret) {
GST_DEBUG_OBJECT (y4mdec, "Couldn't set caps on src pad");
return GST_FLOW_ERROR;
}
y4mdec->have_header = TRUE;
}
if (y4mdec->have_new_segment) {
GstEvent *event;
GstClockTime start = gst_y4m_dec_bytes_to_timestamp (y4mdec,
y4mdec->segment.start);
GstClockTime stop = gst_y4m_dec_bytes_to_timestamp (y4mdec,
y4mdec->segment.stop);
GstClockTime time = gst_y4m_dec_bytes_to_timestamp (y4mdec,
y4mdec->segment.time);
GstSegment seg;
gst_segment_init (&seg, GST_FORMAT_TIME);
seg.start = start;
seg.stop = stop;
seg.time = time;
event = gst_event_new_segment (&seg);
gst_pad_push_event (y4mdec->srcpad, event);
//gst_event_unref (event);
y4mdec->have_new_segment = FALSE;
y4mdec->frame_index = gst_y4m_dec_bytes_to_frames (y4mdec,
y4mdec->segment.time);
GST_DEBUG ("new frame_index %d", y4mdec->frame_index);
}
while (1) {
n_avail = gst_adapter_available (y4mdec->adapter);
if (n_avail < MAX_HEADER_LENGTH)
break;
gst_adapter_copy (y4mdec->adapter, (guint8 *) header, 0, MAX_HEADER_LENGTH);
header[MAX_HEADER_LENGTH - 1] = 0;
for (i = 0; i < MAX_HEADER_LENGTH; i++) {
if (header[i] == 0x0a)
header[i] = 0;
}
if (memcmp (header, "FRAME", 5) != 0) {
GST_ELEMENT_ERROR (y4mdec, STREAM, DECODE,
("Failed to parse YUV4MPEG frame"), (NULL));
flow_ret = GST_FLOW_ERROR;
break;
}
len = strlen (header);
if (n_avail < y4mdec->info.size + len + 1) {
/* not enough data */
GST_DEBUG ("not enough data for frame %d < %" G_GSIZE_FORMAT,
n_avail, y4mdec->info.size + len + 1);
break;
}
gst_adapter_flush (y4mdec->adapter, len + 1);
buffer = gst_adapter_take_buffer (y4mdec->adapter, y4mdec->info.size);
GST_BUFFER_TIMESTAMP (buffer) =
gst_y4m_dec_frames_to_timestamp (y4mdec, y4mdec->frame_index);
GST_BUFFER_DURATION (buffer) =
gst_y4m_dec_frames_to_timestamp (y4mdec, y4mdec->frame_index + 1) -
GST_BUFFER_TIMESTAMP (buffer);
y4mdec->frame_index++;
if (y4mdec->video_meta) {
gst_buffer_add_video_meta_full (buffer, 0, y4mdec->info.finfo->format,
y4mdec->info.width, y4mdec->info.height, y4mdec->info.finfo->n_planes,
y4mdec->info.offset, y4mdec->info.stride);
} else if (memcmp (&y4mdec->info, &y4mdec->out_info,
sizeof (y4mdec->info)) != 0) {
GstBuffer *outbuf;
GstVideoFrame iframe, oframe;
gint i, j;
gint w, h, istride, ostride;
guint8 *src, *dest;
/* Allocate a new buffer and do stride conversion */
g_assert (y4mdec->pool != NULL);
flow_ret = gst_buffer_pool_acquire_buffer (y4mdec->pool, &outbuf, NULL);
if (flow_ret != GST_FLOW_OK) {
gst_buffer_unref (buffer);
break;
}
gst_video_frame_map (&iframe, &y4mdec->info, buffer, GST_MAP_READ);
gst_video_frame_map (&oframe, &y4mdec->out_info, outbuf, GST_MAP_WRITE);
for (i = 0; i < 3; i++) {
w = GST_VIDEO_FRAME_COMP_WIDTH (&iframe, i);
h = GST_VIDEO_FRAME_COMP_HEIGHT (&iframe, i);
istride = GST_VIDEO_FRAME_COMP_STRIDE (&iframe, i);
ostride = GST_VIDEO_FRAME_COMP_STRIDE (&oframe, i);
src = GST_VIDEO_FRAME_COMP_DATA (&iframe, i);
dest = GST_VIDEO_FRAME_COMP_DATA (&oframe, i);
for (j = 0; j < h; j++) {
memcpy (dest, src, w);
dest += ostride;
src += istride;
}
}
gst_video_frame_unmap (&iframe);
gst_video_frame_unmap (&oframe);
gst_buffer_copy_into (outbuf, buffer, GST_BUFFER_COPY_TIMESTAMPS, 0, -1);
gst_buffer_unref (buffer);
buffer = outbuf;
}
flow_ret = gst_pad_push (y4mdec->srcpad, buffer);
if (flow_ret != GST_FLOW_OK)
break;
}
GST_DEBUG ("returning %d", flow_ret);
return flow_ret;
}
static GstFlowReturn gst_imx_vpu_encoder_base_handle_frame(GstVideoEncoder *encoder, GstVideoCodecFrame *input_frame)
{
GstImxPhysMemMeta *phys_mem_meta;
GstImxVpuEncoderBaseClass *klass;
GstImxVpuEncoderBase *vpu_encoder_base;
GstBuffer *input_buffer;
ImxVpuEncParams enc_params;
vpu_encoder_base = GST_IMX_VPU_ENCODER_BASE(encoder);
klass = GST_IMX_VPU_ENCODER_BASE_CLASS(G_OBJECT_GET_CLASS(vpu_encoder_base));
if (vpu_encoder_base->drop)
{
input_frame->output_buffer = NULL; /* necessary to make finish_frame() drop the frame */
gst_video_encoder_finish_frame(encoder, input_frame);
return GST_FLOW_OK;
}
/* Get access to the input buffer's physical address */
phys_mem_meta = GST_IMX_PHYS_MEM_META_GET(input_frame->input_buffer);
/* If the incoming frame's buffer is not using physically contiguous memory,
* it needs to be copied to the internal input buffer, otherwise the VPU
* encoder cannot read the frame */
if (phys_mem_meta == NULL)
{
/* No physical memory metadata found -> buffer is not physically contiguous */
GstVideoFrame temp_input_video_frame, temp_incoming_video_frame;
GST_LOG_OBJECT(vpu_encoder_base, "input buffer not physically contiguous - frame copy is necessary");
if (vpu_encoder_base->internal_input_buffer == NULL)
{
/* The internal input buffer is the temp input frame's DMA memory.
* If it does not exist yet, it needs to be created here. The temp input
* frame is then mapped. */
GstFlowReturn flow_ret;
if (vpu_encoder_base->internal_input_bufferpool == NULL)
{
/* Internal bufferpool does not exist yet - create it now,
* so that it can in turn create the internal input buffer */
GstStructure *config;
GstCaps *caps;
GST_DEBUG_OBJECT(vpu_encoder_base, "creating internal bufferpool");
caps = gst_video_info_to_caps(&(vpu_encoder_base->video_info));
vpu_encoder_base->internal_input_bufferpool = gst_imx_phys_mem_buffer_pool_new(FALSE);
gst_object_ref(vpu_encoder_base->phys_mem_allocator);
config = gst_buffer_pool_get_config(vpu_encoder_base->internal_input_bufferpool);
gst_buffer_pool_config_set_params(config, caps, vpu_encoder_base->video_info.size, 2, 0);
gst_buffer_pool_config_set_allocator(config, vpu_encoder_base->phys_mem_allocator, NULL);
gst_buffer_pool_config_add_option(config, GST_BUFFER_POOL_OPTION_IMX_PHYS_MEM);
gst_buffer_pool_config_add_option(config, GST_BUFFER_POOL_OPTION_VIDEO_META);
gst_buffer_pool_set_config(vpu_encoder_base->internal_input_bufferpool, config);
gst_caps_unref(caps);
if (vpu_encoder_base->internal_input_bufferpool == NULL)
{
GST_ERROR_OBJECT(vpu_encoder_base, "failed to create internal bufferpool");
return GST_FLOW_ERROR;
}
}
/* Future versions of this code may propose the internal bufferpool upstream;
* hence the is_active check */
if (!gst_buffer_pool_is_active(vpu_encoder_base->internal_input_bufferpool))
gst_buffer_pool_set_active(vpu_encoder_base->internal_input_bufferpool, TRUE);
/* Create the internal input buffer */
flow_ret = gst_buffer_pool_acquire_buffer(vpu_encoder_base->internal_input_bufferpool, &(vpu_encoder_base->internal_input_buffer), NULL);
if (flow_ret != GST_FLOW_OK)
{
GST_ERROR_OBJECT(vpu_encoder_base, "error acquiring input frame buffer: %s", gst_pad_mode_get_name(flow_ret));
return flow_ret;
}
}
/* The internal input buffer exists at this point. Since the incoming frame
* is not stored in physical memory, copy its pixels to the internal
* input buffer, so the encoder can read them. */
gst_video_frame_map(&temp_incoming_video_frame, &(vpu_encoder_base->video_info), input_frame->input_buffer, GST_MAP_READ);
gst_video_frame_map(&temp_input_video_frame, &(vpu_encoder_base->video_info), vpu_encoder_base->internal_input_buffer, GST_MAP_WRITE);
gst_video_frame_copy(&temp_input_video_frame, &temp_incoming_video_frame);
gst_video_frame_unmap(&temp_incoming_video_frame);
gst_video_frame_unmap(&temp_input_video_frame);
/* Set the input buffer as the encoder's input */
input_buffer = vpu_encoder_base->internal_input_buffer;
/* And use the input buffer's physical memory metadata */
phys_mem_meta = GST_IMX_PHYS_MEM_META_GET(vpu_encoder_base->internal_input_buffer);
}
else
{
/* Physical memory metadata found -> buffer is physically contiguous
* It can be used directly as input for the VPU encoder */
input_buffer = input_frame->input_buffer;
}
/* Prepare the input buffer's information (strides, plane offsets ..) for encoding */
{
GstVideoMeta *video_meta;
/* Try to use plane offset and stride information from the video
* metadata if present, since these can be more accurate than
* the information from the video info */
video_meta = gst_buffer_get_video_meta(input_buffer);
if (video_meta != NULL)
{
vpu_encoder_base->input_framebuffer.y_stride = video_meta->stride[0];
vpu_encoder_base->input_framebuffer.cbcr_stride = video_meta->stride[1];
vpu_encoder_base->input_framebuffer.y_offset = video_meta->offset[0];
vpu_encoder_base->input_framebuffer.cb_offset = video_meta->offset[1];
vpu_encoder_base->input_framebuffer.cr_offset = video_meta->offset[2];
}
else
{
vpu_encoder_base->input_framebuffer.y_stride = GST_VIDEO_INFO_PLANE_STRIDE(&(vpu_encoder_base->video_info), 0);
vpu_encoder_base->input_framebuffer.cbcr_stride = GST_VIDEO_INFO_PLANE_STRIDE(&(vpu_encoder_base->video_info), 1);
vpu_encoder_base->input_framebuffer.y_offset = GST_VIDEO_INFO_PLANE_OFFSET(&(vpu_encoder_base->video_info), 0);
vpu_encoder_base->input_framebuffer.cb_offset = GST_VIDEO_INFO_PLANE_OFFSET(&(vpu_encoder_base->video_info), 1);
vpu_encoder_base->input_framebuffer.cr_offset = GST_VIDEO_INFO_PLANE_OFFSET(&(vpu_encoder_base->video_info), 2);
}
vpu_encoder_base->input_framebuffer.mvcol_offset = 0; /* this is not used by the encoder */
vpu_encoder_base->input_framebuffer.context = (void *)(input_frame->system_frame_number);
vpu_encoder_base->input_dmabuffer.fd = -1;
vpu_encoder_base->input_dmabuffer.physical_address = phys_mem_meta->phys_addr;
vpu_encoder_base->input_dmabuffer.size = gst_buffer_get_size(input_buffer);
}
/* Prepare the encoding parameters */
memset(&enc_params, 0, sizeof(enc_params));
imx_vpu_enc_set_default_encoding_params(vpu_encoder_base->encoder, &enc_params);
enc_params.force_I_frame = 0;
enc_params.acquire_output_buffer = gst_imx_vpu_encoder_base_acquire_output_buffer;
enc_params.finish_output_buffer = gst_imx_vpu_encoder_base_finish_output_buffer;
enc_params.output_buffer_context = vpu_encoder_base;
/* Force I-frame if either IS_FORCE_KEYFRAME or IS_FORCE_KEYFRAME_HEADERS is set for the current frame. */
if (GST_VIDEO_CODEC_FRAME_IS_FORCE_KEYFRAME(input_frame) || GST_VIDEO_CODEC_FRAME_IS_FORCE_KEYFRAME_HEADERS(input_frame))
{
enc_params.force_I_frame = 1;
GST_LOG_OBJECT(vpu_encoder_base, "got request to make this a keyframe - forcing I frame");
GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT(input_frame);
}
/* Give the derived class a chance to set up encoding parameters too */
if ((klass->set_frame_enc_params != NULL) && !klass->set_frame_enc_params(vpu_encoder_base, &enc_params))
{
GST_ERROR_OBJECT(vpu_encoder_base, "derived class could not frame enc params");
return GST_FLOW_ERROR;
}
/* Main encoding block */
{
ImxVpuEncReturnCodes enc_ret;
unsigned int output_code = 0;
ImxVpuEncodedFrame encoded_data_frame;
vpu_encoder_base->output_buffer = NULL;
/* The actual encoding call */
memset(&encoded_data_frame, 0, sizeof(ImxVpuEncodedFrame));
enc_ret = imx_vpu_enc_encode(vpu_encoder_base->encoder, &(vpu_encoder_base->input_frame), &encoded_data_frame, &enc_params, &output_code);
if (enc_ret != IMX_VPU_ENC_RETURN_CODE_OK)
{
GST_ERROR_OBJECT(vpu_encoder_base, "failed to encode frame: %s", imx_vpu_enc_error_string(enc_ret));
if (vpu_encoder_base->output_buffer != NULL)
gst_buffer_unref(vpu_encoder_base->output_buffer);
return GST_FLOW_ERROR;
}
/* Give the derived class a chance to process the output_block_buffer */
if ((klass->process_output_buffer != NULL) && !klass->process_output_buffer(vpu_encoder_base, input_frame, &(vpu_encoder_base->output_buffer)))
{
GST_ERROR_OBJECT(vpu_encoder_base, "derived class reports failure while processing encoded output");
if (vpu_encoder_base->output_buffer != NULL)
gst_buffer_unref(vpu_encoder_base->output_buffer);
return GST_FLOW_ERROR;
}
if (output_code & IMX_VPU_ENC_OUTPUT_CODE_ENCODED_FRAME_AVAILABLE)
{
GST_LOG_OBJECT(vpu_encoder_base, "VPU outputs encoded frame");
/* TODO: make use of the frame context that is retrieved with get_frame(i)
* This is not strictly necessary, since the VPU encoder does not
* do frame reordering, nor does it produce delays, but it would
* be a bit cleaner. */
input_frame->dts = input_frame->pts;
/* Take all of the encoded bits. The adapter contains an encoded frame
* at this point. */
input_frame->output_buffer = vpu_encoder_base->output_buffer;
/* And finish the frame, handing the output data over to the base class */
gst_video_encoder_finish_frame(encoder, input_frame);
}
else
{
/* If at this point IMX_VPU_ENC_OUTPUT_CODE_ENCODED_FRAME_AVAILABLE is not set
* in the output_code, it means the input was used up before a frame could be
* encoded. Therefore, no output frame can be pushed downstream. Note that this
* should not happen during normal operation, so a warning is logged. */
if (vpu_encoder_base->output_buffer != NULL)
gst_buffer_unref(vpu_encoder_base->output_buffer);
GST_WARNING_OBJECT(vpu_encoder_base, "frame unfinished ; dropping");
input_frame->output_buffer = NULL; /* necessary to make finish_frame() drop the frame */
gst_video_encoder_finish_frame(encoder, input_frame);
}
}
return GST_FLOW_OK;
}
static GstBufferPool *
gst_msdkdec_create_buffer_pool (GstMsdkDec * thiz, GstVideoInfo * info,
guint num_buffers)
{
GstBufferPool *pool = NULL;
GstStructure *config;
GstAllocator *allocator = NULL;
GstVideoAlignment align;
GstCaps *caps = NULL;
GstAllocationParams params = { 0, 31, 0, 0, };
mfxFrameAllocResponse *alloc_resp = NULL;
g_return_val_if_fail (info, NULL);
g_return_val_if_fail (GST_VIDEO_INFO_WIDTH (info)
&& GST_VIDEO_INFO_HEIGHT (info), NULL);
alloc_resp = &thiz->alloc_resp;
pool = gst_msdk_buffer_pool_new (thiz->context, alloc_resp);
if (!pool)
goto error_no_pool;
if (G_UNLIKELY (!IS_ALIGNED (GST_VIDEO_INFO_WIDTH (info), 16)
|| !IS_ALIGNED (GST_VIDEO_INFO_HEIGHT (info), 32))) {
gst_msdk_set_video_alignment (info, &align);
gst_video_info_align (info, &align);
}
caps = gst_video_info_to_caps (info);
/* allocators should use the same width/height/stride/height_alignment of
* negotiated output caps which is what we configure in msdk_allocator */
if (thiz->use_dmabuf)
allocator = gst_msdk_dmabuf_allocator_new (thiz->context, info, alloc_resp);
else if (thiz->use_video_memory)
allocator = gst_msdk_video_allocator_new (thiz->context, info, alloc_resp);
else
allocator = gst_msdk_system_allocator_new (info);
if (!allocator)
goto error_no_allocator;
config = gst_buffer_pool_get_config (GST_BUFFER_POOL_CAST (pool));
gst_buffer_pool_config_set_params (config, caps,
GST_VIDEO_INFO_SIZE (info), num_buffers, 0);
gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
if (thiz->use_video_memory) {
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_MSDK_USE_VIDEO_MEMORY);
if (thiz->use_dmabuf)
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_MSDK_USE_DMABUF);
}
gst_buffer_pool_config_set_video_alignment (config, &align);
gst_buffer_pool_config_set_allocator (config, allocator, ¶ms);
gst_object_unref (allocator);
if (!gst_buffer_pool_set_config (pool, config))
goto error_pool_config;
return pool;
error_no_pool:
{
GST_INFO_OBJECT (thiz, "failed to create bufferpool");
return NULL;
}
error_no_allocator:
{
GST_INFO_OBJECT (thiz, "failed to create allocator");
gst_object_unref (pool);
return NULL;
}
error_pool_config:
{
GST_INFO_OBJECT (thiz, "failed to set config");
gst_object_unref (pool);
gst_object_unref (allocator);
return NULL;
}
}
