X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=sys%2Fv4l2%2Fgstv4l2bufferpool.c;h=7dd862fab0adfbd99c7e45f919ef12a5cdaa9d4e;hb=9e79821b1dc0f3f97ac7bdd72b3394f646042280;hp=b795e4a73180395dfef253ec8f34e56f4227ab75;hpb=8635258046a3c55edce4cceff810c1099fce590d;p=platform%2Fupstream%2Fgst-plugins-good.git diff --git a/sys/v4l2/gstv4l2bufferpool.c b/sys/v4l2/gstv4l2bufferpool.c index b795e4a..7dd862f 100644 --- a/sys/v4l2/gstv4l2bufferpool.c +++ b/sys/v4l2/gstv4l2bufferpool.c @@ -42,7 +42,7 @@ #include -#include "v4l2_calls.h" +#include "gstv4l2object.h" #include "gst/gst-i18n-plugin.h" #include @@ -292,6 +292,9 @@ gst_v4l2_buffer_pool_import_userptr (GstV4l2BufferPool * pool, gst_mini_object_set_qdata (GST_MINI_OBJECT (dest), GST_V4L2_IMPORT_QUARK, data, (GDestroyNotify) _unmap_userptr_frame); + gst_buffer_copy_into (dest, src, + GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS, 0, -1); + return ret; not_our_buffer: @@ -346,6 +349,9 @@ gst_v4l2_buffer_pool_import_dmabuf (GstV4l2BufferPool * pool, gst_mini_object_set_qdata (GST_MINI_OBJECT (dest), GST_V4L2_IMPORT_QUARK, gst_buffer_ref (src), (GDestroyNotify) gst_buffer_unref); + gst_buffer_copy_into (dest, src, + GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS, 0, -1); + return GST_FLOW_OK; not_our_buffer: @@ -604,24 +610,60 @@ wrong_config: } } +static GstFlowReturn +gst_v4l2_buffer_pool_resurect_buffer (GstV4l2BufferPool * pool) +{ + GstBufferPoolAcquireParams params = { 0 }; + GstBuffer *buffer = NULL; + GstFlowReturn ret; + + GST_DEBUG_OBJECT (pool, "A buffer was lost, reallocating it"); + + /* block recursive calls to this function */ + g_signal_handler_block (pool->vallocator, pool->group_released_handler); + + params.flags = + (GstBufferPoolAcquireFlags) GST_V4L2_BUFFER_POOL_ACQUIRE_FLAG_RESURRECT | + GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT; + ret = + gst_buffer_pool_acquire_buffer (GST_BUFFER_POOL (pool), &buffer, ¶ms); + + if (ret == GST_FLOW_OK) + gst_buffer_unref (buffer); + + g_signal_handler_unblock (pool->vallocator, pool->group_released_handler); + + return ret; +} + static gboolean gst_v4l2_buffer_pool_streamon (GstV4l2BufferPool * pool) { GstV4l2Object *obj = pool->obj; + if (pool->streaming) + return TRUE; + switch (obj->mode) { case GST_V4L2_IO_MMAP: case GST_V4L2_IO_USERPTR: case GST_V4L2_IO_DMABUF: case GST_V4L2_IO_DMABUF_IMPORT: - if (!pool->streaming) { - if (v4l2_ioctl (pool->video_fd, VIDIOC_STREAMON, &obj->type) < 0) - goto streamon_failed; + if (!V4L2_TYPE_IS_OUTPUT (pool->obj->type)) { + /* For captures, we need to enqueue buffers before we start streaming, + * so the driver don't underflow immediatly. As we have put then back + * into the base class queue, resurect them, then releasing will queue + * them back. */ + while (gst_v4l2_buffer_pool_resurect_buffer (pool) == GST_FLOW_OK) + continue; + } - pool->streaming = TRUE; + if (obj->ioctl (pool->video_fd, VIDIOC_STREAMON, &obj->type) < 0) + goto streamon_failed; - GST_DEBUG_OBJECT (pool, "Started streaming"); - } + pool->streaming = TRUE; + + GST_DEBUG_OBJECT (pool, "Started streaming"); break; default: break; @@ -637,53 +679,53 @@ streamon_failed: } } +/* Call with streamlock held, or when streaming threads are down */ static void gst_v4l2_buffer_pool_streamoff (GstV4l2BufferPool * pool) { + GstBufferPoolClass *pclass = GST_BUFFER_POOL_CLASS (parent_class); GstV4l2Object *obj = pool->obj; + gint i; + + if (!pool->streaming) + return; switch (obj->mode) { case GST_V4L2_IO_MMAP: case GST_V4L2_IO_USERPTR: case GST_V4L2_IO_DMABUF: case GST_V4L2_IO_DMABUF_IMPORT: - if (pool->streaming) { - if (v4l2_ioctl (pool->video_fd, VIDIOC_STREAMOFF, &obj->type) < 0) - GST_WARNING_OBJECT (pool, "STREAMOFF failed with errno %d (%s)", - errno, g_strerror (errno)); - pool->streaming = FALSE; + if (obj->ioctl (pool->video_fd, VIDIOC_STREAMOFF, &obj->type) < 0) + GST_WARNING_OBJECT (pool, "STREAMOFF failed with errno %d (%s)", + errno, g_strerror (errno)); - GST_DEBUG_OBJECT (pool, "Stopped streaming"); + pool->streaming = FALSE; - if (pool->vallocator) - gst_v4l2_allocator_flush (pool->vallocator); - } + GST_DEBUG_OBJECT (pool, "Stopped streaming"); + + if (pool->vallocator) + gst_v4l2_allocator_flush (pool->vallocator); break; default: break; } -} - -static GstFlowReturn -gst_v4l2_buffer_pool_resurect_buffer (GstV4l2BufferPool * pool) -{ - GstBufferPoolAcquireParams params = { 0 }; - GstBuffer *buffer = NULL; - GstFlowReturn ret; - GST_DEBUG_OBJECT (pool, "A buffer was lost, reallocating it"); + for (i = 0; i < VIDEO_MAX_FRAME; i++) { + if (pool->buffers[i]) { + GstBuffer *buffer = pool->buffers[i]; + GstBufferPool *bpool = GST_BUFFER_POOL (pool); - params.flags = - (GstBufferPoolAcquireFlags) GST_V4L2_BUFFER_POOL_ACQUIRE_FLAG_RESURRECT | - GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT; - ret = - gst_buffer_pool_acquire_buffer (GST_BUFFER_POOL (pool), &buffer, ¶ms); + pool->buffers[i] = NULL; - if (ret == GST_FLOW_OK) - gst_buffer_unref (buffer); + if (V4L2_TYPE_IS_OUTPUT (pool->obj->type)) + gst_v4l2_buffer_pool_release_buffer (bpool, buffer); + else /* Don't re-enqueue capture buffer on stop */ + pclass->release_buffer (bpool, buffer); - return ret; + g_atomic_int_add (&pool->num_queued, -1); + } + } } static gboolean @@ -696,7 +738,7 @@ gst_v4l2_buffer_pool_start (GstBufferPool * bpool) GstCaps *caps; guint size, min_buffers, max_buffers; guint max_latency, min_latency, copy_threshold = 0; - gboolean can_allocate = FALSE; + gboolean can_allocate = FALSE, ret = TRUE; GST_DEBUG_OBJECT (pool, "activating pool"); @@ -717,7 +759,7 @@ gst_v4l2_buffer_pool_start (GstBufferPool * bpool) * queue to be initialized now. We only do this if we have a streaming * driver. */ if (obj->device_caps & V4L2_CAP_STREAMING) - v4l2_read (obj->video_fd, NULL, 0); + obj->read (obj->video_fd, NULL, 0); #endif break; case GST_V4L2_IO_DMABUF: @@ -827,12 +869,17 @@ gst_v4l2_buffer_pool_start (GstBufferPool * bpool) if (!pclass->start (bpool)) goto start_failed; - if (!V4L2_TYPE_IS_OUTPUT (obj->type)) + if (!V4L2_TYPE_IS_OUTPUT (obj->type)) { + if (g_atomic_int_get (&pool->num_queued) < min_buffers) + goto queue_failed; + pool->group_released_handler = g_signal_connect_swapped (pool->vallocator, "group-released", G_CALLBACK (gst_v4l2_buffer_pool_resurect_buffer), pool); + ret = gst_v4l2_buffer_pool_streamon (pool); + } - return TRUE; + return ret; /* ERRORS */ wrong_config: @@ -851,7 +898,7 @@ no_buffers: } start_failed: { - GST_ERROR_OBJECT (pool, "failed to start streaming"); + GST_ERROR_OBJECT (pool, "allocate failed"); return FALSE; } other_pool_failed: @@ -860,15 +907,18 @@ other_pool_failed: GST_PTR_FORMAT, pool->other_pool); return FALSE; } +queue_failed: + { + GST_ERROR_OBJECT (pool, "failed to queue buffers into the capture queue"); + return FALSE; + } } static gboolean gst_v4l2_buffer_pool_stop (GstBufferPool * bpool) { GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); - GstBufferPoolClass *pclass = GST_BUFFER_POOL_CLASS (parent_class); gboolean ret; - gint i; GST_DEBUG_OBJECT (pool, "stopping pool"); @@ -886,21 +936,6 @@ gst_v4l2_buffer_pool_stop (GstBufferPool * bpool) gst_v4l2_buffer_pool_streamoff (pool); - for (i = 0; i < VIDEO_MAX_FRAME; i++) { - if (pool->buffers[i]) { - GstBuffer *buffer = pool->buffers[i]; - - pool->buffers[i] = NULL; - - if (V4L2_TYPE_IS_OUTPUT (pool->obj->type)) - gst_v4l2_buffer_pool_release_buffer (bpool, buffer); - else /* Don't re-enqueue capture buffer on stop */ - pclass->release_buffer (bpool, buffer); - - g_atomic_int_add (&pool->num_queued, -1); - } - } - ret = GST_BUFFER_POOL_CLASS (parent_class)->stop (bpool); if (ret && pool->vallocator) { @@ -939,89 +974,53 @@ static void gst_v4l2_buffer_pool_flush_stop (GstBufferPool * bpool) { GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); - GstV4l2Object *obj = pool->obj; - GstBuffer *buffers[VIDEO_MAX_FRAME]; - gint i; GST_DEBUG_OBJECT (pool, "stop flushing"); - /* If we haven't started streaming yet, simply call streamon */ - if (!pool->streaming) - goto streamon; - if (pool->other_pool) gst_buffer_pool_set_flushing (pool->other_pool, FALSE); - GST_OBJECT_LOCK (pool); - gst_v4l2_buffer_pool_streamoff (pool); - /* Remember buffers to re-enqueue */ - memcpy (buffers, pool->buffers, sizeof (buffers)); - memset (pool->buffers, 0, sizeof (pool->buffers)); - GST_OBJECT_UNLOCK (pool); - - /* Reset our state */ - switch (obj->mode) { - case GST_V4L2_IO_RW: - break; - case GST_V4L2_IO_MMAP: - case GST_V4L2_IO_USERPTR: - case GST_V4L2_IO_DMABUF: - case GST_V4L2_IO_DMABUF_IMPORT: - { - for (i = 0; i < VIDEO_MAX_FRAME; i++) { - /* Re-enqueue buffers */ - if (buffers[i]) { - GstBufferPool *bpool = (GstBufferPool *) pool; - GstBuffer *buffer = buffers[i]; - - /* Remove qdata, this will unmap any map data in - * userptr/dmabuf-import */ - gst_mini_object_set_qdata (GST_MINI_OBJECT (buffer), - GST_V4L2_IMPORT_QUARK, NULL, NULL); - - if (buffer->pool == NULL) - gst_v4l2_buffer_pool_release_buffer (bpool, buffer); - - g_atomic_int_add (&pool->num_queued, -1); - } - } - - break; - } - default: - g_assert_not_reached (); - break; - } - -streamon: - /* Start streaming on capture device only */ - if (!V4L2_TYPE_IS_OUTPUT (obj->type)) - gst_v4l2_buffer_pool_streamon (pool); - gst_poll_set_flushing (pool->poll, FALSE); } static GstFlowReturn -gst_v4l2_buffer_pool_poll (GstV4l2BufferPool * pool) +gst_v4l2_buffer_pool_poll (GstV4l2BufferPool * pool, gboolean wait) { gint ret; + GstClockTime timeout; + + if (wait) + timeout = GST_CLOCK_TIME_NONE; + else + timeout = 0; /* In RW mode there is no queue, hence no need to wait while the queue is * empty */ if (pool->obj->mode != GST_V4L2_IO_RW) { GST_OBJECT_LOCK (pool); + + if (!wait && pool->empty) { + GST_OBJECT_UNLOCK (pool); + goto no_buffers; + } + while (pool->empty) g_cond_wait (&pool->empty_cond, GST_OBJECT_GET_LOCK (pool)); + GST_OBJECT_UNLOCK (pool); } - if (!pool->can_poll_device) - goto done; + if (!pool->can_poll_device) { + if (wait) + goto done; + else + goto no_buffers; + } GST_LOG_OBJECT (pool, "polling device"); again: - ret = gst_poll_wait (pool->poll, GST_CLOCK_TIME_NONE); + ret = gst_poll_wait (pool->poll, timeout); if (G_UNLIKELY (ret < 0)) { switch (errno) { case EBUSY: @@ -1043,6 +1042,9 @@ again: if (gst_poll_fd_has_error (pool->poll, &pool->pollfd)) goto select_error; + if (ret == 0) + goto no_buffers; + done: return GST_FLOW_OK; @@ -1058,22 +1060,18 @@ select_error: ("poll error %d: %s (%d)", ret, g_strerror (errno), errno)); return GST_FLOW_ERROR; } +no_buffers: + return GST_FLOW_CUSTOM_SUCCESS; } static GstFlowReturn -gst_v4l2_buffer_pool_qbuf (GstV4l2BufferPool * pool, GstBuffer * buf) +gst_v4l2_buffer_pool_qbuf (GstV4l2BufferPool * pool, GstBuffer * buf, + GstV4l2MemoryGroup * group) { - GstV4l2MemoryGroup *group = NULL; const GstV4l2Object *obj = pool->obj; GstClockTime timestamp; gint index; - if (!gst_v4l2_is_buffer_valid (buf, &group)) { - GST_LOG_OBJECT (pool, "unref copied/invalid buffer %p", buf); - gst_buffer_unref (buf); - return GST_FLOW_OK; - } - index = group->buffer.index; if (pool->buffers[index] != NULL) @@ -1139,18 +1137,26 @@ queue_failed: } static GstFlowReturn -gst_v4l2_buffer_pool_dqbuf (GstV4l2BufferPool * pool, GstBuffer ** buffer) +gst_v4l2_buffer_pool_dqbuf (GstV4l2BufferPool * pool, GstBuffer ** buffer, + gboolean wait) { GstFlowReturn res; - GstBuffer *outbuf; + GstBuffer *outbuf = NULL; GstV4l2Object *obj = pool->obj; GstClockTime timestamp; GstV4l2MemoryGroup *group; + GstVideoMeta *vmeta; + gsize size; gint i; - if ((res = gst_v4l2_buffer_pool_poll (pool)) != GST_FLOW_OK) + if ((res = gst_v4l2_buffer_pool_poll (pool, wait)) < GST_FLOW_OK) goto poll_failed; + if (res == GST_FLOW_CUSTOM_SUCCESS) { + GST_LOG_OBJECT (pool, "nothing to dequeue"); + goto done; + } + GST_LOG_OBJECT (pool, "dequeueing a buffer"); res = gst_v4l2_allocator_dqbuf (pool->vallocator, &group); @@ -1176,7 +1182,8 @@ gst_v4l2_buffer_pool_dqbuf (GstV4l2BufferPool * pool, GstBuffer ** buffer) timestamp = GST_TIMEVAL_TO_TIME (group->buffer.timestamp); -#ifndef GST_DISABLE_GST_DEBUG + size = 0; + vmeta = gst_buffer_get_video_meta (outbuf); for (i = 0; i < group->n_mem; i++) { GST_LOG_OBJECT (pool, "dequeued buffer %p seq:%d (ix=%d), mem %p used %d, plane=%d, flags %08x, ts %" @@ -1184,8 +1191,12 @@ gst_v4l2_buffer_pool_dqbuf (GstV4l2BufferPool * pool, GstBuffer ** buffer) group->buffer.sequence, group->buffer.index, group->mem[i], group->planes[i].bytesused, i, group->buffer.flags, GST_TIME_ARGS (timestamp), pool->num_queued, outbuf); + + if (vmeta) { + vmeta->offset[i] = size; + size += gst_memory_get_sizes (group->mem[i], NULL, NULL); + } } -#endif /* Ignore timestamp and field for OUTPUT device */ if (V4L2_TYPE_IS_OUTPUT (obj->type)) @@ -1253,7 +1264,10 @@ gst_v4l2_buffer_pool_dqbuf (GstV4l2BufferPool * pool, GstBuffer ** buffer) } if (GST_VIDEO_INFO_FORMAT (&obj->info) == GST_VIDEO_FORMAT_ENCODED) { - if (group->buffer.flags & V4L2_BUF_FLAG_KEYFRAME) + if ((group->buffer.flags & V4L2_BUF_FLAG_KEYFRAME) || + GST_V4L2_PIXELFORMAT (obj) == V4L2_PIX_FMT_MJPEG || + GST_V4L2_PIXELFORMAT (obj) == V4L2_PIX_FMT_JPEG || + GST_V4L2_PIXELFORMAT (obj) == V4L2_PIX_FMT_PJPG) GST_BUFFER_FLAG_UNSET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT); else GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT); @@ -1269,7 +1283,7 @@ gst_v4l2_buffer_pool_dqbuf (GstV4l2BufferPool * pool, GstBuffer ** buffer) done: *buffer = outbuf; - return GST_FLOW_OK; + return res; /* ERRORS */ poll_failed: @@ -1329,7 +1343,7 @@ gst_v4l2_buffer_pool_acquire_buffer (GstBufferPool * bpool, GstBuffer ** buffer, /* just dequeue a buffer, we basically use the queue of v4l2 as the * storage for our buffers. This function does poll first so we can * interrupt it fine. */ - ret = gst_v4l2_buffer_pool_dqbuf (pool, buffer); + ret = gst_v4l2_buffer_pool_dqbuf (pool, buffer, TRUE); break; } default: @@ -1404,7 +1418,7 @@ gst_v4l2_buffer_pool_release_buffer (GstBufferPool * bpool, GstBuffer * buffer) /* queue back in the device */ if (pool->other_pool) gst_v4l2_buffer_pool_prepare_buffer (pool, buffer, NULL); - if (gst_v4l2_buffer_pool_qbuf (pool, buffer) != GST_FLOW_OK) + if (gst_v4l2_buffer_pool_qbuf (pool, buffer, group) != GST_FLOW_OK) pclass->release_buffer (bpool, buffer); } else { /* Simply release invalide/modified buffer, the allocator will @@ -1506,12 +1520,11 @@ gst_v4l2_buffer_pool_finalize (GObject * object) GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (object); if (pool->video_fd >= 0) - v4l2_close (pool->video_fd); + pool->obj->close (pool->video_fd); gst_poll_free (pool->poll); - /* FIXME Is this required to keep around ? - * This can't be done in dispose method because we must not set pointer + /* This can't be done in dispose method because we must not set pointer * to NULL as it is part of the v4l2object and dispose could be called * multiple times */ gst_object_unref (pool->obj->element); @@ -1571,7 +1584,7 @@ gst_v4l2_buffer_pool_new (GstV4l2Object * obj, GstCaps * caps) gchar *name, *parent_name; gint fd; - fd = v4l2_dup (obj->video_fd); + fd = obj->dup (obj->video_fd); if (fd < 0) goto dup_failed; @@ -1583,6 +1596,7 @@ gst_v4l2_buffer_pool_new (GstV4l2Object * obj, GstCaps * caps) pool = (GstV4l2BufferPool *) g_object_new (GST_TYPE_V4L2_BUFFER_POOL, "name", name, NULL); + g_object_ref_sink (pool); g_free (name); gst_poll_fd_init (&pool->pollfd); @@ -1597,8 +1611,7 @@ gst_v4l2_buffer_pool_new (GstV4l2Object * obj, GstCaps * caps) pool->obj = obj; pool->can_poll_device = TRUE; - pool->vallocator = - gst_v4l2_allocator_new (GST_OBJECT (pool), obj->video_fd, &obj->format); + pool->vallocator = gst_v4l2_allocator_new (GST_OBJECT (pool), obj); if (pool->vallocator == NULL) goto allocator_failed; @@ -1642,10 +1655,10 @@ gst_v4l2_do_read (GstV4l2BufferPool * pool, GstBuffer * buf) gst_buffer_map (buf, &map, GST_MAP_WRITE); do { - if ((res = gst_v4l2_buffer_pool_poll (pool)) != GST_FLOW_OK) + if ((res = gst_v4l2_buffer_pool_poll (pool, TRUE)) != GST_FLOW_OK) goto poll_error; - amount = v4l2_read (obj->video_fd, map.data, toread); + amount = obj->read (obj->video_fd, map.data, toread); if (amount == toread) { break; @@ -1730,20 +1743,13 @@ gst_v4l2_buffer_pool_process (GstV4l2BufferPool * pool, GstBuffer ** buf) guint num_queued; gsize size = gst_buffer_get_size (*buf); - if (size == 0) { - if (GST_BUFFER_FLAG_IS_SET (*buf, GST_BUFFER_FLAG_CORRUPTED)) - goto buffer_corrupted; - else - goto eos; - } + /* Legacy M2M devices return empty buffer when drained */ + if (size == 0 && GST_V4L2_IS_M2M (obj->device_caps)) + goto eos; - /* verify that buffer contains a full frame for raw video */ - if (GST_VIDEO_INFO_FORMAT (&obj->info) != GST_VIDEO_FORMAT_ENCODED - && size < GST_VIDEO_INFO_SIZE (&obj->info)) { - GST_WARNING_OBJECT (pool, "Invalid buffer size, this is likely " - "due to a bug in your driver, dropping"); - goto buffer_corrupted; - } + if (GST_VIDEO_INFO_FORMAT (&pool->caps_info) != + GST_VIDEO_FORMAT_ENCODED && size < pool->size) + goto buffer_truncated; num_queued = g_atomic_int_get (&pool->num_queued); GST_TRACE_OBJECT (pool, "Only %i buffer left in the capture queue.", @@ -1784,19 +1790,16 @@ gst_v4l2_buffer_pool_process (GstV4l2BufferPool * pool, GstBuffer ** buf) } /* buffer not from our pool, grab a frame and copy it into the target */ - if ((ret = gst_v4l2_buffer_pool_dqbuf (pool, &tmp)) != GST_FLOW_OK) + if ((ret = gst_v4l2_buffer_pool_dqbuf (pool, &tmp, TRUE)) + != GST_FLOW_OK) goto done; /* An empty buffer on capture indicates the end of stream */ if (gst_buffer_get_size (tmp) == 0) { - gboolean corrupted = GST_BUFFER_FLAG_IS_SET (tmp, - GST_BUFFER_FLAG_CORRUPTED); - gst_v4l2_buffer_pool_release_buffer (bpool, tmp); - if (corrupted) - goto buffer_corrupted; - else + /* Legacy M2M devices return empty buffer when drained */ + if (GST_V4L2_IS_M2M (obj->device_caps)) goto eos; } @@ -1813,12 +1816,20 @@ gst_v4l2_buffer_pool_process (GstV4l2BufferPool * pool, GstBuffer ** buf) case GST_V4L2_IO_USERPTR: { struct UserPtrData *data; + GstBuffer *tmp; /* Replace our buffer with downstream allocated buffer */ data = gst_mini_object_steal_qdata (GST_MINI_OBJECT (*buf), GST_V4L2_IMPORT_QUARK); - gst_buffer_replace (buf, data->buffer); + tmp = gst_buffer_ref (data->buffer); _unmap_userptr_frame (data); + + /* Now tmp is writable, copy the flags and timestamp */ + gst_buffer_copy_into (tmp, *buf, + GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS, 0, -1); + + gst_buffer_replace (buf, tmp); + gst_buffer_unref (tmp); break; } @@ -1829,6 +1840,10 @@ gst_v4l2_buffer_pool_process (GstV4l2BufferPool * pool, GstBuffer ** buf) /* Replace our buffer with downstream allocated buffer */ tmp = gst_mini_object_steal_qdata (GST_MINI_OBJECT (*buf), GST_V4L2_IMPORT_QUARK); + + gst_buffer_copy_into (tmp, *buf, + GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS, 0, -1); + gst_buffer_replace (buf, tmp); gst_buffer_unref (tmp); break; @@ -1855,6 +1870,7 @@ gst_v4l2_buffer_pool_process (GstV4l2BufferPool * pool, GstBuffer ** buf) case GST_V4L2_IO_MMAP: { GstBuffer *to_queue = NULL; + GstBuffer *buffer; GstV4l2MemoryGroup *group; gint index; @@ -1895,9 +1911,13 @@ gst_v4l2_buffer_pool_process (GstV4l2BufferPool * pool, GstBuffer ** buf) gst_buffer_unref (to_queue); goto prepare_failed; } + + /* retreive the group */ + gst_v4l2_is_buffer_valid (to_queue, &group); } - if ((ret = gst_v4l2_buffer_pool_qbuf (pool, to_queue)) != GST_FLOW_OK) + if ((ret = gst_v4l2_buffer_pool_qbuf (pool, to_queue, group)) + != GST_FLOW_OK) goto queue_failed; /* if we are not streaming yet (this is the first buffer, start @@ -1925,15 +1945,21 @@ gst_v4l2_buffer_pool_process (GstV4l2BufferPool * pool, GstBuffer ** buf) * otherwise the pool will think it is outstanding and will refuse to stop. */ gst_buffer_unref (to_queue); + /* release as many buffer as possible */ + while (gst_v4l2_buffer_pool_dqbuf (pool, &buffer, FALSE) == + GST_FLOW_OK) { + if (buffer->pool == NULL) + gst_v4l2_buffer_pool_release_buffer (bpool, buffer); + } + if (g_atomic_int_get (&pool->num_queued) >= pool->min_latency) { - GstBuffer *out; /* all buffers are queued, try to dequeue one and release it back * into the pool so that _acquire can get to it again. */ - ret = gst_v4l2_buffer_pool_dqbuf (pool, &out); - if (ret == GST_FLOW_OK && out->pool == NULL) + ret = gst_v4l2_buffer_pool_dqbuf (pool, &buffer, TRUE); + if (ret == GST_FLOW_OK && buffer->pool == NULL) /* release the rendered buffer back into the pool. This wakes up any * thread waiting for a buffer in _acquire(). */ - gst_v4l2_buffer_pool_release_buffer (bpool, out); + gst_v4l2_buffer_pool_release_buffer (bpool, buffer); } break; } @@ -1955,9 +1981,10 @@ copy_failed: GST_ERROR_OBJECT (pool, "failed to copy buffer"); return ret; } -buffer_corrupted: +buffer_truncated: { - GST_WARNING_OBJECT (pool, "Dropping corrupted buffer without payload"); + GST_WARNING_OBJECT (pool, + "Dropping truncated buffer, this is likely a driver bug."); gst_buffer_unref (*buf); *buf = NULL; return GST_V4L2_FLOW_CORRUPTED_BUFFER; @@ -2013,3 +2040,17 @@ gst_v4l2_buffer_pool_copy_at_threshold (GstV4l2BufferPool * pool, gboolean copy) pool->enable_copy_threshold = copy; GST_OBJECT_UNLOCK (pool); } + +gboolean +gst_v4l2_buffer_pool_flush (GstBufferPool * bpool) +{ + GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); + gboolean ret = TRUE; + + gst_v4l2_buffer_pool_streamoff (pool); + + if (!V4L2_TYPE_IS_OUTPUT (pool->obj->type)) + ret = gst_v4l2_buffer_pool_streamon (pool); + + return ret; +}