diff mbox

[RFC,v3,media] mem2mem: add support for hardware buffered queue

Message ID 1369989199-20952-1-git-send-email-p.zabel@pengutronix.de (mailing list archive)
State New, archived
Headers show

Commit Message

Philipp Zabel May 31, 2013, 8:33 a.m. UTC
On mem2mem decoders with a hardware bitstream ringbuffer, to drain the
buffer at the end of the stream, remaining frames might need to be decoded
from the bitstream buffer without additional input buffers being provided.
To achieve this, allow a queue to be marked as buffered by the driver, and
allow scheduling of device_runs when buffered ready queues are empty.

This also allows a driver to copy input buffers into their bitstream
ringbuffer and immediately mark them as done to be dequeued.

The motivation for this patch is hardware assisted h.264 reordering support
in the coda driver. For high profile streams, the coda can hold back
out-of-order frames, causing a few mem2mem device runs in the beginning, that
don't produce any decompressed buffer at the v4l2 capture side. At the same
time, the last few frames can be decoded from the bitstream with mem2mem device
runs that don't need a new input buffer at the v4l2 output side. The decoder
command ioctl can be used to put the decoder into the ringbuffer draining
end-of-stream mode.

Signed-off-by: Philipp Zabel <p.zabel@pengutronix.de>
---
Changes since v2:
 - Fixed declaration of v4l2_m2m_queue_set_buffered in v4l2-mem2mem.h
---
 drivers/media/v4l2-core/v4l2-mem2mem.c | 18 ++++++++++++++++--
 include/media/v4l2-mem2mem.h           |  3 +++
 2 files changed, 19 insertions(+), 2 deletions(-)

Comments

Hi Philipp,

On 05/31/2013 10:33 AM, Philipp Zabel wrote:
> +void v4l2_m2m_queue_set_buffered(struct vb2_queue *vq, bool buffered)

How about making it a 'static inline' function in include/media/v4l2-mem2mem.h
instead ?

> +{
> +	struct v4l2_m2m_queue_ctx *q_ctx = container_of(vq, struct v4l2_m2m_queue_ctx, q);
> +
> +	q_ctx->buffered = buffered;
> +}
> +EXPORT_SYMBOL_GPL(v4l2_m2m_queue_set_buffered);


Also, I was wondering how do you handle now in the coda driver a situation
when, e.g. during normal stream decoding more than one buffer is produced
by the decoder from one compressed data buffer on its input side ?

Regards,
Sylwester
Philipp Zabel May 31, 2013, 9:29 a.m. UTC | #2
Hi Sylwester,

Am Freitag, den 31.05.2013, 10:52 +0200 schrieb Sylwester Nawrocki:
> Hi Philipp,
> 
> On 05/31/2013 10:33 AM, Philipp Zabel wrote:
> > +void v4l2_m2m_queue_set_buffered(struct vb2_queue *vq, bool buffered)
> 
> How about making it a 'static inline' function in include/media/v4l2-mem2mem.h
> instead ?

Thanks, I'll change this.

> > +{
> > +	struct v4l2_m2m_queue_ctx *q_ctx = container_of(vq, struct v4l2_m2m_queue_ctx, q);
> > +
> > +	q_ctx->buffered = buffered;
> > +}
> > +EXPORT_SYMBOL_GPL(v4l2_m2m_queue_set_buffered);
> 
> 
> Also, I was wondering how do you handle now in the coda driver a situation
> when, e.g. during normal stream decoding more than one buffer is produced
> by the decoder from one compressed data buffer on its input side ?

I didn't properly test it yet. In principle it should just work because
the compressed OUTPUT source buffer is always copied into the internal
bitstream ringbuffer, and then device_run can be scheduled multiple
times as long as there is enough bitstream data available, each run
producing a single CAPTURE destination buffer.

But I'm counting input buffers to send the EOS signal with the last
CAPTURE buffer DQBUF, assuming that there is one compressed frame per
OUTPUT source buffer.

regards
Philipp

--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
diff mbox

Patch

diff --git a/drivers/media/v4l2-core/v4l2-mem2mem.c b/drivers/media/v4l2-core/v4l2-mem2mem.c
index 66f599f..9377000 100644
--- a/drivers/media/v4l2-core/v4l2-mem2mem.c
+++ b/drivers/media/v4l2-core/v4l2-mem2mem.c
@@ -196,6 +196,10 @@  static void v4l2_m2m_try_run(struct v4l2_m2m_dev *m2m_dev)
  * 2) at least one destination buffer has to be queued,
  * 3) streaming has to be on.
  *
+ * If a queue is buffered (for example a decoder hardware ringbuffer that has
+ * to be drained before doing streamoff), allow scheduling without v4l2 buffers
+ * on that queue.
+ *
  * There may also be additional, custom requirements. In such case the driver
  * should supply a custom callback (job_ready in v4l2_m2m_ops) that should
  * return 1 if the instance is ready.
@@ -224,14 +228,16 @@  static void v4l2_m2m_try_schedule(struct v4l2_m2m_ctx *m2m_ctx)
 	}
 
 	spin_lock_irqsave(&m2m_ctx->out_q_ctx.rdy_spinlock, flags);
-	if (list_empty(&m2m_ctx->out_q_ctx.rdy_queue)) {
+	if (list_empty(&m2m_ctx->out_q_ctx.rdy_queue)
+	    && !m2m_ctx->out_q_ctx.buffered) {
 		spin_unlock_irqrestore(&m2m_ctx->out_q_ctx.rdy_spinlock, flags);
 		spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags_job);
 		dprintk("No input buffers available\n");
 		return;
 	}
 	spin_lock_irqsave(&m2m_ctx->cap_q_ctx.rdy_spinlock, flags);
-	if (list_empty(&m2m_ctx->cap_q_ctx.rdy_queue)) {
+	if (list_empty(&m2m_ctx->cap_q_ctx.rdy_queue)
+	    && !m2m_ctx->cap_q_ctx.buffered) {
 		spin_unlock_irqrestore(&m2m_ctx->cap_q_ctx.rdy_spinlock, flags);
 		spin_unlock_irqrestore(&m2m_ctx->out_q_ctx.rdy_spinlock, flags);
 		spin_unlock_irqrestore(&m2m_dev->job_spinlock, flags_job);
@@ -626,6 +632,14 @@  err:
 }
 EXPORT_SYMBOL_GPL(v4l2_m2m_ctx_init);
 
+void v4l2_m2m_queue_set_buffered(struct vb2_queue *vq, bool buffered)
+{
+	struct v4l2_m2m_queue_ctx *q_ctx = container_of(vq, struct v4l2_m2m_queue_ctx, q);
+
+	q_ctx->buffered = buffered;
+}
+EXPORT_SYMBOL_GPL(v4l2_m2m_queue_set_buffered);
+
 /**
  * v4l2_m2m_ctx_release() - release m2m context
  *
diff --git a/include/media/v4l2-mem2mem.h b/include/media/v4l2-mem2mem.h
index d3eef01..40aaadc 100644
--- a/include/media/v4l2-mem2mem.h
+++ b/include/media/v4l2-mem2mem.h
@@ -60,6 +60,7 @@  struct v4l2_m2m_queue_ctx {
 	struct list_head	rdy_queue;
 	spinlock_t		rdy_spinlock;
 	u8			num_rdy;
+	bool			buffered;
 };
 
 struct v4l2_m2m_ctx {
@@ -132,6 +133,8 @@  struct v4l2_m2m_ctx *v4l2_m2m_ctx_init(struct v4l2_m2m_dev *m2m_dev,
 		void *drv_priv,
 		int (*queue_init)(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq));
 
+void v4l2_m2m_queue_set_buffered(struct vb2_queue *vq, bool buffered);
+
 void v4l2_m2m_ctx_release(struct v4l2_m2m_ctx *m2m_ctx);
 
 void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx, struct vb2_buffer *vb);