UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

media: mtk-vcodec: venc: support START and STOP commands 

The V4L2 encoder specification requires encoders to support the
V4L2_ENC_CMD_START and V4L2_ENC_CMD_STOP commands. Add support for these
to the mtk-vcodec encoder by reusing the same flush buffer as used by
the decoder driver.

[hsinyi: fix double-free issue if flush buffer was not dequeued by the
time streamoff is called]

Signed-off-by: Alexandre Courbot <acourbot@chromium.org>
Signed-off-by: Hsin-Yi Wang <hsinyi@chromium.org>
Signed-off-by: Tzung-Bi Shih <tzungbi@google.com>
Signed-off-by: Hans Verkuil <hverkuil-cisco@xs4all.nl>
Signed-off-by: Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
This commit is contained in:
Alexandre Courbot 2021-08-06 06:15:21 +02:00 committed by Mauro Carvalho Chehab
parent 69466c22f5
commit b375e01b79
3 changed files with 140 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/media/platform/mtk-vcodec/mtk_vcodec_drv.h
View File

@ -252,6 +252,7 @@ struct vdec_pic_info {
* @last_decoded_picinfo: pic information get from latest decode
* @empty_flush_buf: a fake size-0 capture buffer that indicates flush. Only
* to be used with encoder and stateful decoder.
* @is_flushing: set to true if flushing is in progress.
*
* @colorspace: enum v4l2_colorspace; supplemental to pixelformat
* @ycbcr_enc: enum v4l2_ycbcr_encoding, Y'CbCr encoding
@ -291,6 +292,7 @@ struct mtk_vcodec_ctx {
struct work_struct encode_work;
struct vdec_pic_info last_decoded_picinfo;
struct v4l2_m2m_buffer empty_flush_buf;
bool is_flushing;
enum v4l2_colorspace colorspace;
enum v4l2_ycbcr_encoding ycbcr_enc;

140
drivers/media/platform/mtk-vcodec/mtk_vcodec_enc.c
View File

@ -672,6 +672,7 @@ static int vidioc_venc_dqbuf(struct file *file, void *priv,
struct v4l2_buffer *buf)
{
struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv);
int ret;
if (ctx->state == MTK_STATE_ABORT) {
mtk_v4l2_err("[%d] Call on QBUF after unrecoverable error",
@ -679,7 +680,83 @@ static int vidioc_venc_dqbuf(struct file *file, void *priv,
return -EIO;
}
return v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf);
ret = v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf);
if (ret)
return ret;
/*
* Complete flush if the user dequeued the 0-payload LAST buffer.
* We check the payload because a buffer with the LAST flag can also
* be seen during resolution changes. If we happen to be flushing at
* that time, the last buffer before the resolution changes could be
* misinterpreted for the buffer generated by the flush and terminate
* it earlier than we want.
*/
if (!V4L2_TYPE_IS_OUTPUT(buf->type) &&
buf->flags & V4L2_BUF_FLAG_LAST &&
buf->m.planes[0].bytesused == 0 &&
ctx->is_flushing) {
/*
* Last CAPTURE buffer is dequeued, we can allow another flush
* to take place.
*/
ctx->is_flushing = false;
}
return 0;
}
static int vidioc_encoder_cmd(struct file *file, void *priv,
struct v4l2_encoder_cmd *cmd)
{
struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv);
struct vb2_queue *src_vq, *dst_vq;
int ret;
if (ctx->state == MTK_STATE_ABORT) {
mtk_v4l2_err("[%d] Call to CMD after unrecoverable error",
ctx->id);
return -EIO;
}
ret = v4l2_m2m_ioctl_try_encoder_cmd(file, priv, cmd);
if (ret)
return ret;
/* Calling START or STOP is invalid if a flush is in progress */
if (ctx->is_flushing)
return -EBUSY;
mtk_v4l2_debug(1, "encoder cmd=%u", cmd->cmd);
dst_vq = v4l2_m2m_get_vq(ctx->m2m_ctx,
V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
switch (cmd->cmd) {
case V4L2_ENC_CMD_STOP:
src_vq = v4l2_m2m_get_vq(ctx->m2m_ctx,
V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
if (!vb2_is_streaming(src_vq)) {
mtk_v4l2_debug(1, "Output stream is off. No need to flush.");
return 0;
}
if (!vb2_is_streaming(dst_vq)) {
mtk_v4l2_debug(1, "Capture stream is off. No need to flush.");
return 0;
}
ctx->is_flushing = true;
v4l2_m2m_buf_queue(ctx->m2m_ctx, &ctx->empty_flush_buf.vb);
v4l2_m2m_try_schedule(ctx->m2m_ctx);
break;
case V4L2_ENC_CMD_START:
vb2_clear_last_buffer_dequeued(dst_vq);
break;
default:
return -EINVAL;
}
return 0;
}
const struct v4l2_ioctl_ops mtk_venc_ioctl_ops = {
@ -715,6 +792,9 @@ const struct v4l2_ioctl_ops mtk_venc_ioctl_ops = {
.vidioc_g_selection = vidioc_venc_g_selection,
.vidioc_s_selection = vidioc_venc_s_selection,
.vidioc_encoder_cmd = vidioc_encoder_cmd,
.vidioc_try_encoder_cmd = v4l2_m2m_ioctl_try_encoder_cmd,
};
static int vb2ops_venc_queue_setup(struct vb2_queue *vq,
@ -882,9 +962,38 @@ static void vb2ops_venc_stop_streaming(struct vb2_queue *q)
dst_buf->vb2_buf.planes[0].bytesused = 0;
v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR);
}
/* STREAMOFF on the CAPTURE queue completes any ongoing flush */
if (ctx->is_flushing) {
struct v4l2_m2m_buffer *b, *n;
mtk_v4l2_debug(1, "STREAMOFF called while flushing");
/*
* STREAMOFF could be called before the flush buffer is
* dequeued. Check whether empty flush buf is still in
* queue before removing it.
*/
v4l2_m2m_for_each_src_buf_safe(ctx->m2m_ctx, b, n) {
if (b == &ctx->empty_flush_buf) {
v4l2_m2m_src_buf_remove_by_buf(ctx->m2m_ctx, &b->vb);
break;
}
}
ctx->is_flushing = false;
}
} else {
while ((src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx)))
v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR);
while ((src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx))) {
if (src_buf != &ctx->empty_flush_buf.vb)
v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR);
}
if (ctx->is_flushing) {
/*
* If we are in the middle of a flush, put the flush
* buffer back into the queue so the next CAPTURE
* buffer gets returned with the LAST flag set.
*/
v4l2_m2m_buf_queue(ctx->m2m_ctx,
&ctx->empty_flush_buf.vb);
}
}
if ((q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
@ -984,12 +1093,15 @@ static int mtk_venc_param_change(struct mtk_vcodec_ctx *ctx)
{
struct venc_enc_param enc_prm;
struct vb2_v4l2_buffer *vb2_v4l2 = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
struct mtk_video_enc_buf *mtk_buf =
container_of(vb2_v4l2, struct mtk_video_enc_buf,
m2m_buf.vb);
struct mtk_video_enc_buf *mtk_buf;
int ret = 0;
/* Don't upcast the empty flush buffer */
if (vb2_v4l2 == &ctx->empty_flush_buf.vb)
return 0;
mtk_buf = container_of(vb2_v4l2, struct mtk_video_enc_buf, m2m_buf.vb);
memset(&enc_prm, 0, sizeof(enc_prm));
if (mtk_buf->param_change == MTK_ENCODE_PARAM_NONE)
return 0;
@ -1075,6 +1187,20 @@ static void mtk_venc_worker(struct work_struct *work)
}
src_buf = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
/*
* If we see the flush buffer, send an empty buffer with the LAST flag
* to the client. is_flushing will be reset at the time the buffer
* is dequeued.
*/
if (src_buf == &ctx->empty_flush_buf.vb) {
vb2_set_plane_payload(&dst_buf->vb2_buf, 0, 0);
dst_buf->flags |= V4L2_BUF_FLAG_LAST;
v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_DONE);
v4l2_m2m_job_finish(ctx->dev->m2m_dev_enc, ctx->m2m_ctx);
return;
}
memset(&frm_buf, 0, sizeof(frm_buf));
for (i = 0; i < src_buf->vb2_buf.num_planes ; i++) {
frm_buf.fb_addr[i].dma_addr =

6
drivers/media/platform/mtk-vcodec/mtk_vcodec_enc_drv.c
View File

@ -123,6 +123,7 @@ static int fops_vcodec_open(struct file *file)
struct mtk_vcodec_dev *dev = video_drvdata(file);
struct mtk_vcodec_ctx *ctx = NULL;
int ret = 0;
struct vb2_queue *src_vq;
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
if (!ctx)
@ -149,13 +150,16 @@ static int fops_vcodec_open(struct file *file)
goto err_ctrls_setup;
}
ctx->m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev_enc, ctx,
&mtk_vcodec_enc_queue_init);
&mtk_vcodec_enc_queue_init);
if (IS_ERR((__force void *)ctx->m2m_ctx)) {
ret = PTR_ERR((__force void *)ctx->m2m_ctx);
mtk_v4l2_err("Failed to v4l2_m2m_ctx_init() (%d)",
ret);
goto err_m2m_ctx_init;
}
src_vq = v4l2_m2m_get_vq(ctx->m2m_ctx,
V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
ctx->empty_flush_buf.vb.vb2_buf.vb2_queue = src_vq;
mtk_vcodec_enc_set_default_params(ctx);
if (v4l2_fh_is_singular(&ctx->fh)) {