mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-10-05 18:22:23 +00:00
omxvideodec: Add buffer pool for sharing OpenMAX memory with downstream
This commit is contained in:
parent
7a1eaec3b9
commit
0cd96e8c6b
2 changed files with 881 additions and 19 deletions
|
@ -32,6 +32,614 @@
|
||||||
GST_DEBUG_CATEGORY_STATIC (gst_omx_video_dec_debug_category);
|
GST_DEBUG_CATEGORY_STATIC (gst_omx_video_dec_debug_category);
|
||||||
#define GST_CAT_DEFAULT gst_omx_video_dec_debug_category
|
#define GST_CAT_DEFAULT gst_omx_video_dec_debug_category
|
||||||
|
|
||||||
|
typedef struct _GstOMXMemory GstOMXMemory;
|
||||||
|
typedef struct _GstOMXMemoryAllocator GstOMXMemoryAllocator;
|
||||||
|
typedef struct _GstOMXMemoryAllocatorClass GstOMXMemoryAllocatorClass;
|
||||||
|
|
||||||
|
struct _GstOMXMemory
|
||||||
|
{
|
||||||
|
GstMemory mem;
|
||||||
|
|
||||||
|
GstOMXBuffer *buf;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct _GstOMXMemoryAllocator
|
||||||
|
{
|
||||||
|
GstAllocator parent;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct _GstOMXMemoryAllocatorClass
|
||||||
|
{
|
||||||
|
GstAllocatorClass parent_class;
|
||||||
|
};
|
||||||
|
|
||||||
|
#define GST_OMX_MEMORY_TYPE "openmax"
|
||||||
|
|
||||||
|
static GstMemory *
|
||||||
|
gst_omx_memory_allocator_alloc_dummy (GstAllocator * allocator, gsize size,
|
||||||
|
GstAllocationParams * params)
|
||||||
|
{
|
||||||
|
g_assert_not_reached ();
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_omx_memory_allocator_free (GstAllocator * allocator, GstMemory * mem)
|
||||||
|
{
|
||||||
|
GstOMXMemory *omem = (GstOMXMemory *) mem;
|
||||||
|
|
||||||
|
/* TODO: We need to remember which memories are still used
|
||||||
|
* so we can wait until everything is released before allocating
|
||||||
|
* new memory
|
||||||
|
*/
|
||||||
|
|
||||||
|
g_slice_free (GstOMXMemory, omem);
|
||||||
|
}
|
||||||
|
|
||||||
|
static gpointer
|
||||||
|
gst_omx_memory_map (GstMemory * mem, gsize maxsize, GstMapFlags flags)
|
||||||
|
{
|
||||||
|
GstOMXMemory *omem = (GstOMXMemory *) mem;
|
||||||
|
|
||||||
|
return omem->buf->omx_buf->pBuffer + omem->mem.offset;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_omx_memory_unmap (GstMemory * mem)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
static GstMemory *
|
||||||
|
gst_omx_memory_share (GstMemory * mem, gssize offset, gssize size)
|
||||||
|
{
|
||||||
|
g_assert_not_reached ();
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
GType gst_omx_memory_allocator_get_type (void);
|
||||||
|
G_DEFINE_TYPE (GstOMXMemoryAllocator, gst_omx_memory_allocator,
|
||||||
|
GST_TYPE_ALLOCATOR);
|
||||||
|
|
||||||
|
#define GST_TYPE_OMX_MEMORY_ALLOCATOR (gst_omx_memory_allocator_get_type())
|
||||||
|
#define GST_IS_OMX_MEMORY_ALLOCATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_OMX_MEMORY_ALLOCATOR))
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_omx_memory_allocator_class_init (GstOMXMemoryAllocatorClass * klass)
|
||||||
|
{
|
||||||
|
GstAllocatorClass *allocator_class;
|
||||||
|
|
||||||
|
allocator_class = (GstAllocatorClass *) klass;
|
||||||
|
|
||||||
|
allocator_class->alloc = gst_omx_memory_allocator_alloc_dummy;
|
||||||
|
allocator_class->free = gst_omx_memory_allocator_free;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_omx_memory_allocator_init (GstOMXMemoryAllocator * allocator)
|
||||||
|
{
|
||||||
|
GstAllocator *alloc = GST_ALLOCATOR_CAST (allocator);
|
||||||
|
|
||||||
|
alloc->mem_type = GST_OMX_MEMORY_TYPE;
|
||||||
|
alloc->mem_map = gst_omx_memory_map;
|
||||||
|
alloc->mem_unmap = gst_omx_memory_unmap;
|
||||||
|
alloc->mem_share = gst_omx_memory_share;
|
||||||
|
|
||||||
|
/* default copy & is_span */
|
||||||
|
|
||||||
|
GST_OBJECT_FLAG_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);
|
||||||
|
}
|
||||||
|
|
||||||
|
static GstMemory *
|
||||||
|
gst_omx_memory_allocator_alloc (GstAllocator * allocator, GstMemoryFlags flags,
|
||||||
|
GstOMXBuffer * buf)
|
||||||
|
{
|
||||||
|
GstOMXMemory *mem;
|
||||||
|
|
||||||
|
/* FIXME: We don't allow sharing because we need to know
|
||||||
|
* when the memory becomes unused and can only then put
|
||||||
|
* it back to the pool. Which is done in the pool's release
|
||||||
|
* function
|
||||||
|
*/
|
||||||
|
flags |= GST_MEMORY_FLAG_NO_SHARE;
|
||||||
|
|
||||||
|
mem = g_slice_new (GstOMXMemory);
|
||||||
|
/* the shared memory is always readonly */
|
||||||
|
gst_memory_init (GST_MEMORY_CAST (mem), flags, allocator, NULL,
|
||||||
|
buf->omx_buf->nAllocLen, buf->port->port_def.nBufferAlignment,
|
||||||
|
0, buf->omx_buf->nAllocLen);
|
||||||
|
|
||||||
|
mem->buf = buf;
|
||||||
|
|
||||||
|
return GST_MEMORY_CAST (mem);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Buffer pool for the buffers of an OpenMAX port.
|
||||||
|
*
|
||||||
|
* This pool is only used if we either passed buffers from another
|
||||||
|
* pool to the OMX port or provide the OMX buffers directly to other
|
||||||
|
* elements.
|
||||||
|
*
|
||||||
|
*
|
||||||
|
* A buffer is in the pool if it is currently owned by the port,
|
||||||
|
* i.e. after OMX_{Fill,Empty}ThisBuffer(). A buffer is outside
|
||||||
|
* the pool after it was taken from the port after it was handled
|
||||||
|
* by the port, i.e. {Empty,Fill}BufferDone.
|
||||||
|
*
|
||||||
|
* Buffers can be allocated by us (OMX_AllocateBuffer()) or allocated
|
||||||
|
* by someone else and (temporarily) passed to this pool
|
||||||
|
* (OMX_UseBuffer(), OMX_UseEGLImage()). In the latter case the pool of
|
||||||
|
* the buffer will be overriden, and restored in free_buffer(). Other
|
||||||
|
* buffers are just freed there.
|
||||||
|
*
|
||||||
|
* The pool always has a fixed number of minimum and maximum buffers
|
||||||
|
* and these are allocated while starting the pool and released afterwards.
|
||||||
|
* They correspond 1:1 to the OMX buffers of the port, which are allocated
|
||||||
|
* before the pool is started.
|
||||||
|
*
|
||||||
|
* Acquiring a buffer from this pool happens after the OMX buffer has
|
||||||
|
* been acquired from the port. gst_buffer_pool_acquire_buffer() is
|
||||||
|
* supposed to return the buffer that corresponds to the OMX buffer.
|
||||||
|
*
|
||||||
|
* For buffers provided to upstream, the buffer will be passed to
|
||||||
|
* the component manually when it arrives and then unreffed. If the
|
||||||
|
* buffer is released before reaching the component it will be just put
|
||||||
|
* back into the pool as if EmptyBufferDone has happened. If it was
|
||||||
|
* passed to the component, it will be back into the pool when it was
|
||||||
|
* released and EmptyBufferDone has happened.
|
||||||
|
*
|
||||||
|
* For buffers provided to downstream, the buffer will be returned
|
||||||
|
* back to the component (OMX_FillThisBuffer()) when it is released.
|
||||||
|
*/
|
||||||
|
|
||||||
|
static GQuark gst_omx_buffer_data_quark = 0;
|
||||||
|
|
||||||
|
#define GST_OMX_BUFFER_POOL(pool) ((GstOMXBufferPool *) pool)
|
||||||
|
typedef struct _GstOMXBufferPool GstOMXBufferPool;
|
||||||
|
typedef struct _GstOMXBufferPoolClass GstOMXBufferPoolClass;
|
||||||
|
|
||||||
|
struct _GstOMXBufferPool
|
||||||
|
{
|
||||||
|
GstVideoBufferPool parent;
|
||||||
|
|
||||||
|
GstElement *element;
|
||||||
|
|
||||||
|
GstCaps *caps;
|
||||||
|
gboolean add_videometa;
|
||||||
|
GstVideoInfo video_info;
|
||||||
|
|
||||||
|
/* Owned by element, element has to stop this pool before
|
||||||
|
* it destroys component or port */
|
||||||
|
GstOMXComponent *component;
|
||||||
|
GstOMXPort *port;
|
||||||
|
|
||||||
|
/* For handling OpenMAX allocated memory */
|
||||||
|
GstAllocator *allocator;
|
||||||
|
|
||||||
|
/* Set from outside this pool */
|
||||||
|
/* TRUE if we're currently allocating all our buffers */
|
||||||
|
gboolean allocating;
|
||||||
|
|
||||||
|
/* TRUE if the pool is not used anymore */
|
||||||
|
gboolean deactivated;
|
||||||
|
|
||||||
|
/* For populating the pool from another one */
|
||||||
|
GstBufferPool *other_pool;
|
||||||
|
GPtrArray *buffers;
|
||||||
|
|
||||||
|
/* Used during acquire for output ports to
|
||||||
|
* specify which buffer has to be retrieved
|
||||||
|
* and during alloc, which buffer has to be
|
||||||
|
* wrapped
|
||||||
|
*/
|
||||||
|
gint current_buffer_index;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct _GstOMXBufferPoolClass
|
||||||
|
{
|
||||||
|
GstVideoBufferPoolClass parent_class;
|
||||||
|
};
|
||||||
|
|
||||||
|
GType gst_omx_buffer_pool_get_type (void);
|
||||||
|
|
||||||
|
G_DEFINE_TYPE (GstOMXBufferPool, gst_omx_buffer_pool, GST_TYPE_BUFFER_POOL);
|
||||||
|
|
||||||
|
static gboolean
|
||||||
|
gst_omx_buffer_pool_start (GstBufferPool * bpool)
|
||||||
|
{
|
||||||
|
GstOMXBufferPool *pool = GST_OMX_BUFFER_POOL (bpool);
|
||||||
|
|
||||||
|
/* Only allow to start the pool if we still are attached
|
||||||
|
* to a component and port */
|
||||||
|
GST_OBJECT_LOCK (pool);
|
||||||
|
if (!pool->component || !pool->port) {
|
||||||
|
GST_OBJECT_UNLOCK (pool);
|
||||||
|
return FALSE;
|
||||||
|
}
|
||||||
|
GST_OBJECT_UNLOCK (pool);
|
||||||
|
|
||||||
|
return
|
||||||
|
GST_BUFFER_POOL_CLASS (gst_omx_buffer_pool_parent_class)->start (bpool);
|
||||||
|
}
|
||||||
|
|
||||||
|
static gboolean
|
||||||
|
gst_omx_buffer_pool_stop (GstBufferPool * bpool)
|
||||||
|
{
|
||||||
|
GstOMXBufferPool *pool = GST_OMX_BUFFER_POOL (bpool);
|
||||||
|
|
||||||
|
/* Remove any buffers that are there */
|
||||||
|
g_ptr_array_set_size (pool->buffers, 0);
|
||||||
|
|
||||||
|
if (pool->caps)
|
||||||
|
gst_caps_unref (pool->caps);
|
||||||
|
pool->caps = NULL;
|
||||||
|
|
||||||
|
pool->add_videometa = FALSE;
|
||||||
|
|
||||||
|
return GST_BUFFER_POOL_CLASS (gst_omx_buffer_pool_parent_class)->stop (bpool);
|
||||||
|
}
|
||||||
|
|
||||||
|
static const gchar **
|
||||||
|
gst_omx_buffer_pool_get_options (GstBufferPool * bpool)
|
||||||
|
{
|
||||||
|
static const gchar *raw_video_options[] =
|
||||||
|
{ GST_BUFFER_POOL_OPTION_VIDEO_META, NULL };
|
||||||
|
static const gchar *options[] = { NULL };
|
||||||
|
GstOMXBufferPool *pool = GST_OMX_BUFFER_POOL (bpool);
|
||||||
|
|
||||||
|
GST_OBJECT_LOCK (pool);
|
||||||
|
if (pool->port && pool->port->port_def.eDomain == OMX_PortDomainVideo
|
||||||
|
&& pool->port->port_def.format.video.eCompressionFormat ==
|
||||||
|
OMX_VIDEO_CodingUnused) {
|
||||||
|
GST_OBJECT_UNLOCK (pool);
|
||||||
|
return raw_video_options;
|
||||||
|
}
|
||||||
|
GST_OBJECT_UNLOCK (pool);
|
||||||
|
|
||||||
|
return options;
|
||||||
|
}
|
||||||
|
|
||||||
|
static gboolean
|
||||||
|
gst_omx_buffer_pool_set_config (GstBufferPool * bpool, GstStructure * config)
|
||||||
|
{
|
||||||
|
GstOMXBufferPool *pool = GST_OMX_BUFFER_POOL (bpool);
|
||||||
|
GstCaps *caps;
|
||||||
|
|
||||||
|
GST_OBJECT_LOCK (pool);
|
||||||
|
|
||||||
|
if (!gst_buffer_pool_config_get_params (config, &caps, NULL, NULL, NULL))
|
||||||
|
goto wrong_config;
|
||||||
|
|
||||||
|
if (caps == NULL)
|
||||||
|
goto no_caps;
|
||||||
|
|
||||||
|
if (pool->port && pool->port->port_def.eDomain == OMX_PortDomainVideo
|
||||||
|
&& pool->port->port_def.format.video.eCompressionFormat ==
|
||||||
|
OMX_VIDEO_CodingUnused) {
|
||||||
|
GstVideoInfo info;
|
||||||
|
|
||||||
|
/* now parse the caps from the config */
|
||||||
|
if (!gst_video_info_from_caps (&info, caps))
|
||||||
|
goto wrong_video_caps;
|
||||||
|
|
||||||
|
/* enable metadata based on config of the pool */
|
||||||
|
pool->add_videometa =
|
||||||
|
gst_buffer_pool_config_has_option (config,
|
||||||
|
GST_BUFFER_POOL_OPTION_VIDEO_META);
|
||||||
|
|
||||||
|
pool->video_info = info;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (pool->caps)
|
||||||
|
gst_caps_unref (pool->caps);
|
||||||
|
pool->caps = gst_caps_ref (caps);
|
||||||
|
|
||||||
|
GST_OBJECT_UNLOCK (pool);
|
||||||
|
|
||||||
|
return GST_BUFFER_POOL_CLASS (gst_omx_buffer_pool_parent_class)->set_config
|
||||||
|
(bpool, config);
|
||||||
|
|
||||||
|
/* ERRORS */
|
||||||
|
wrong_config:
|
||||||
|
{
|
||||||
|
GST_OBJECT_UNLOCK (pool);
|
||||||
|
GST_WARNING_OBJECT (pool, "invalid config");
|
||||||
|
return FALSE;
|
||||||
|
}
|
||||||
|
no_caps:
|
||||||
|
{
|
||||||
|
GST_OBJECT_UNLOCK (pool);
|
||||||
|
GST_WARNING_OBJECT (pool, "no caps in config");
|
||||||
|
return FALSE;
|
||||||
|
}
|
||||||
|
wrong_video_caps:
|
||||||
|
{
|
||||||
|
GST_OBJECT_UNLOCK (pool);
|
||||||
|
GST_WARNING_OBJECT (pool,
|
||||||
|
"failed getting geometry from caps %" GST_PTR_FORMAT, caps);
|
||||||
|
return FALSE;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static GstFlowReturn
|
||||||
|
gst_omx_buffer_pool_alloc_buffer (GstBufferPool * bpool,
|
||||||
|
GstBuffer ** buffer, GstBufferPoolAcquireParams * params)
|
||||||
|
{
|
||||||
|
GstOMXBufferPool *pool = GST_OMX_BUFFER_POOL (bpool);
|
||||||
|
GstBuffer *buf;
|
||||||
|
GstOMXBuffer *omx_buf;
|
||||||
|
|
||||||
|
g_return_val_if_fail (pool->allocating, GST_FLOW_ERROR);
|
||||||
|
|
||||||
|
omx_buf = g_ptr_array_index (pool->port->buffers, pool->current_buffer_index);
|
||||||
|
g_return_val_if_fail (omx_buf != NULL, GST_FLOW_ERROR);
|
||||||
|
|
||||||
|
if (pool->other_pool) {
|
||||||
|
guint i, n;
|
||||||
|
|
||||||
|
buf = g_ptr_array_index (pool->buffers, pool->current_buffer_index);
|
||||||
|
g_assert (pool->other_pool == buf->pool);
|
||||||
|
gst_object_replace ((GstObject **) & buf->pool, NULL);
|
||||||
|
|
||||||
|
n = gst_buffer_n_memory (buf);
|
||||||
|
for (i = 0; i < n; i++) {
|
||||||
|
GstMemory *mem = gst_buffer_peek_memory (buf, i);
|
||||||
|
|
||||||
|
/* FIXME: We don't allow sharing because we need to know
|
||||||
|
* when the memory becomes unused and can only then put
|
||||||
|
* it back to the pool. Which is done in the pool's release
|
||||||
|
* function
|
||||||
|
*/
|
||||||
|
GST_MINI_OBJECT_FLAG_SET (mem, GST_MEMORY_FLAG_NO_SHARE);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (pool->add_videometa) {
|
||||||
|
GstVideoMeta *meta;
|
||||||
|
|
||||||
|
meta = gst_buffer_get_video_meta (buf);
|
||||||
|
if (!meta) {
|
||||||
|
gst_buffer_add_video_meta (buf, GST_VIDEO_FRAME_FLAG_NONE,
|
||||||
|
GST_VIDEO_INFO_FORMAT (&pool->video_info),
|
||||||
|
GST_VIDEO_INFO_WIDTH (&pool->video_info),
|
||||||
|
GST_VIDEO_INFO_HEIGHT (&pool->video_info));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
GstMemory *mem;
|
||||||
|
|
||||||
|
mem = gst_omx_memory_allocator_alloc (pool->allocator, 0, omx_buf);
|
||||||
|
buf = gst_buffer_new ();
|
||||||
|
gst_buffer_append_memory (buf, mem);
|
||||||
|
g_ptr_array_add (pool->buffers, buf);
|
||||||
|
|
||||||
|
if (pool->add_videometa) {
|
||||||
|
gsize offset[4] = { 0, };
|
||||||
|
gint stride[4] = { 0, };
|
||||||
|
|
||||||
|
switch (pool->video_info.finfo->format) {
|
||||||
|
case GST_VIDEO_FORMAT_I420:
|
||||||
|
offset[0] = 0;
|
||||||
|
stride[0] = pool->port->port_def.format.video.nStride;
|
||||||
|
offset[1] =
|
||||||
|
stride[0] * pool->port->port_def.format.video.nSliceHeight;
|
||||||
|
stride[1] = pool->port->port_def.format.video.nStride / 2;
|
||||||
|
offset[2] =
|
||||||
|
offset[1] +
|
||||||
|
stride[1] * (pool->port->port_def.format.video.nSliceHeight / 2);
|
||||||
|
stride[2] = pool->port->port_def.format.video.nStride / 2;
|
||||||
|
break;
|
||||||
|
case GST_VIDEO_FORMAT_NV12:
|
||||||
|
offset[0] = 0;
|
||||||
|
stride[0] = pool->port->port_def.format.video.nStride;
|
||||||
|
offset[1] =
|
||||||
|
stride[0] * pool->port->port_def.format.video.nSliceHeight;
|
||||||
|
stride[1] = pool->port->port_def.format.video.nStride;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
g_assert_not_reached ();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
gst_buffer_add_video_meta_full (buf, GST_VIDEO_FRAME_FLAG_NONE,
|
||||||
|
GST_VIDEO_INFO_FORMAT (&pool->video_info),
|
||||||
|
GST_VIDEO_INFO_WIDTH (&pool->video_info),
|
||||||
|
GST_VIDEO_INFO_HEIGHT (&pool->video_info),
|
||||||
|
GST_VIDEO_INFO_N_PLANES (&pool->video_info), offset, stride);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (buf),
|
||||||
|
gst_omx_buffer_data_quark, omx_buf, NULL);
|
||||||
|
|
||||||
|
*buffer = buf;
|
||||||
|
|
||||||
|
pool->current_buffer_index++;
|
||||||
|
|
||||||
|
return GST_FLOW_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_omx_buffer_pool_free_buffer (GstBufferPool * bpool, GstBuffer * buffer)
|
||||||
|
{
|
||||||
|
GstOMXBufferPool *pool = GST_OMX_BUFFER_POOL (bpool);
|
||||||
|
|
||||||
|
/* If the buffers belong to another pool, restore them now */
|
||||||
|
GST_OBJECT_LOCK (pool);
|
||||||
|
if (pool->other_pool) {
|
||||||
|
gst_object_replace ((GstObject **) & buffer->pool,
|
||||||
|
(GstObject *) pool->other_pool);
|
||||||
|
}
|
||||||
|
GST_OBJECT_UNLOCK (pool);
|
||||||
|
|
||||||
|
gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (buffer),
|
||||||
|
gst_omx_buffer_data_quark, NULL, NULL);
|
||||||
|
|
||||||
|
GST_BUFFER_POOL_CLASS (gst_omx_buffer_pool_parent_class)->free_buffer (bpool,
|
||||||
|
buffer);
|
||||||
|
}
|
||||||
|
|
||||||
|
static GstFlowReturn
|
||||||
|
gst_omx_buffer_pool_acquire_buffer (GstBufferPool * bpool,
|
||||||
|
GstBuffer ** buffer, GstBufferPoolAcquireParams * params)
|
||||||
|
{
|
||||||
|
GstFlowReturn ret;
|
||||||
|
GstOMXBufferPool *pool = GST_OMX_BUFFER_POOL (bpool);
|
||||||
|
|
||||||
|
if (pool->port->port_def.eDir == OMX_DirOutput) {
|
||||||
|
GstBuffer *buf;
|
||||||
|
GstBufferPoolAcquireParams int_params = *params;
|
||||||
|
|
||||||
|
int_params.flags |= GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT;
|
||||||
|
|
||||||
|
g_return_val_if_fail (pool->current_buffer_index != -1, GST_FLOW_ERROR);
|
||||||
|
|
||||||
|
buf = g_ptr_array_index (pool->buffers, pool->current_buffer_index);
|
||||||
|
g_return_val_if_fail (buf != NULL, GST_FLOW_ERROR);
|
||||||
|
|
||||||
|
/* FIXME: Add API to GstBufferPool for this */
|
||||||
|
while ((ret =
|
||||||
|
GST_BUFFER_POOL_CLASS
|
||||||
|
(gst_omx_buffer_pool_parent_class)->acquire_buffer (bpool, buffer,
|
||||||
|
&int_params)) != GST_FLOW_EOS) {
|
||||||
|
if (ret != GST_FLOW_OK)
|
||||||
|
return ret;
|
||||||
|
if (*buffer == buf)
|
||||||
|
break;
|
||||||
|
gst_buffer_unref (*buffer);
|
||||||
|
*buffer = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
g_return_val_if_fail (*buffer != NULL, GST_FLOW_ERROR);
|
||||||
|
|
||||||
|
/* If it's our own memory we have to set the sizes */
|
||||||
|
if (!pool->other_pool) {
|
||||||
|
GstMemory *mem = gst_buffer_peek_memory (*buffer, 0);
|
||||||
|
|
||||||
|
g_assert (mem
|
||||||
|
&& g_strcmp0 (mem->allocator->mem_type, GST_OMX_MEMORY_TYPE) == 0);
|
||||||
|
mem->size = ((GstOMXMemory *) mem)->buf->omx_buf->nFilledLen;
|
||||||
|
mem->offset = ((GstOMXMemory *) mem)->buf->omx_buf->nOffset;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
/* Acquire any buffer that is available to be filled by upstream */
|
||||||
|
ret =
|
||||||
|
GST_BUFFER_POOL_CLASS (gst_omx_buffer_pool_parent_class)->acquire_buffer
|
||||||
|
(bpool, buffer, params);
|
||||||
|
}
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_omx_buffer_pool_release_buffer (GstBufferPool * bpool, GstBuffer * buffer)
|
||||||
|
{
|
||||||
|
GstOMXBufferPool *pool = GST_OMX_BUFFER_POOL (bpool);
|
||||||
|
OMX_ERRORTYPE err;
|
||||||
|
GstOMXBuffer *omx_buf;
|
||||||
|
|
||||||
|
g_assert (pool->component && pool->port);
|
||||||
|
|
||||||
|
if (!pool->allocating && !pool->deactivated) {
|
||||||
|
omx_buf =
|
||||||
|
gst_mini_object_get_qdata (GST_MINI_OBJECT_CAST (buffer),
|
||||||
|
gst_omx_buffer_data_quark);
|
||||||
|
if (pool->port->port_def.eDir == OMX_DirOutput) {
|
||||||
|
/* Release back to the port, can be filled again */
|
||||||
|
err = gst_omx_port_release_buffer (pool->port, omx_buf);
|
||||||
|
if (err != OMX_ErrorNone) {
|
||||||
|
/* TODO: Do something about this */
|
||||||
|
g_assert_not_reached ();
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
/* TODO: Implement.
|
||||||
|
*
|
||||||
|
* If not used (i.e. was not passed to the component) this should do
|
||||||
|
* the same as EmptyBufferDone.
|
||||||
|
* If it is used (i.e. was passed to the component) this should do
|
||||||
|
* nothing until EmptyBufferDone.
|
||||||
|
*
|
||||||
|
* EmptyBufferDone should release the buffer to the pool so it can
|
||||||
|
* be allocated again
|
||||||
|
*
|
||||||
|
* Needs something to call back here in EmptyBufferDone, like keeping
|
||||||
|
* a ref on the buffer in GstOMXBuffer until EmptyBufferDone... which
|
||||||
|
* would ensure that the buffer is always unused when this is called.
|
||||||
|
*/
|
||||||
|
g_assert_not_reached ();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
GST_BUFFER_POOL_CLASS (gst_omx_buffer_pool_parent_class)->release_buffer
|
||||||
|
(bpool, buffer);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_omx_buffer_pool_finalize (GObject * object)
|
||||||
|
{
|
||||||
|
GstOMXBufferPool *pool = GST_OMX_BUFFER_POOL (object);
|
||||||
|
|
||||||
|
if (pool->element)
|
||||||
|
gst_object_unref (pool->element);
|
||||||
|
pool->element = NULL;
|
||||||
|
|
||||||
|
if (pool->buffers)
|
||||||
|
g_ptr_array_unref (pool->buffers);
|
||||||
|
pool->buffers = NULL;
|
||||||
|
|
||||||
|
if (pool->other_pool)
|
||||||
|
gst_object_unref (pool->other_pool);
|
||||||
|
pool->other_pool = NULL;
|
||||||
|
|
||||||
|
if (pool->allocator)
|
||||||
|
gst_object_unref (pool->allocator);
|
||||||
|
pool->allocator = NULL;
|
||||||
|
|
||||||
|
if (pool->caps)
|
||||||
|
gst_caps_unref (pool->caps);
|
||||||
|
pool->caps = NULL;
|
||||||
|
|
||||||
|
G_OBJECT_CLASS (gst_omx_buffer_pool_parent_class)->finalize (object);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_omx_buffer_pool_class_init (GstOMXBufferPoolClass * klass)
|
||||||
|
{
|
||||||
|
GObjectClass *gobject_class = (GObjectClass *) klass;
|
||||||
|
GstBufferPoolClass *gstbufferpool_class = (GstBufferPoolClass *) klass;
|
||||||
|
|
||||||
|
gst_omx_buffer_data_quark = g_quark_from_static_string ("GstOMXBufferData");
|
||||||
|
|
||||||
|
gobject_class->finalize = gst_omx_buffer_pool_finalize;
|
||||||
|
gstbufferpool_class->start = gst_omx_buffer_pool_start;
|
||||||
|
gstbufferpool_class->stop = gst_omx_buffer_pool_stop;
|
||||||
|
gstbufferpool_class->get_options = gst_omx_buffer_pool_get_options;
|
||||||
|
gstbufferpool_class->set_config = gst_omx_buffer_pool_set_config;
|
||||||
|
gstbufferpool_class->alloc_buffer = gst_omx_buffer_pool_alloc_buffer;
|
||||||
|
gstbufferpool_class->free_buffer = gst_omx_buffer_pool_free_buffer;
|
||||||
|
gstbufferpool_class->acquire_buffer = gst_omx_buffer_pool_acquire_buffer;
|
||||||
|
gstbufferpool_class->release_buffer = gst_omx_buffer_pool_release_buffer;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_omx_buffer_pool_init (GstOMXBufferPool * pool)
|
||||||
|
{
|
||||||
|
pool->buffers = g_ptr_array_new ();
|
||||||
|
pool->allocator = g_object_new (gst_omx_memory_allocator_get_type (), NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
static GstBufferPool *
|
||||||
|
gst_omx_buffer_pool_new (GstElement * element, GstOMXComponent * component,
|
||||||
|
GstOMXPort * port)
|
||||||
|
{
|
||||||
|
GstOMXBufferPool *pool;
|
||||||
|
|
||||||
|
pool = g_object_new (gst_omx_buffer_pool_get_type (), NULL);
|
||||||
|
pool->element = gst_object_ref (element);
|
||||||
|
pool->component = component;
|
||||||
|
pool->port = port;
|
||||||
|
|
||||||
|
return GST_BUFFER_POOL (pool);
|
||||||
|
}
|
||||||
|
|
||||||
typedef struct _BufferIdentification BufferIdentification;
|
typedef struct _BufferIdentification BufferIdentification;
|
||||||
struct _BufferIdentification
|
struct _BufferIdentification
|
||||||
{
|
{
|
||||||
|
@ -68,6 +676,11 @@ static gboolean gst_omx_video_dec_decide_allocation (GstVideoDecoder * bdec,
|
||||||
static GstFlowReturn gst_omx_video_dec_drain (GstOMXVideoDec * self,
|
static GstFlowReturn gst_omx_video_dec_drain (GstOMXVideoDec * self,
|
||||||
gboolean is_eos);
|
gboolean is_eos);
|
||||||
|
|
||||||
|
static OMX_ERRORTYPE gst_omx_video_dec_allocate_output_buffers (GstOMXVideoDec *
|
||||||
|
self);
|
||||||
|
static OMX_ERRORTYPE gst_omx_video_dec_deallocate_output_buffers (GstOMXVideoDec
|
||||||
|
* self);
|
||||||
|
|
||||||
enum
|
enum
|
||||||
{
|
{
|
||||||
PROP_0
|
PROP_0
|
||||||
|
@ -195,7 +808,7 @@ gst_omx_video_dec_shutdown (GstOMXVideoDec * self)
|
||||||
}
|
}
|
||||||
gst_omx_component_set_state (self->dec, OMX_StateLoaded);
|
gst_omx_component_set_state (self->dec, OMX_StateLoaded);
|
||||||
gst_omx_port_deallocate_buffers (self->dec_in_port);
|
gst_omx_port_deallocate_buffers (self->dec_in_port);
|
||||||
gst_omx_port_deallocate_buffers (self->dec_out_port);
|
gst_omx_video_dec_deallocate_output_buffers (self);
|
||||||
if (state > OMX_StateLoaded)
|
if (state > OMX_StateLoaded)
|
||||||
gst_omx_component_get_state (self->dec, 5 * GST_SECOND);
|
gst_omx_component_get_state (self->dec, 5 * GST_SECOND);
|
||||||
}
|
}
|
||||||
|
@ -541,6 +1154,199 @@ done:
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static OMX_ERRORTYPE
|
||||||
|
gst_omx_video_dec_allocate_output_buffers (GstOMXVideoDec * self)
|
||||||
|
{
|
||||||
|
OMX_ERRORTYPE err = OMX_ErrorNone;
|
||||||
|
GstOMXPort *port;
|
||||||
|
GstBufferPool *pool;
|
||||||
|
GstStructure *config;
|
||||||
|
gboolean eglimage = FALSE, add_videometa = FALSE;
|
||||||
|
GstCaps *caps = NULL;
|
||||||
|
guint min = 0, max = 0;
|
||||||
|
GstVideoCodecState *state =
|
||||||
|
gst_video_decoder_get_output_state (GST_VIDEO_DECODER (self));
|
||||||
|
|
||||||
|
port = self->dec_out_port;
|
||||||
|
|
||||||
|
pool = gst_video_decoder_get_buffer_pool (GST_VIDEO_DECODER (self));
|
||||||
|
if (pool) {
|
||||||
|
GstAllocator *allocator;
|
||||||
|
|
||||||
|
config = gst_buffer_pool_get_config (pool);
|
||||||
|
gst_buffer_pool_config_get_params (config, &caps, NULL, &min, &max);
|
||||||
|
gst_buffer_pool_config_get_allocator (config, &allocator, NULL);
|
||||||
|
|
||||||
|
/* Need at least 2 buffers for anything meaningful */
|
||||||
|
min = MAX (MAX (min, port->port_def.nBufferCountMin), 2);
|
||||||
|
max = min;
|
||||||
|
|
||||||
|
add_videometa = gst_buffer_pool_config_has_option (config,
|
||||||
|
GST_BUFFER_POOL_OPTION_VIDEO_META);
|
||||||
|
|
||||||
|
/* TODO: Implement something here */
|
||||||
|
eglimage = FALSE;
|
||||||
|
caps = caps ? gst_caps_ref (caps) : NULL;
|
||||||
|
|
||||||
|
GST_DEBUG_OBJECT (self, "Trying to use pool %p with caps %" GST_PTR_FORMAT
|
||||||
|
" and memory type %s", pool, caps,
|
||||||
|
(allocator ? allocator->mem_type : "(null)"));
|
||||||
|
} else {
|
||||||
|
gst_caps_replace (&caps, NULL);
|
||||||
|
min = max = port->port_def.nBufferCountMin;
|
||||||
|
GST_DEBUG_OBJECT (self, "No pool available, not negotiated yet");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (caps)
|
||||||
|
self->out_port_pool =
|
||||||
|
gst_omx_buffer_pool_new (GST_ELEMENT_CAST (self), self->dec, port);
|
||||||
|
|
||||||
|
/* TODO: Implement EGLImage handling and usage of other downstream buffers */
|
||||||
|
|
||||||
|
/* If not using EGLImage or trying to use EGLImage failed */
|
||||||
|
if (!eglimage) {
|
||||||
|
gboolean was_enabled = TRUE;
|
||||||
|
|
||||||
|
if (min != port->port_def.nBufferCountActual) {
|
||||||
|
err = gst_omx_port_update_port_definition (port, NULL);
|
||||||
|
if (err == OMX_ErrorNone) {
|
||||||
|
port->port_def.nBufferCountActual = min;
|
||||||
|
err = gst_omx_port_update_port_definition (port, &port->port_def);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (err != OMX_ErrorNone) {
|
||||||
|
GST_ERROR_OBJECT (self,
|
||||||
|
"Failed to configure %n output buffers: %s (0x%08x)", min,
|
||||||
|
gst_omx_error_to_string (err), err);
|
||||||
|
goto done;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!gst_omx_port_is_enabled (port)) {
|
||||||
|
err = gst_omx_port_set_enabled (port, TRUE);
|
||||||
|
if (err != OMX_ErrorNone) {
|
||||||
|
GST_INFO_OBJECT (self,
|
||||||
|
"Failed to enable port: %s (0x%08x)",
|
||||||
|
gst_omx_error_to_string (err), err);
|
||||||
|
goto done;
|
||||||
|
}
|
||||||
|
was_enabled = FALSE;
|
||||||
|
}
|
||||||
|
|
||||||
|
err = gst_omx_port_allocate_buffers (port);
|
||||||
|
if (err != OMX_ErrorNone && min > port->port_def.nBufferCountMin) {
|
||||||
|
GST_ERROR_OBJECT (self,
|
||||||
|
"Failed to allocate required number of buffers %d, trying less and copying",
|
||||||
|
min);
|
||||||
|
min = port->port_def.nBufferCountMin;
|
||||||
|
|
||||||
|
if (!was_enabled)
|
||||||
|
gst_omx_port_set_enabled (port, FALSE);
|
||||||
|
|
||||||
|
if (min != port->port_def.nBufferCountActual) {
|
||||||
|
err = gst_omx_port_update_port_definition (port, NULL);
|
||||||
|
if (err == OMX_ErrorNone) {
|
||||||
|
port->port_def.nBufferCountActual = min;
|
||||||
|
err = gst_omx_port_update_port_definition (port, &port->port_def);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (err != OMX_ErrorNone) {
|
||||||
|
GST_ERROR_OBJECT (self,
|
||||||
|
"Failed to configure %n output buffers: %s (0x%08x)", min,
|
||||||
|
gst_omx_error_to_string (err), err);
|
||||||
|
goto done;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
err = gst_omx_port_allocate_buffers (port);
|
||||||
|
|
||||||
|
/* Can't provide buffers downstream in this case */
|
||||||
|
gst_caps_replace (&caps, NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (err != OMX_ErrorNone) {
|
||||||
|
GST_ERROR_OBJECT (self, "Failed to allocate %d buffers: %s (0x%08x)", min,
|
||||||
|
gst_omx_error_to_string (err), err);
|
||||||
|
goto done;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!was_enabled) {
|
||||||
|
err = gst_omx_port_wait_enabled (port, 2 * GST_SECOND);
|
||||||
|
if (err != OMX_ErrorNone) {
|
||||||
|
GST_ERROR_OBJECT (self,
|
||||||
|
"Failed to wait until port is enabled: %s (0x%08x)",
|
||||||
|
gst_omx_error_to_string (err), err);
|
||||||
|
goto done;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
err = OMX_ErrorNone;
|
||||||
|
|
||||||
|
if (caps) {
|
||||||
|
config = gst_buffer_pool_get_config (self->out_port_pool);
|
||||||
|
|
||||||
|
if (add_videometa)
|
||||||
|
gst_buffer_pool_config_add_option (config,
|
||||||
|
GST_BUFFER_POOL_OPTION_VIDEO_META);
|
||||||
|
|
||||||
|
gst_buffer_pool_config_set_params (config, caps,
|
||||||
|
self->dec_out_port->port_def.nBufferSize, min, max);
|
||||||
|
|
||||||
|
if (!gst_buffer_pool_set_config (self->out_port_pool, config)) {
|
||||||
|
GST_INFO_OBJECT (self, "Failed to set config on internal pool");
|
||||||
|
gst_object_unref (self->out_port_pool);
|
||||||
|
self->out_port_pool = NULL;
|
||||||
|
goto done;
|
||||||
|
}
|
||||||
|
|
||||||
|
GST_OMX_BUFFER_POOL (self->out_port_pool)->allocating = TRUE;
|
||||||
|
/* This now allocates all the buffers */
|
||||||
|
if (!gst_buffer_pool_set_active (self->out_port_pool, TRUE)) {
|
||||||
|
GST_INFO_OBJECT (self, "Failed to activate internal pool");
|
||||||
|
gst_object_unref (self->out_port_pool);
|
||||||
|
self->out_port_pool = NULL;
|
||||||
|
} else {
|
||||||
|
GST_OMX_BUFFER_POOL (self->out_port_pool)->allocating = FALSE;
|
||||||
|
}
|
||||||
|
} else if (self->out_port_pool) {
|
||||||
|
gst_object_unref (self->out_port_pool);
|
||||||
|
self->out_port_pool = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
done:
|
||||||
|
if (!self->out_port_pool && err == OMX_ErrorNone)
|
||||||
|
GST_DEBUG_OBJECT (self,
|
||||||
|
"Not using our internal pool and copying buffers for downstream");
|
||||||
|
|
||||||
|
if (caps)
|
||||||
|
gst_caps_unref (caps);
|
||||||
|
if (pool)
|
||||||
|
gst_object_unref (pool);
|
||||||
|
if (state)
|
||||||
|
gst_video_codec_state_unref (state);
|
||||||
|
|
||||||
|
return err;
|
||||||
|
}
|
||||||
|
|
||||||
|
static OMX_ERRORTYPE
|
||||||
|
gst_omx_video_dec_deallocate_output_buffers (GstOMXVideoDec * self)
|
||||||
|
{
|
||||||
|
OMX_ERRORTYPE err;
|
||||||
|
|
||||||
|
if (self->out_port_pool) {
|
||||||
|
gst_buffer_pool_set_active (self->out_port_pool, FALSE);
|
||||||
|
GST_OMX_BUFFER_POOL (self->out_port_pool)->deactivated = TRUE;
|
||||||
|
gst_object_unref (self->out_port_pool);
|
||||||
|
self->out_port_pool = NULL;
|
||||||
|
}
|
||||||
|
err = gst_omx_port_deallocate_buffers (self->dec_out_port);
|
||||||
|
|
||||||
|
return err;
|
||||||
|
}
|
||||||
|
|
||||||
static void
|
static void
|
||||||
gst_omx_video_dec_loop (GstOMXVideoDec * self)
|
gst_omx_video_dec_loop (GstOMXVideoDec * self)
|
||||||
{
|
{
|
||||||
|
@ -582,7 +1388,7 @@ gst_omx_video_dec_loop (GstOMXVideoDec * self)
|
||||||
if (err != OMX_ErrorNone)
|
if (err != OMX_ErrorNone)
|
||||||
goto reconfigure_error;
|
goto reconfigure_error;
|
||||||
|
|
||||||
err = gst_omx_port_deallocate_buffers (port);
|
err = gst_omx_video_dec_deallocate_output_buffers (self);
|
||||||
if (err != OMX_ErrorNone)
|
if (err != OMX_ErrorNone)
|
||||||
goto reconfigure_error;
|
goto reconfigure_error;
|
||||||
|
|
||||||
|
@ -646,7 +1452,7 @@ gst_omx_video_dec_loop (GstOMXVideoDec * self)
|
||||||
if (err != OMX_ErrorNone)
|
if (err != OMX_ErrorNone)
|
||||||
goto reconfigure_error;
|
goto reconfigure_error;
|
||||||
|
|
||||||
err = gst_omx_port_allocate_buffers (port, -1);
|
err = gst_omx_video_dec_allocate_output_buffers (self);
|
||||||
if (err != OMX_ErrorNone)
|
if (err != OMX_ErrorNone)
|
||||||
goto reconfigure_error;
|
goto reconfigure_error;
|
||||||
|
|
||||||
|
@ -704,17 +1510,69 @@ gst_omx_video_dec_loop (GstOMXVideoDec * self)
|
||||||
|
|
||||||
GST_ERROR_OBJECT (self, "No corresponding frame found");
|
GST_ERROR_OBJECT (self, "No corresponding frame found");
|
||||||
|
|
||||||
|
if (self->out_port_pool) {
|
||||||
|
gint i, n;
|
||||||
|
GstBufferPoolAcquireParams params = { 0, };
|
||||||
|
|
||||||
|
n = port->buffers->len;
|
||||||
|
for (i = 0; i < n; i++) {
|
||||||
|
GstOMXBuffer *tmp = g_ptr_array_index (port->buffers, i);
|
||||||
|
|
||||||
|
if (tmp == buf)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
g_assert (i != n);
|
||||||
|
|
||||||
|
GST_OMX_BUFFER_POOL (self->out_port_pool)->current_buffer_index = i;
|
||||||
|
flow_ret =
|
||||||
|
gst_buffer_pool_acquire_buffer (self->out_port_pool, &outbuf,
|
||||||
|
¶ms);
|
||||||
|
if (flow_ret != GST_FLOW_OK) {
|
||||||
|
gst_omx_port_release_buffer (self->dec_out_port, buf);
|
||||||
|
goto invalid_buffer;
|
||||||
|
}
|
||||||
|
buf = NULL;
|
||||||
|
} else {
|
||||||
outbuf =
|
outbuf =
|
||||||
gst_video_decoder_allocate_output_buffer (GST_VIDEO_DECODER (self));
|
gst_video_decoder_allocate_output_buffer (GST_VIDEO_DECODER (self));
|
||||||
|
|
||||||
if (!gst_omx_video_dec_fill_buffer (self, buf, outbuf)) {
|
if (!gst_omx_video_dec_fill_buffer (self, buf, outbuf)) {
|
||||||
gst_buffer_unref (outbuf);
|
gst_buffer_unref (outbuf);
|
||||||
gst_omx_port_release_buffer (self->dec_out_port, buf);
|
gst_omx_port_release_buffer (self->dec_out_port, buf);
|
||||||
goto invalid_buffer;
|
goto invalid_buffer;
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
flow_ret = gst_pad_push (GST_VIDEO_DECODER_SRC_PAD (self), outbuf);
|
flow_ret = gst_pad_push (GST_VIDEO_DECODER_SRC_PAD (self), outbuf);
|
||||||
} else if (buf->omx_buf->nFilledLen > 0) {
|
} else if (buf->omx_buf->nFilledLen > 0) {
|
||||||
|
if (self->out_port_pool) {
|
||||||
|
gint i, n;
|
||||||
|
GstBufferPoolAcquireParams params = { 0, };
|
||||||
|
|
||||||
|
n = port->buffers->len;
|
||||||
|
for (i = 0; i < n; i++) {
|
||||||
|
GstOMXBuffer *tmp = g_ptr_array_index (port->buffers, i);
|
||||||
|
|
||||||
|
if (tmp == buf)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
g_assert (i != n);
|
||||||
|
|
||||||
|
GST_OMX_BUFFER_POOL (self->out_port_pool)->current_buffer_index = i;
|
||||||
|
flow_ret =
|
||||||
|
gst_buffer_pool_acquire_buffer (self->out_port_pool,
|
||||||
|
&frame->output_buffer, ¶ms);
|
||||||
|
if (flow_ret != GST_FLOW_OK) {
|
||||||
|
flow_ret =
|
||||||
|
gst_video_decoder_drop_frame (GST_VIDEO_DECODER (self), frame);
|
||||||
|
frame = NULL;
|
||||||
|
gst_omx_port_release_buffer (self->dec_out_port, buf);
|
||||||
|
goto invalid_buffer;
|
||||||
|
}
|
||||||
|
flow_ret =
|
||||||
|
gst_video_decoder_finish_frame (GST_VIDEO_DECODER (self), frame);
|
||||||
|
frame = NULL;
|
||||||
|
buf = NULL;
|
||||||
|
} else {
|
||||||
if ((flow_ret =
|
if ((flow_ret =
|
||||||
gst_video_decoder_allocate_output_frame (GST_VIDEO_DECODER
|
gst_video_decoder_allocate_output_frame (GST_VIDEO_DECODER
|
||||||
(self), frame)) == GST_FLOW_OK) {
|
(self), frame)) == GST_FLOW_OK) {
|
||||||
|
@ -734,6 +1592,7 @@ gst_omx_video_dec_loop (GstOMXVideoDec * self)
|
||||||
gst_video_decoder_finish_frame (GST_VIDEO_DECODER (self), frame);
|
gst_video_decoder_finish_frame (GST_VIDEO_DECODER (self), frame);
|
||||||
frame = NULL;
|
frame = NULL;
|
||||||
}
|
}
|
||||||
|
}
|
||||||
} else if (frame != NULL) {
|
} else if (frame != NULL) {
|
||||||
flow_ret = gst_video_decoder_drop_frame (GST_VIDEO_DECODER (self), frame);
|
flow_ret = gst_video_decoder_drop_frame (GST_VIDEO_DECODER (self), frame);
|
||||||
frame = NULL;
|
frame = NULL;
|
||||||
|
@ -757,6 +1616,7 @@ gst_omx_video_dec_loop (GstOMXVideoDec * self)
|
||||||
gst_flow_get_name (flow_ret));
|
gst_flow_get_name (flow_ret));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if (buf)
|
||||||
gst_omx_port_release_buffer (port, buf);
|
gst_omx_port_release_buffer (port, buf);
|
||||||
|
|
||||||
self->downstream_flow_ret = flow_ret;
|
self->downstream_flow_ret = flow_ret;
|
||||||
|
|
|
@ -53,6 +53,8 @@ struct _GstOMXVideoDec
|
||||||
GstOMXComponent *dec;
|
GstOMXComponent *dec;
|
||||||
GstOMXPort *dec_in_port, *dec_out_port;
|
GstOMXPort *dec_in_port, *dec_out_port;
|
||||||
|
|
||||||
|
GstBufferPool *in_port_pool, *out_port_pool;
|
||||||
|
|
||||||
/* < private > */
|
/* < private > */
|
||||||
GstVideoCodecState *input_state;
|
GstVideoCodecState *input_state;
|
||||||
GstBuffer *codec_data;
|
GstBuffer *codec_data;
|
||||||
|
|
Loading…
Reference in a new issue