/** * gst_buffer_pool_acquire_buffer: * @pool: a #GstBufferPool * @buffer: (out): a location for a #GstBuffer * @params: (transfer none) (allow-none) parameters. * * Acquire a buffer from @pool. @buffer should point to a memory location that * can hold a pointer to the new buffer. * * @params can be NULL or contain optional parameters to influence the allocation. * * Returns: a #GstFlowReturn such as GST_FLOW_FLUSHING when the pool is * inactive. */ GstFlowReturn gst_buffer_pool_acquire_buffer (GstBufferPool * pool, GstBuffer ** buffer, GstBufferPoolAcquireParams * params) { GstBufferPoolClass *pclass; GstFlowReturn result; g_return_val_if_fail (GST_IS_BUFFER_POOL (pool), GST_FLOW_ERROR); g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR); pclass = GST_BUFFER_POOL_GET_CLASS (pool); /* assume we'll have one more outstanding buffer we need to do that so * that concurrent set_active doesn't clear the buffers */ g_atomic_int_inc (&pool->priv->outstanding); if (G_LIKELY (pclass->acquire_buffer)) result = pclass->acquire_buffer (pool, buffer, params); else result = GST_FLOW_NOT_SUPPORTED; if (G_LIKELY (result == GST_FLOW_OK)) { /* all buffers from the pool point to the pool and have the refcount of the * pool incremented */ (*buffer)->pool = gst_object_ref (pool); } else { dec_outstanding (pool); } return result; }
static GstFlowReturn gst_v4l2_buffer_pool_acquire_buffer (GstBufferPool * bpool, GstBuffer ** buffer, GstBufferPoolAcquireParams * params) { GstFlowReturn ret; GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); GstBufferPoolClass *pclass = GST_BUFFER_POOL_CLASS (parent_class); GstV4l2Object *obj = pool->obj; GST_DEBUG_OBJECT (pool, "acquire"); /* If this is being called to resurect a lost buffer */ if (params && params->flags & GST_V4L2_BUFFER_POOL_ACQUIRE_FLAG_RESURRECT) { ret = pclass->acquire_buffer (bpool, buffer, params); goto done; } switch (obj->type) { case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: /* capture, This function should return a buffer with new captured data */ switch (obj->mode) { case GST_V4L2_IO_RW: { /* take empty buffer from the pool */ ret = pclass->acquire_buffer (bpool, buffer, params); break; } case GST_V4L2_IO_DMABUF: case GST_V4L2_IO_MMAP: { /* 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); if (G_UNLIKELY (ret != GST_FLOW_OK)) goto done; break; } case GST_V4L2_IO_USERPTR: case GST_V4L2_IO_DMABUF_IMPORT: { /* dequeue filled buffer */ ret = gst_v4l2_buffer_pool_dqbuf (pool, buffer); break; } default: ret = GST_FLOW_ERROR; g_assert_not_reached (); break; } break; case V4L2_BUF_TYPE_VIDEO_OUTPUT: case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: /* playback, This function should return an empty buffer */ switch (obj->mode) { case GST_V4L2_IO_RW: /* get an empty buffer */ ret = pclass->acquire_buffer (bpool, buffer, params); break; case GST_V4L2_IO_MMAP: case GST_V4L2_IO_DMABUF: case GST_V4L2_IO_USERPTR: case GST_V4L2_IO_DMABUF_IMPORT: /* get a free unqueued buffer */ ret = pclass->acquire_buffer (bpool, buffer, params); break; default: ret = GST_FLOW_ERROR; g_assert_not_reached (); break; } break; default: ret = GST_FLOW_ERROR; g_assert_not_reached (); break; } done: return ret; }