From 21f532ae10a6738d92b90c88f3785c30ca578261 Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Fri, 15 Jul 2011 11:27:18 +0200 Subject: [PATCH] v4l2: convert to GstBufferPool Extend from GstBufferPool. Handle the lifetime of the pool buffers correctly with the start/stop vmethods. Map acquire and release directly to QBUF and DQBUF. We still expose an explicit qbuf for the v4l2sink for now. --- sys/v4l2/gstv4l2bufferpool.c | 608 +++++++++++++++++++++---------------------- sys/v4l2/gstv4l2bufferpool.h | 34 +-- sys/v4l2/gstv4l2object.c | 68 ++--- sys/v4l2/gstv4l2object.h | 2 +- 4 files changed, 342 insertions(+), 370 deletions(-) diff --git a/sys/v4l2/gstv4l2bufferpool.c b/sys/v4l2/gstv4l2bufferpool.c index a48c2a8..bb2ef99 100644 --- a/sys/v4l2/gstv4l2bufferpool.c +++ b/sys/v4l2/gstv4l2bufferpool.c @@ -34,6 +34,7 @@ #include "gst/video/gstmetavideo.h" #include + #include "gstv4l2src.h" #include "gstv4l2sink.h" #include "v4l2_calls.h" @@ -69,11 +70,16 @@ gst_meta_v4l2_get_info (void) return meta_info; } +/* + * GstV4l2BufferPool: + */ +#define gst_v4l2_buffer_pool_parent_class parent_class +G_DEFINE_TYPE (GstV4l2BufferPool, gst_v4l2_buffer_pool, GST_TYPE_BUFFER_POOL); + static void -gst_v4l2_buffer_dispose (GstBuffer * buffer) +gst_v4l2_buffer_pool_free_buffer (GstBufferPool * bpool, GstBuffer * buffer) { - GstV4l2BufferPool *pool; - gboolean resuscitated = FALSE; + GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); gint index; GstMetaV4l2 *meta; GstV4l2Object *obj; @@ -81,90 +87,58 @@ gst_v4l2_buffer_dispose (GstBuffer * buffer) meta = GST_META_V4L2_GET (buffer); g_assert (meta != NULL); - pool = meta->pool; - index = meta->vbuffer.index; obj = pool->obj; - GST_LOG_OBJECT (obj->element, "finalizing buffer %p %d", buffer, index); - - GST_V4L2_BUFFER_POOL_LOCK (pool); - if (pool->running) { - if (pool->requeuebuf) { - if (!gst_v4l2_buffer_pool_qbuf (pool, buffer)) { - GST_WARNING_OBJECT (obj->element, "could not requeue buffer %p %d", - buffer, index); - } else { - resuscitated = TRUE; - } - } else { - resuscitated = TRUE; - /* XXX double check this... I think it is ok to not synchronize this - * w.r.t. destruction of the pool, since the buffer is still live and - * the buffer holds a ref to the pool.. - */ - g_async_queue_push (pool->avail_buffers, buffer); - } - } else { - GST_LOG_OBJECT (obj->element, "the pool is shutting down"); - } - - if (resuscitated) { - GST_LOG_OBJECT (obj->element, "reviving buffer %p, %d", buffer, index); - gst_buffer_ref (buffer); - pool->buffers[index] = buffer; - } - - GST_V4L2_BUFFER_POOL_UNLOCK (pool); + index = meta->vbuffer.index; + GST_LOG_OBJECT (pool, "finalizing buffer %p %d", buffer, index); + pool->buffers[index] = NULL; - if (!resuscitated) { - GST_LOG_OBJECT (obj->element, - "buffer %p (data %p, len %u) not recovered, unmapping", - buffer, meta->mem, meta->vbuffer.length); - v4l2_munmap (meta->mem, meta->vbuffer.length); + GST_LOG_OBJECT (pool, + "buffer %p (data %p, len %u) freed, unmapping", + buffer, meta->mem, meta->vbuffer.length); + v4l2_munmap (meta->mem, meta->vbuffer.length); - g_object_unref (pool); - } + gst_buffer_unref (buffer); } -static GstBuffer * -gst_v4l2_buffer_new (GstV4l2BufferPool * pool, guint index) +static GstFlowReturn +gst_v4l2_buffer_pool_alloc_buffer (GstBufferPool * bpool, GstBuffer ** buffer, + GstBufferPoolParams * params) { - GstBuffer *ret; + GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); + GstBuffer *newbuf; GstMetaV4l2 *meta; GstV4l2Object *obj; GstVideoInfo *info; + guint index; obj = pool->obj; info = &obj->info; - ret = gst_buffer_new (); - GST_MINI_OBJECT_CAST (ret)->dispose = - (GstMiniObjectDisposeFunction) gst_v4l2_buffer_dispose; + newbuf = gst_buffer_new (); + meta = GST_META_V4L2_ADD (newbuf); - meta = GST_META_V4L2_ADD (ret); + index = pool->index; - GST_LOG_OBJECT (obj->element, "creating buffer %u, %p in pool %p", index, - ret, pool); - - meta->pool = (GstV4l2BufferPool *) g_object_ref (pool); + GST_LOG_OBJECT (pool, "creating buffer %u, %p", index, newbuf, pool); meta->vbuffer.index = index; - meta->vbuffer.type = pool->type; + meta->vbuffer.type = obj->type; meta->vbuffer.memory = V4L2_MEMORY_MMAP; if (v4l2_ioctl (pool->video_fd, VIDIOC_QUERYBUF, &meta->vbuffer) < 0) goto querybuf_failed; - GST_LOG_OBJECT (obj->element, " index: %u", meta->vbuffer.index); - GST_LOG_OBJECT (obj->element, " type: %d", meta->vbuffer.type); - GST_LOG_OBJECT (obj->element, " bytesused: %u", meta->vbuffer.bytesused); - GST_LOG_OBJECT (obj->element, " flags: %08x", meta->vbuffer.flags); - GST_LOG_OBJECT (obj->element, " field: %d", meta->vbuffer.field); - GST_LOG_OBJECT (obj->element, " memory: %d", meta->vbuffer.memory); + GST_LOG_OBJECT (pool, " index: %u", meta->vbuffer.index); + GST_LOG_OBJECT (pool, " type: %d", meta->vbuffer.type); + GST_LOG_OBJECT (pool, " bytesused: %u", meta->vbuffer.bytesused); + GST_LOG_OBJECT (pool, " flags: %08x", meta->vbuffer.flags); + GST_LOG_OBJECT (pool, " field: %d", meta->vbuffer.field); + GST_LOG_OBJECT (pool, " memory: %d", meta->vbuffer.memory); if (meta->vbuffer.memory == V4L2_MEMORY_MMAP) - GST_LOG_OBJECT (obj->element, " MMAP offset: %u", meta->vbuffer.m.offset); - GST_LOG_OBJECT (obj->element, " length: %u", meta->vbuffer.length); - GST_LOG_OBJECT (obj->element, " input: %u", meta->vbuffer.input); + GST_LOG_OBJECT (pool, " MMAP offset: %u", meta->vbuffer.m.offset); + GST_LOG_OBJECT (pool, " length: %u", meta->vbuffer.length); + GST_LOG_OBJECT (pool, " input: %u", meta->vbuffer.input); meta->mem = v4l2_mmap (0, meta->vbuffer.length, PROT_READ | PROT_WRITE, MAP_SHARED, pool->video_fd, @@ -172,7 +146,7 @@ gst_v4l2_buffer_new (GstV4l2BufferPool * pool, guint index) if (meta->mem == MAP_FAILED) goto mmap_failed; - gst_buffer_take_memory (ret, -1, + gst_buffer_take_memory (newbuf, -1, gst_memory_new_wrapped (0, meta->mem, NULL, meta->vbuffer.length, 0, meta->vbuffer.length)); @@ -184,13 +158,18 @@ gst_v4l2_buffer_new (GstV4l2BufferPool * pool, guint index) offset[0] = 0; stride[0] = obj->bytesperline; - GST_DEBUG ("adding video meta"); - gst_buffer_add_meta_video_full (ret, info->flags, + GST_DEBUG_OBJECT (pool, "adding video meta"); + gst_buffer_add_meta_video_full (newbuf, info->flags, GST_VIDEO_INFO_FORMAT (info), GST_VIDEO_INFO_WIDTH (info), GST_VIDEO_INFO_HEIGHT (info), GST_VIDEO_INFO_N_PLANES (info), offset, stride); } - return ret; + + pool->index++; + + *buffer = newbuf; + + return GST_FLOW_OK; /* ERRORS */ querybuf_failed: @@ -198,95 +177,63 @@ querybuf_failed: gint errnosave = errno; GST_WARNING ("Failed QUERYBUF: %s", g_strerror (errnosave)); - gst_buffer_unref (ret); + gst_buffer_unref (newbuf); errno = errnosave; - return NULL; + return GST_FLOW_ERROR; } mmap_failed: { gint errnosave = errno; GST_WARNING ("Failed to mmap: %s", g_strerror (errnosave)); - gst_buffer_unref (ret); + gst_buffer_unref (newbuf); errno = errnosave; - return NULL; + return GST_FLOW_ERROR; } } -/* - * GstV4l2BufferPool: - */ -#define gst_v4l2_buffer_pool_parent_class parent_class -G_DEFINE_TYPE (GstV4l2BufferPool, gst_v4l2_buffer_pool, G_TYPE_OBJECT); - -static void -gst_v4l2_buffer_pool_finalize (GObject * object) +static gboolean +gst_v4l2_buffer_pool_set_config (GstBufferPool * bpool, GstStructure * config) { - GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (object); - - g_mutex_free (pool->lock); - pool->lock = NULL; + GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); + const GstCaps *caps; + guint size, min_buffers, max_buffers; + guint prefix, align; - g_async_queue_unref (pool->avail_buffers); - pool->avail_buffers = NULL; + GST_DEBUG_OBJECT (pool, "set config"); - if (pool->video_fd >= 0) - v4l2_close (pool->video_fd); - - if (pool->buffers) { - g_free (pool->buffers); - pool->buffers = NULL; - } + /* parse the config and keep around */ + if (!gst_buffer_pool_config_get (config, &caps, &size, &min_buffers, + &max_buffers, &prefix, &align)) + goto wrong_config; - G_OBJECT_CLASS (parent_class)->finalize (object); -} + GST_DEBUG_OBJECT (pool, "config %" GST_PTR_FORMAT, config); -static void -gst_v4l2_buffer_pool_init (GstV4l2BufferPool * pool) -{ - pool->lock = g_mutex_new (); - pool->running = FALSE; - pool->num_live_buffers = 0; -} + pool->min_buffers = min_buffers; + pool->max_buffers = max_buffers; -static void -gst_v4l2_buffer_pool_class_init (GstV4l2BufferPoolClass * klass) -{ - GObjectClass *object_class = G_OBJECT_CLASS (klass); + return TRUE; - object_class->finalize = gst_v4l2_buffer_pool_finalize; +wrong_config: + { + GST_WARNING_OBJECT (pool, "invalid config %" GST_PTR_FORMAT, config); + return FALSE; + } } -/** - * gst_v4l2_buffer_pool_new: - * @obj: the v4l2 object owning the pool - * @num_buffers: the requested number of buffers in the pool - * @requeuebuf: if %TRUE, and if the pool is still in the running state, a - * buffer with no remaining references is immediately passed back to v4l2 - * (VIDIOC_QBUF), otherwise it is returned to the pool of available buffers - * (which can be accessed via gst_v4l2_buffer_pool_get(). - * - * Construct a new buffer pool. - * - * Returns: the new pool, use gst_v4l2_buffer_pool_destroy() to free resources - */ -GstV4l2BufferPool * -gst_v4l2_buffer_pool_new (GstV4l2Object * obj, gint num_buffers, - gboolean requeuebuf) +static gboolean +gst_v4l2_buffer_pool_start (GstBufferPool * bpool) { - GstV4l2BufferPool *pool; + GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); + GstV4l2Object *obj = pool->obj; gint n; struct v4l2_requestbuffers breq; + gint num_buffers; - pool = (GstV4l2BufferPool *) g_object_new (GST_TYPE_V4L2_BUFFER_POOL, NULL); - - pool->video_fd = v4l2_dup (obj->video_fd); - if (pool->video_fd < 0) - goto dup_failed; + num_buffers = pool->max_buffers; /* first, lets request buffers, and see how many we can get: */ - GST_DEBUG_OBJECT (obj->element, "STREAMING, requesting %d MMAP buffers", - num_buffers); + GST_DEBUG_OBJECT (pool, "starting, requesting %d MMAP buffers", num_buffers); memset (&breq, 0, sizeof (struct v4l2_requestbuffers)); breq.type = obj->type; @@ -296,302 +243,325 @@ gst_v4l2_buffer_pool_new (GstV4l2Object * obj, gint num_buffers, if (v4l2_ioctl (pool->video_fd, VIDIOC_REQBUFS, &breq) < 0) goto reqbufs_failed; - GST_LOG_OBJECT (obj->element, " count: %u", breq.count); - GST_LOG_OBJECT (obj->element, " type: %d", breq.type); - GST_LOG_OBJECT (obj->element, " memory: %d", breq.memory); + GST_LOG_OBJECT (pool, " count: %u", breq.count); + GST_LOG_OBJECT (pool, " type: %d", breq.type); + GST_LOG_OBJECT (pool, " memory: %d", breq.memory); if (breq.count < GST_V4L2_MIN_BUFFERS) goto no_buffers; if (num_buffers != breq.count) { - GST_WARNING_OBJECT (obj->element, "using %u buffers instead", breq.count); + GST_WARNING_OBJECT (pool, "using %u buffers instead", breq.count); num_buffers = breq.count; } pool->obj = obj; - pool->requeuebuf = requeuebuf; - pool->type = obj->type; + pool->requeuebuf = (obj->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ? TRUE : FALSE); pool->buffer_count = num_buffers; pool->buffers = g_new0 (GstBuffer *, num_buffers); - pool->avail_buffers = g_async_queue_new (); + pool->index = 0; /* now, map the buffers: */ for (n = 0; n < num_buffers; n++) { - pool->buffers[n] = gst_v4l2_buffer_new (pool, n); - if (!pool->buffers[n]) + GstBuffer *buffer; + + if (gst_v4l2_buffer_pool_alloc_buffer (bpool, &buffer, NULL) != GST_FLOW_OK) goto buffer_new_failed; - pool->num_live_buffers++; - g_async_queue_push (pool->avail_buffers, pool->buffers[n]); - } - return pool; + if (pool->requeuebuf) + gst_v4l2_buffer_pool_qbuf (bpool, buffer); + } + return TRUE; /* ERRORS */ -dup_failed: - { - gint errnosave = errno; - - g_object_unref (pool); - - errno = errnosave; - - return NULL; - } reqbufs_failed: { - GST_ELEMENT_ERROR (obj->element, RESOURCE, READ, + GST_ELEMENT_ERROR (pool, RESOURCE, READ, (_("Could not get buffers from device '%s'."), obj->videodev), ("error requesting %d buffers: %s", num_buffers, g_strerror (errno))); - return NULL; + return FALSE; } no_buffers: { - GST_ELEMENT_ERROR (obj->element, RESOURCE, READ, + GST_ELEMENT_ERROR (pool, RESOURCE, READ, (_("Could not get enough buffers from device '%s'."), obj->videodev), ("we received %d from device '%s', we want at least %d", breq.count, obj->videodev, GST_V4L2_MIN_BUFFERS)); - return NULL; + return FALSE; } buffer_new_failed: { - gint errnosave = errno; - - gst_v4l2_buffer_pool_destroy (pool); - - errno = errnosave; - - return NULL; - } -} - -/** - * gst_v4l2_buffer_pool_destroy: - * @pool: the pool - * - * Free all resources in the pool and the pool itself. - */ -void -gst_v4l2_buffer_pool_destroy (GstV4l2BufferPool * pool) -{ - gint n; - GstV4l2Object *obj = pool->obj; - - GST_V4L2_BUFFER_POOL_LOCK (pool); - pool->running = FALSE; - GST_V4L2_BUFFER_POOL_UNLOCK (pool); - - GST_DEBUG_OBJECT (obj->element, "destroy pool"); - - /* after this point, no more buffers will be queued or dequeued; no buffer - * from pool->buffers that is NULL will be set to a buffer, and no buffer that - * is not NULL will be pushed out. */ - - /* miniobjects have no dispose, so they can't break ref-cycles, as buffers ref - * the pool, we need to unref the buffer to properly finalize te pool */ - for (n = 0; n < pool->buffer_count; n++) { - GstBuffer *buf; - - GST_V4L2_BUFFER_POOL_LOCK (pool); - buf = pool->buffers[n]; - GST_V4L2_BUFFER_POOL_UNLOCK (pool); - - if (buf) - /* we own the ref if the buffer is in pool->buffers; drop it. */ - gst_buffer_unref (buf); - } - - g_object_unref (pool); -} - -/** - * gst_v4l2_buffer_pool_get: - * @pool: the "this" object - * @blocking: should this call suspend until there is a buffer available - * in the buffer pool? - * - * Get an available buffer in the pool - */ -GstBuffer * -gst_v4l2_buffer_pool_get (GstV4l2BufferPool * pool, gboolean blocking) -{ - GstBuffer *buf; - - if (blocking) { - buf = g_async_queue_pop (pool->avail_buffers); - } else { - buf = g_async_queue_try_pop (pool->avail_buffers); - } - - if (buf) { - GstMetaV4l2 *meta = GST_META_V4L2_GET (buf); - - GST_V4L2_BUFFER_POOL_LOCK (pool); - gst_buffer_resize (buf, 0, meta->vbuffer.length); - GST_BUFFER_FLAG_UNSET (buf, 0xffffffff); - GST_V4L2_BUFFER_POOL_UNLOCK (pool); + return FALSE; } - - pool->running = TRUE; - - return buf; } - -/** - * gst_v4l2_buffer_pool_qbuf: - * @pool: the pool - * @buf: the buffer to queue - * - * Queue a buffer to the driver - * - * Returns: %TRUE for success - */ -gboolean -gst_v4l2_buffer_pool_qbuf (GstV4l2BufferPool * pool, GstBuffer * buf) +static gboolean +gst_v4l2_buffer_pool_stop (GstBufferPool * bpool) { - GstMetaV4l2 *meta; - GstV4l2Object *obj = pool->obj; - - meta = GST_META_V4L2_GET (buf); + GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); + guint n; - GST_LOG_OBJECT (obj->element, "enqueue pool buffer %d", meta->vbuffer.index); + GST_DEBUG_OBJECT (pool, "stopping pool"); - if (v4l2_ioctl (pool->video_fd, VIDIOC_QBUF, &meta->vbuffer) < 0) - goto queue_failed; - - pool->num_live_buffers--; - GST_DEBUG_OBJECT (obj->element, "num_live_buffers--: %d", - pool->num_live_buffers); + /* free the buffers: */ + for (n = 0; n < pool->buffer_count; n++) + gst_v4l2_buffer_pool_free_buffer (bpool, pool->buffers[n]); return TRUE; - - /* ERRORS */ -queue_failed: - { - GST_WARNING_OBJECT (obj->element, "could not queue a buffer"); - return FALSE; - } } -/** - * gst_v4l2_buffer_pool_dqbuf: - * @pool: the pool - * - * Dequeue a buffer from the driver. Some generic error handling is done in - * this function, but any error handling specific to v4l2src (capture) or - * v4l2sink (output) can be done outside this function by checking 'errno' - * - * Returns: a buffer - */ -GstBuffer * -gst_v4l2_buffer_pool_dqbuf (GstV4l2BufferPool * pool) +static GstFlowReturn +gst_v4l2_buffer_pool_acquire_buffer (GstBufferPool * bpool, GstBuffer ** buffer, + GstBufferPoolParams * params) { - GstBuffer *pool_buffer; - struct v4l2_buffer buffer; + GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); + GstBuffer *outbuf; + struct v4l2_buffer vbuffer; GstV4l2Object *obj = pool->obj; - memset (&buffer, 0x00, sizeof (buffer)); - buffer.type = pool->type; - buffer.memory = V4L2_MEMORY_MMAP; + if (GST_BUFFER_POOL_IS_FLUSHING (bpool)) + goto flushing; - if (v4l2_ioctl (pool->video_fd, VIDIOC_DQBUF, &buffer) < 0) - goto error; + memset (&vbuffer, 0x00, sizeof (vbuffer)); + vbuffer.type = obj->type; + vbuffer.memory = V4L2_MEMORY_MMAP; - GST_V4L2_BUFFER_POOL_LOCK (pool); + if (v4l2_ioctl (pool->video_fd, VIDIOC_DQBUF, &vbuffer) < 0) + goto error; /* get our GstBuffer with that index from the pool, if the buffer was * outstanding we have a serious problem. */ - pool_buffer = pool->buffers[buffer.index]; - - if (pool_buffer == NULL) + outbuf = pool->buffers[vbuffer.index]; + if (outbuf == NULL) goto no_buffers; - GST_LOG_OBJECT (obj->element, - "grabbed frame %d (ix=%d), flags %08x, pool-ct=%d, buffer=%p", - buffer.sequence, buffer.index, buffer.flags, pool->num_live_buffers, - pool_buffer); + /* mark the buffer outstanding */ + pool->buffers[vbuffer.index] = NULL; + + GST_LOG_OBJECT (pool, + "dequeued frame %d (ix=%d), flags %08x, pool-ct=%d, buffer=%p", + vbuffer.sequence, vbuffer.index, vbuffer.flags, pool->num_live_buffers, + outbuf); pool->num_live_buffers++; - GST_DEBUG_OBJECT (obj->element, "num_live_buffers++: %d", - pool->num_live_buffers); + GST_DEBUG_OBJECT (pool, "num_live_buffers++: %d", pool->num_live_buffers); /* set top/bottom field first if v4l2_buffer has the information */ - if (buffer.field == V4L2_FIELD_INTERLACED_TB) - GST_BUFFER_FLAG_SET (pool_buffer, GST_VIDEO_BUFFER_TFF); - if (buffer.field == V4L2_FIELD_INTERLACED_BT) - GST_BUFFER_FLAG_UNSET (pool_buffer, GST_VIDEO_BUFFER_TFF); + if (vbuffer.field == V4L2_FIELD_INTERLACED_TB) + GST_BUFFER_FLAG_SET (outbuf, GST_VIDEO_BUFFER_TFF); + if (vbuffer.field == V4L2_FIELD_INTERLACED_BT) + GST_BUFFER_FLAG_UNSET (outbuf, GST_VIDEO_BUFFER_TFF); /* this can change at every frame, esp. with jpeg */ - gst_buffer_resize (pool_buffer, 0, buffer.bytesused); + gst_buffer_resize (outbuf, 0, vbuffer.bytesused); - GST_V4L2_BUFFER_POOL_UNLOCK (pool); + *buffer = outbuf; - return pool_buffer; + return GST_FLOW_OK; /* ERRORS */ +flushing: + { + return GST_FLOW_WRONG_STATE; + } error: { - GST_WARNING_OBJECT (obj->element, + GST_WARNING_OBJECT (pool, "problem grabbing frame %d (ix=%d), pool-ct=%d, buf.flags=%d", - buffer.sequence, buffer.index, - GST_MINI_OBJECT_REFCOUNT (pool), buffer.flags); + vbuffer.sequence, vbuffer.index, + GST_MINI_OBJECT_REFCOUNT (pool), vbuffer.flags); switch (errno) { case EAGAIN: - GST_WARNING_OBJECT (obj->element, + GST_WARNING_OBJECT (pool, "Non-blocking I/O has been selected using O_NONBLOCK and" " no buffer was in the outgoing queue. device %s", obj->videodev); break; case EINVAL: - GST_ELEMENT_ERROR (obj->element, RESOURCE, FAILED, + GST_ELEMENT_ERROR (pool, RESOURCE, FAILED, (_("Failed trying to get video frames from device '%s'."), obj->videodev), (_("The buffer type is not supported, or the index is out of bounds," " or no buffers have been allocated yet, or the userptr" " or length are invalid. device %s"), obj->videodev)); break; case ENOMEM: - GST_ELEMENT_ERROR (obj->element, RESOURCE, FAILED, + GST_ELEMENT_ERROR (pool, RESOURCE, FAILED, (_("Failed trying to get video frames from device '%s'. Not enough memory."), obj->videodev), (_("insufficient memory to enqueue a user pointer buffer. device %s."), obj->videodev)); break; case EIO: - GST_INFO_OBJECT (obj->element, + GST_INFO_OBJECT (pool, "VIDIOC_DQBUF failed due to an internal error." " Can also indicate temporary problems like signal loss." " Note the driver might dequeue an (empty) buffer despite" " returning an error, or even stop capturing." " device %s", obj->videodev); /* have we de-queued a buffer ? */ - if (!(buffer.flags & (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE))) { - GST_DEBUG_OBJECT (obj->element, "reenqueing buffer"); + if (!(vbuffer.flags & (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE))) { + GST_DEBUG_OBJECT (pool, "reenqueing buffer"); /* FIXME ... should we do something here? */ } break; case EINTR: - GST_WARNING_OBJECT (obj->element, + GST_WARNING_OBJECT (pool, "could not sync on a buffer on device %s", obj->videodev); break; default: - GST_WARNING_OBJECT (obj->element, + GST_WARNING_OBJECT (pool, "Grabbing frame got interrupted on %s unexpectedly. %d: %s.", obj->videodev, errno, g_strerror (errno)); break; } - return NULL; + return GST_FLOW_ERROR; } no_buffers: { - GST_ELEMENT_ERROR (obj->element, RESOURCE, FAILED, + GST_ELEMENT_ERROR (pool, RESOURCE, FAILED, (_("Failed trying to get video frames from device '%s'."), obj->videodev), - (_("No free buffers found in the pool at index %d."), buffer.index)); - GST_V4L2_BUFFER_POOL_UNLOCK (pool); + (_("No free buffers found in the pool at index %d."), vbuffer.index)); + return GST_FLOW_ERROR; + } +} + +static void +gst_v4l2_buffer_pool_release_buffer (GstBufferPool * bpool, GstBuffer * buffer) +{ + GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); + + GST_DEBUG_OBJECT (pool, "release"); + + if (pool->requeuebuf) + gst_v4l2_buffer_pool_qbuf (bpool, buffer); +} + +static void +gst_v4l2_buffer_pool_finalize (GObject * object) +{ + GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (object); + + if (pool->video_fd >= 0) + v4l2_close (pool->video_fd); + + if (pool->buffers) { + g_free (pool->buffers); + pool->buffers = NULL; + } + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +gst_v4l2_buffer_pool_init (GstV4l2BufferPool * pool) +{ +} + +static void +gst_v4l2_buffer_pool_class_init (GstV4l2BufferPoolClass * klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GstBufferPoolClass *bufferpool_class = GST_BUFFER_POOL_CLASS (klass); + + object_class->finalize = gst_v4l2_buffer_pool_finalize; + + bufferpool_class->start = gst_v4l2_buffer_pool_start; + bufferpool_class->stop = gst_v4l2_buffer_pool_stop; + bufferpool_class->set_config = gst_v4l2_buffer_pool_set_config; + bufferpool_class->alloc_buffer = gst_v4l2_buffer_pool_alloc_buffer; + bufferpool_class->acquire_buffer = gst_v4l2_buffer_pool_acquire_buffer; + bufferpool_class->release_buffer = gst_v4l2_buffer_pool_release_buffer; + bufferpool_class->free_buffer = gst_v4l2_buffer_pool_free_buffer; +} + +/** + * gst_v4l2_buffer_pool_new: + * @obj: the v4l2 object owning the pool + * @num_buffers: the requested number of buffers in the pool + * @requeuebuf: if %TRUE, and if the pool is still in the running state, a + * buffer with no remaining references is immediately passed back to v4l2 + * (VIDIOC_QBUF), otherwise it is returned to the pool of available buffers + * (which can be accessed via gst_v4l2_buffer_pool_get(). + * + * Construct a new buffer pool. + * + * Returns: the new pool, use gst_v4l2_buffer_pool_destroy() to free resources + */ +GstBufferPool * +gst_v4l2_buffer_pool_new (GstV4l2Object * obj) +{ + GstV4l2BufferPool *pool; + + pool = (GstV4l2BufferPool *) g_object_new (GST_TYPE_V4L2_BUFFER_POOL, NULL); + + pool->video_fd = v4l2_dup (obj->video_fd); + if (pool->video_fd < 0) + goto dup_failed; + + pool->obj = obj; + + return GST_BUFFER_POOL_CAST (pool); + + /* ERRORS */ +dup_failed: + { + gint errnosave = errno; + gst_object_unref (pool); + errno = errnosave; return NULL; } } /** + * gst_v4l2_buffer_pool_qbuf: + * @pool: the pool + * @buf: the buffer to queue + * + * Queue a buffer to the driver + * + * Returns: %TRUE for success + */ +gboolean +gst_v4l2_buffer_pool_qbuf (GstBufferPool * bpool, GstBuffer * buf) +{ + GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); + GstMetaV4l2 *meta; + gint index; + + meta = GST_META_V4L2_GET (buf); + g_assert (meta != NULL); + + index = meta->vbuffer.index; + + GST_LOG_OBJECT (pool, "enqueue pool buffer %d", index); + + if (pool->buffers[index] != NULL) + goto already_queued; + + if (v4l2_ioctl (pool->video_fd, VIDIOC_QBUF, &meta->vbuffer) < 0) + goto queue_failed; + + pool->buffers[index] = buf; + + pool->num_live_buffers--; + GST_DEBUG_OBJECT (pool, "num_live_buffers--: %d", pool->num_live_buffers); + + return TRUE; + + /* ERRORS */ +already_queued: + { + GST_WARNING_OBJECT (pool, "the buffer was already queued"); + return FALSE; + } +queue_failed: + { + GST_WARNING_OBJECT (pool, "could not queue a buffer"); + return FALSE; + } +} + +/** * gst_v4l2_buffer_pool_available_buffers: * @pool: the pool * @@ -601,7 +571,9 @@ no_buffers: * Returns: the number of buffers available. */ gint -gst_v4l2_buffer_pool_available_buffers (GstV4l2BufferPool * pool) +gst_v4l2_buffer_pool_available_buffers (GstBufferPool * bpool) { + GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); + return pool->buffer_count - pool->num_live_buffers; } diff --git a/sys/v4l2/gstv4l2bufferpool.h b/sys/v4l2/gstv4l2bufferpool.h index 47c628a..9173087 100644 --- a/sys/v4l2/gstv4l2bufferpool.h +++ b/sys/v4l2/gstv4l2bufferpool.h @@ -39,34 +39,31 @@ GST_DEBUG_CATEGORY_EXTERN (v4l2buffer_debug); G_BEGIN_DECLS -GType gst_v4l2_buffer_pool_get_type (void); #define GST_TYPE_V4L2_BUFFER_POOL (gst_v4l2_buffer_pool_get_type()) #define GST_IS_V4L2_BUFFER_POOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_V4L2_BUFFER_POOL)) #define GST_V4L2_BUFFER_POOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_V4L2_BUFFER_POOL, GstV4l2BufferPool)) -#define GST_V4L2_BUFFER_POOL_LOCK(pool) g_mutex_lock ((pool)->lock) -#define GST_V4L2_BUFFER_POOL_UNLOCK(pool) g_mutex_unlock ((pool)->lock) - struct _GstV4l2BufferPool { - GObject parent; + GstBufferPool parent; GstV4l2Object *obj; /* the v4l2 object */ + gint video_fd; /* a dup(2) of the v4l2object's video_fd */ gboolean requeuebuf; /* if true, unusued buffers are automatically re-QBUF'd */ - enum v4l2_buf_type type; /* V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_OUTPUT */ - GMutex *lock; - gboolean running; /* with lock */ - gint num_live_buffers; /* number of buffers not with driver */ - GAsyncQueue* avail_buffers;/* pool of available buffers, not with the driver and which aren't held outside the bufferpool */ - gint video_fd; /* a dup(2) of the v4l2object's video_fd */ + guint min_buffers; + guint max_buffers; + guint buffer_count; + gint index; + gint num_live_buffers; /* number of buffers not with driver */ + GstBuffer **buffers; }; struct _GstV4l2BufferPoolClass { - GObjectClass parent_class; + GstBufferPoolClass parent_class; }; struct _GstMetaV4l2 { @@ -74,24 +71,19 @@ struct _GstMetaV4l2 { gpointer mem; struct v4l2_buffer vbuffer; - - GstV4l2BufferPool *pool; }; const GstMetaInfo * gst_meta_v4l2_get_info (void); #define GST_META_V4L2_GET(buf) ((GstMetaV4l2 *)gst_buffer_get_meta(buf,gst_meta_v4l2_get_info())) #define GST_META_V4L2_ADD(buf) ((GstMetaV4l2 *)gst_buffer_add_meta(buf,gst_meta_v4l2_get_info(),NULL)) -GstV4l2BufferPool * gst_v4l2_buffer_pool_new (GstV4l2Object *obj, gint num_buffers, gboolean requeuebuf); -void gst_v4l2_buffer_pool_destroy (GstV4l2BufferPool * pool); - -GstBuffer * gst_v4l2_buffer_pool_get (GstV4l2BufferPool *pool, gboolean blocking); +GType gst_v4l2_buffer_pool_get_type (void); +GstBufferPool * gst_v4l2_buffer_pool_new (GstV4l2Object *obj); -gboolean gst_v4l2_buffer_pool_qbuf (GstV4l2BufferPool *pool, GstBuffer *buf); -GstBuffer * gst_v4l2_buffer_pool_dqbuf (GstV4l2BufferPool *pool); +gboolean gst_v4l2_buffer_pool_qbuf (GstBufferPool * bpool, GstBuffer * buf); -gint gst_v4l2_buffer_pool_available_buffers (GstV4l2BufferPool *pool); +gint gst_v4l2_buffer_pool_available_buffers (GstBufferPool *pool); G_END_DECLS diff --git a/sys/v4l2/gstv4l2object.c b/sys/v4l2/gstv4l2object.c index cc8ba7c..215c447 100644 --- a/sys/v4l2/gstv4l2object.c +++ b/sys/v4l2/gstv4l2object.c @@ -2050,24 +2050,27 @@ gst_v4l2_object_setup_pool (GstV4l2Object * v4l2object) GST_V4L2_CHECK_NOT_ACTIVE (v4l2object); if (v4l2object->vcap.capabilities & V4L2_CAP_STREAMING) { - gboolean requeuebuf; + guint num_buffers; + GstStructure *config; - requeuebuf = v4l2object->type == V4L2_BUF_TYPE_VIDEO_CAPTURE; + /* keep track of current number of buffers */ + num_buffers = v4l2object->num_buffers; /* Map the buffers */ GST_LOG_OBJECT (v4l2object->element, "initiating buffer pool"); - if (!(v4l2object->pool = gst_v4l2_buffer_pool_new (v4l2object, - v4l2object->num_buffers, requeuebuf))) + if (!(v4l2object->pool = gst_v4l2_buffer_pool_new (v4l2object))) goto buffer_pool_new_failed; GST_INFO_OBJECT (v4l2object->element, "capturing buffers via mmap()"); v4l2object->use_mmap = TRUE; - if (v4l2object->num_buffers != v4l2object->pool->buffer_count) { - v4l2object->num_buffers = v4l2object->pool->buffer_count; - g_object_notify (G_OBJECT (v4l2object->element), "queue-size"); - } + config = gst_buffer_pool_get_config (v4l2object->pool); + gst_buffer_pool_config_set (config, NULL, 0, num_buffers, num_buffers, + 0, 0); + gst_buffer_pool_set_config (v4l2object->pool, config); + + gst_buffer_pool_set_active (v4l2object->pool, TRUE); } else if (v4l2object->vcap.capabilities & V4L2_CAP_READWRITE) { GST_INFO_OBJECT (v4l2object->element, "capturing buffers via read()"); @@ -2335,22 +2338,18 @@ pool_failed: gboolean gst_v4l2_object_start (GstV4l2Object * v4l2object) { - GstBuffer *buf; - GST_DEBUG_OBJECT (v4l2object->element, "starting"); GST_V4L2_CHECK_OPEN (v4l2object); GST_V4L2_CHECK_ACTIVE (v4l2object); + if (v4l2object->pool) + if (!gst_buffer_pool_set_active (v4l2object->pool, TRUE)) + goto activate_failed; + if (v4l2object->use_mmap) { switch (v4l2object->type) { case V4L2_BUF_TYPE_VIDEO_CAPTURE: - /* for capture, queue all the buffers so the device can start filling - * them */ - GST_DEBUG_OBJECT (v4l2object->element, "queueing buffers"); - while ((buf = gst_v4l2_buffer_pool_get (v4l2object->pool, FALSE))) - if (!gst_v4l2_buffer_pool_qbuf (v4l2object->pool, buf)) - goto queue_failed; break; case V4L2_BUF_TYPE_VIDEO_OUTPUT: /* for output, we assume we already queued a buffer */ @@ -2369,14 +2368,10 @@ gst_v4l2_object_start (GstV4l2Object * v4l2object) return TRUE; /* ERRORS */ -queue_failed: +activate_failed: { - GST_ELEMENT_ERROR (v4l2object->element, RESOURCE, READ, - (_("Could not enqueue buffers in device '%s'."), - v4l2object->videodev), - ("enqueing buffer %d/%d failed: %s", - GST_META_V4L2_GET (buf)->vbuffer.index, v4l2object->num_buffers, - g_strerror (errno))); + GST_ELEMENT_ERROR (v4l2object->element, RESOURCE, OPEN_READ, + (_("Error starting bufferpool")), (NULL)); return FALSE; } start_failed: @@ -2412,7 +2407,9 @@ gst_v4l2_object_stop (GstV4l2Object * v4l2object) } if (v4l2object->pool) { - gst_v4l2_buffer_pool_destroy (v4l2object->pool); + GST_DEBUG_OBJECT (v4l2object->element, "deactivating pool"); + gst_buffer_pool_set_active (v4l2object->pool, FALSE); + gst_object_unref (v4l2object->pool); v4l2object->pool = NULL; } @@ -2516,8 +2513,9 @@ cleanup: static GstFlowReturn gst_v4l2_object_get_mmap (GstV4l2Object * v4l2object, GstBuffer ** buf) { + GstFlowReturn res; #define NUM_TRIALS 50 - GstV4l2BufferPool *pool; + GstBufferPool *pool; gint32 trials = NUM_TRIALS; GstBuffer *pool_buffer; gboolean need_copy; @@ -2546,8 +2544,8 @@ gst_v4l2_object_get_mmap (GstV4l2Object * v4l2object, GstBuffer ** buf) } } - pool_buffer = gst_v4l2_buffer_pool_dqbuf (pool); - if (pool_buffer == NULL) + res = gst_buffer_pool_acquire_buffer (pool, &pool_buffer, NULL); + if (res != GST_FLOW_OK) goto no_buffer; if (v4l2object->size > 0) { @@ -2651,7 +2649,7 @@ gst_v4l2_object_get_buffer (GstV4l2Object * v4l2object, GstBuffer ** buf) } break; case V4L2_BUF_TYPE_VIDEO_OUTPUT: - ret = GST_FLOW_ERROR; + ret = gst_buffer_pool_acquire_buffer (v4l2object->pool, buf, NULL); break; default: ret = GST_FLOW_ERROR; @@ -2663,18 +2661,21 @@ gst_v4l2_object_get_buffer (GstV4l2Object * v4l2object, GstBuffer ** buf) GstFlowReturn gst_v4l2_object_output_buffer (GstV4l2Object * v4l2object, GstBuffer * buf) { + GstFlowReturn ret; GstBuffer *newbuf = NULL; GstMetaV4l2 *meta; meta = GST_META_V4L2_GET (buf); - if (meta == NULL || meta->pool != v4l2object->pool) { + if (meta == NULL || buf->pool != v4l2object->pool) { guint8 *data; gsize size; /* not our buffer */ GST_DEBUG_OBJECT (v4l2object->element, "slow-path.. need to memcpy"); - newbuf = gst_v4l2_buffer_pool_get (v4l2object->pool, TRUE); + ret = gst_buffer_pool_acquire_buffer (v4l2object->pool, &newbuf, NULL); + if (ret != GST_FLOW_OK) + goto acquire_failed; if (v4l2object->info.finfo) { GstVideoFrame src_frame, dest_frame; @@ -2710,6 +2711,7 @@ gst_v4l2_object_output_buffer (GstV4l2Object * v4l2object, GstBuffer * buf) if (!newbuf) gst_buffer_ref (buf); +#if 0 /* if the driver has more than one buffer, ie. more than just the one we * just queued, then dequeue one immediately to make it available via * _buffer_alloc(): @@ -2727,9 +2729,15 @@ gst_v4l2_object_output_buffer (GstV4l2Object * v4l2object, GstBuffer * buf) gst_buffer_unref (v4l2buf); } } +#endif return GST_FLOW_OK; /* ERRORS */ +acquire_failed: + { + GST_DEBUG_OBJECT (v4l2object->element, "could not get buffer from pool"); + return ret; + } queue_failed: { GST_DEBUG_OBJECT (v4l2object->element, "failed to queue buffer"); diff --git a/sys/v4l2/gstv4l2object.h b/sys/v4l2/gstv4l2object.h index 0b72f0f..b24990d 100644 --- a/sys/v4l2/gstv4l2object.h +++ b/sys/v4l2/gstv4l2object.h @@ -119,7 +119,7 @@ struct _GstV4l2Object { guint32 min_queued_bufs; gboolean always_copy; gboolean use_mmap; - GstV4l2BufferPool *pool; + GstBufferPool *pool; /* the video device's capabilities */ struct v4l2_capability vcap; -- 2.7.4