自学教程：C++ v4l2_m2m_get_vq函数代码示例

static int vidioc_venc_g_fmt(struct file *file, void *priv,			     struct v4l2_format *f){	struct v4l2_pix_format_mplane *pix = &f->fmt.pix_mp;	struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv);	struct vb2_queue *vq;	struct mtk_q_data *q_data;	int i;	vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);	if (!vq)		return -EINVAL;	q_data = mtk_venc_get_q_data(ctx, f->type);	pix->width = q_data->coded_width;	pix->height = q_data->coded_height;	pix->pixelformat = q_data->fmt->fourcc;	pix->field = q_data->field;	pix->num_planes = q_data->fmt->num_planes;	for (i = 0; i < pix->num_planes; i++) {		pix->plane_fmt[i].bytesperline = q_data->bytesperline[i];		pix->plane_fmt[i].sizeimage = q_data->sizeimage[i];		memset(&(pix->plane_fmt[i].reserved[0]), 0x0,		       sizeof(pix->plane_fmt[i].reserved));	}	pix->flags = 0;	pix->colorspace = ctx->colorspace;	pix->ycbcr_enc = ctx->ycbcr_enc;	pix->quantization = ctx->quantization;	pix->xfer_func = ctx->xfer_func;	return 0;}

static int s5p_jpeg_g_fmt(struct file *file, void *priv, struct v4l2_format *f){	struct vb2_queue *vq;	struct s5p_jpeg_q_data *q_data = NULL;	struct v4l2_pix_format *pix = &f->fmt.pix;	struct s5p_jpeg_ctx *ct = fh_to_ctx(priv);	vq = v4l2_m2m_get_vq(ct->m2m_ctx, f->type);	if (!vq)		return -EINVAL;	if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&	    ct->mode == S5P_JPEG_DECODE && !ct->hdr_parsed)		return -EINVAL;	q_data = get_q_data(ct, f->type);	BUG_ON(q_data == NULL);	pix->width = q_data->w;	pix->height = q_data->h;	pix->field = V4L2_FIELD_NONE;	pix->pixelformat = q_data->fmt->fourcc;	pix->bytesperline = 0;	if (q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG) {		u32 bpl = q_data->w;		if (q_data->fmt->colplanes == 1)			bpl = (bpl * q_data->fmt->depth) >> 3;		pix->bytesperline = bpl;	}

static int hva_s_fmt_stream(struct file *file, void *fh, struct v4l2_format *f){	struct hva_ctx *ctx = fh_to_ctx(file->private_data);	struct device *dev = ctx_to_dev(ctx);	struct vb2_queue *vq;	int ret;	ret = hva_try_fmt_stream(file, fh, f);	if (ret) {		dev_dbg(dev, "%s V4L2 S_FMT (CAPTURE): unsupported format %.4s/n",			ctx->name, (char *)&f->fmt.pix.pixelformat);		return ret;	}	vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);	if (vb2_is_streaming(vq)) {		dev_dbg(dev, "%s V4L2 S_FMT (CAPTURE): queue busy/n",			ctx->name);		return -EBUSY;	}	ctx->max_stream_size = f->fmt.pix.sizeimage;	ctx->streaminfo.width = f->fmt.pix.width;	ctx->streaminfo.height = f->fmt.pix.height;	ctx->streaminfo.streamformat = f->fmt.pix.pixelformat;	ctx->flags |= HVA_FLAG_STREAMINFO;	return 0;}

static int hva_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf){	struct hva_ctx *ctx = fh_to_ctx(file->private_data);	struct device *dev = ctx_to_dev(ctx);	if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {		/*		 * depending on the targeted compressed video format, the		 * capture buffer might contain headers (e.g. H.264 SPS/PPS)		 * filled in by the driver client; the size of these data is		 * copied from the bytesused field of the V4L2 buffer in the		 * payload field of the hva stream buffer		 */		struct vb2_queue *vq;		struct hva_stream *stream;		vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, buf->type);		if (buf->index >= vq->num_buffers) {			dev_dbg(dev, "%s buffer index %d out of range (%d)/n",				ctx->name, buf->index, vq->num_buffers);			return -EINVAL;		}		stream = (struct hva_stream *)vq->bufs[buf->index];		stream->bytesused = buf->bytesused;	}	return v4l2_m2m_qbuf(file, ctx->fh.m2m_ctx, buf);}

static int nxp_video_streamon(struct file *file, void *fh,        enum v4l2_buf_type i){    int ret;    u32 pad;    struct nxp_video *me = file->private_data;    struct v4l2_subdev *subdev = _get_remote_subdev(me, i, &pad);    void *hostdata_back;     vmsg("%s: me %p, %s/n", __func__, me, me->name);    if (me->vbq) {        ret = vb2_streamon(me->vbq, i);        if (ret < 0) {            pr_err("%s: failed to vb2_streamon()/n", __func__);            return ret;        }    } else {        struct vb2_queue *vq = v4l2_m2m_get_vq(me->m2m_ctx, i);        ret = vb2_streamon(vq, i);        if (ret < 0) {            pr_err("%s: m2m, failed to vb2_streamon()/n", __func__);            return ret;        }    }    /* for mlc subdev */    hostdata_back = v4l2_get_subdev_hostdata(subdev);    v4l2_set_subdev_hostdata(subdev, me->name);    ret = v4l2_subdev_call(subdev, video, s_stream, 1);    v4l2_set_subdev_hostdata(subdev, hostdata_back);    return ret;}

/** * v4l2_m2m_reqbufs() - multi-queue-aware REQBUFS multiplexer */int v4l2_m2m_reqbufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,		     struct v4l2_requestbuffers *reqbufs){	struct vb2_queue *vq;	vq = v4l2_m2m_get_vq(m2m_ctx, reqbufs->type);	return vb2_reqbufs(vq, reqbufs);}

/** * v4l2_m2m_dqbuf() - dequeue a source or destination buffer, depending on * the type */int v4l2_m2m_dqbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,		   struct v4l2_buffer *buf){	struct vb2_queue *vq;	vq = v4l2_m2m_get_vq(m2m_ctx, buf->type);	return vb2_dqbuf(vq, buf, file->f_flags & O_NONBLOCK);}

/** * v4l2_m2m_expbuf() - export a source or destination buffer, depending on * the type */int v4l2_m2m_expbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,		  struct v4l2_exportbuffer *eb){	struct vb2_queue *vq;	vq = v4l2_m2m_get_vq(m2m_ctx, eb->type);	return vb2_expbuf(vq, eb);}

/** * v4l2_m2m_create_bufs() - create a source or destination buffer, depending * on the type */int v4l2_m2m_create_bufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,			 struct v4l2_create_buffers *create){	struct vb2_queue *vq;	vq = v4l2_m2m_get_vq(m2m_ctx, create->format.type);	return vb2_create_bufs(vq, create);}

/** * v4l2_m2m_streamoff() - turn off streaming for a video queue */int v4l2_m2m_streamoff(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,		       enum v4l2_buf_type type){	struct vb2_queue *vq;	vq = v4l2_m2m_get_vq(m2m_ctx, type);	return vb2_streamoff(vq, type);}

static int jpeg_enc_vidioc_s_fmt_out(struct file *file, void *priv,			struct v4l2_format *f){	struct jpeg_ctx *ctx = priv;	struct vb2_queue *vq;	struct v4l2_pix_format_mplane *pix;	struct jpeg_fmt *fmt;	struct jpeg_frame *frame;	int ret;	int i;	ret = jpeg_enc_vidioc_try_fmt(file, priv, f);	if (ret)		return ret;	vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);	if (!vq)		return -EINVAL;	if (vb2_is_busy(vq)) {		v4l2_err(&ctx->jpeg_dev->v4l2_dev, "queue (%d) busy/n", f->type);		return -EBUSY;	}	/* TODO: width & height has to be multiple of two */	pix = &f->fmt.pix_mp;	fmt = find_format(f);	frame = ctx_get_frame(ctx, f->type);	if (IS_ERR(frame))		return PTR_ERR(frame);	frame->jpeg_fmt = fmt;	if (!frame->jpeg_fmt) {		v4l2_err(&ctx->jpeg_dev->v4l2_dev,				"not supported format values/n");		return -EINVAL;	}	for (i = 0; i < fmt->memplanes; i++) {		ctx->payload[i] =			pix->plane_fmt[i].bytesperline * pix->height;		ctx->param.enc_param.in_depth[i] = fmt->depth[i];	}	frame->width = pix->width;	frame->height = pix->height;	frame->pixelformat = pix->pixelformat;	ctx->param.enc_param.in_width = pix->width;	ctx->param.enc_param.in_height = pix->height;	ctx->param.enc_param.in_plane = fmt->memplanes;	ctx->param.enc_param.in_fmt = fmt->color;	return 0;}

static int jpeg_dec_m2m_reqbufs(struct file *file, void *priv,			  struct v4l2_requestbuffers *reqbufs){	struct jpeg_ctx *ctx = priv;	struct vb2_queue *vq;	vq = v4l2_m2m_get_vq(ctx->m2m_ctx, reqbufs->type);	return v4l2_m2m_reqbufs(file, ctx->m2m_ctx, reqbufs);}

static int nxp_video_querybuf(struct file *file, void *fh,        struct v4l2_buffer *b){    struct nxp_video *me = file->private_data;    if (me->vbq) {        return vb2_querybuf(me->vbq, b);    } else {        struct vb2_queue *vq = v4l2_m2m_get_vq(me->m2m_ctx, b->type);        return vb2_querybuf(vq, b);    }}

static int fimc_m2m_s_fmt_mplane(struct file *file, void *fh,				 struct v4l2_format *f){	struct fimc_ctx *ctx = fh_to_ctx(fh);	struct fimc_dev *fimc = ctx->fimc_dev;	struct vb2_queue *vq;	struct fimc_frame *frame;	struct v4l2_pix_format_mplane *pix;	int i, ret = 0;	ret = fimc_try_fmt_mplane(ctx, f);	if (ret)		return ret;	vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);	if (vb2_is_busy(vq)) {		v4l2_err(fimc->m2m.vfd, "queue (%d) busy/n", f->type);		return -EBUSY;	}	if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)		frame = &ctx->s_frame;	else		frame = &ctx->d_frame;	pix = &f->fmt.pix_mp;	frame->fmt = fimc_find_format(&pix->pixelformat, NULL,				      get_m2m_fmt_flags(f->type), 0);	if (!frame->fmt)		return -EINVAL;	/* Update RGB Alpha control state and value range */	fimc_alpha_ctrl_update(ctx);	for (i = 0; i < frame->fmt->colplanes; i++) {		frame->payload[i] =			(pix->width * pix->height * frame->fmt->depth[i]) / 8;	}	fimc_fill_frame(frame, f);	ctx->scaler.enabled = 1;	if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)		fimc_ctx_state_set(FIMC_PARAMS | FIMC_DST_FMT, ctx);	else		fimc_ctx_state_set(FIMC_PARAMS | FIMC_SRC_FMT, ctx);	dbg("f_w: %d, f_h: %d", frame->f_width, frame->f_height);	return 0;}

static int nxp_video_dqbuf(struct file *file, void *fh,        struct v4l2_buffer *b){    struct nxp_video *me = file->private_data;    pr_debug("%s/n", __func__);    if (me->vbq) {        return vb2_dqbuf(me->vbq, b, file->f_flags & O_NONBLOCK);    } else {        struct vb2_queue *vq = v4l2_m2m_get_vq(me->m2m_ctx, b->type);        return vb2_dqbuf(vq, b, file->f_flags & O_NONBLOCK);    }}

static int nxp_video_qbuf(struct file *file, void *fh,        struct v4l2_buffer *b){    struct nxp_video *me = file->private_data;    pr_debug("%s: %s, index %d/n", __func__, me->name, b->index);    if (me->vbq) {        return vb2_qbuf(me->vbq, b);    } else {        struct vb2_queue *vq = v4l2_m2m_get_vq(me->m2m_ctx, b->type);        return vb2_qbuf(vq, b);    }}

static int nxp_video_reqbufs(struct file *file, void *fh,        struct v4l2_requestbuffers *b){    struct nxp_video *me = file->private_data;    pr_debug("%s: %s/n", __func__, me->name);    if (me->vbq) { /* capture, out */        return vb2_reqbufs(me->vbq, b); /* call to queue_setup */    } else { /* m2m */        struct vb2_queue *vq = v4l2_m2m_get_vq(me->m2m_ctx, b->type);        return vb2_reqbufs(vq, b);    }}

static int vidioc_decoder_cmd(struct file *file, void *priv,				struct v4l2_decoder_cmd *cmd){	struct mtk_vcodec_ctx *ctx = fh_to_ctx(priv);	struct vb2_queue *src_vq, *dst_vq;	int ret;	ret = vidioc_try_decoder_cmd(file, priv, cmd);	if (ret)		return ret;	mtk_v4l2_debug(1, "decoder cmd=%u", cmd->cmd);	dst_vq = v4l2_m2m_get_vq(ctx->m2m_ctx,				V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);	switch (cmd->cmd) {	case V4L2_DEC_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;		}		v4l2_m2m_buf_queue(ctx->m2m_ctx, &ctx->empty_flush_buf->vb);		v4l2_m2m_try_schedule(ctx->m2m_ctx);		break;	case V4L2_DEC_CMD_START:		vb2_clear_last_buffer_dequeued(dst_vq);		break;	default:		return -EINVAL;	}	return 0;}

/** * v4l2_m2m_streamon() - turn on streaming for a video queue */int v4l2_m2m_streamon(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,		      enum v4l2_buf_type type){	struct vb2_queue *vq;	int ret;	vq = v4l2_m2m_get_vq(m2m_ctx, type);	ret = vb2_streamon(vq, type);	if (!ret)		v4l2_m2m_try_schedule(m2m_ctx);	return ret;}

/** * v4l2_m2m_qbuf() - enqueue a source or destination buffer, depending on * the type */int v4l2_m2m_qbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,		  struct v4l2_buffer *buf){	struct vb2_queue *vq;	int ret;	vq = v4l2_m2m_get_vq(m2m_ctx, buf->type);	ret = vb2_qbuf(vq, buf);	if (!ret)		v4l2_m2m_try_schedule(m2m_ctx);	return ret;}

static int rot_v4l2_s_fmt_mplane(struct file *file, void *priv,				 struct v4l2_format *f){	struct rot_ctx *ctx = priv;	struct vb2_queue *vq;	struct rot_frame *frame;	struct v4l2_pix_format_mplane *pixm = &f->fmt.pix_mp;	int i, ret = 0;	vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);	if (vb2_is_streaming(vq)) {		rot_err("device is busy/n");		return -EBUSY;	}	ret = rot_v4l2_try_fmt_mplane(file, priv, f);	if (ret < 0)		return ret;	frame = ctx_get_frame(ctx, f->type);	if (IS_ERR(frame))		return PTR_ERR(frame);	set_bit(CTX_PARAMS, &ctx->flags);	frame->rot_fmt = rot_find_format(f);	if (!frame->rot_fmt) {		rot_err("not supported format values/n");		return -EINVAL;	}	rot_adjust_pixminfo(ctx, frame, pixm);	frame->pix_mp.pixelformat = pixm->pixelformat;	frame->pix_mp.width	= pixm->width;	frame->pix_mp.height	= pixm->height;	/*	 * Shouldn't call s_crop or g_crop before called g_fmt or s_fmt.	 * Let's assume that we can keep the order.	 */	frame->crop.width	= pixm->width;	frame->crop.height	= pixm->height;	for (i = 0; i < frame->rot_fmt->num_planes; ++i)		frame->bytesused[i] = (pixm->width * pixm->height *				frame->rot_fmt->bitperpixel[i]) >> 3;	return 0;}

static int bdisp_s_fmt(struct file *file, void *fh, struct v4l2_format *f){	struct bdisp_ctx *ctx = fh_to_ctx(fh);	struct vb2_queue *vq;	struct bdisp_frame *frame;	struct v4l2_pix_format *pix;	int ret;	u32 state;	ret = bdisp_try_fmt(file, fh, f);	if (ret) {		dev_err(ctx->bdisp_dev->dev, "Cannot set format/n");		return ret;	}	vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);	if (vb2_is_streaming(vq)) {		dev_err(ctx->bdisp_dev->dev, "queue (%d) busy/n", f->type);		return -EBUSY;	}	frame = (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) ?			&ctx->src : &ctx->dst;	pix = &f->fmt.pix;	frame->fmt = bdisp_find_fmt(pix->pixelformat);	if (!frame->fmt) {		dev_err(ctx->bdisp_dev->dev, "Unknown format 0x%x/n",			pix->pixelformat);		return -EINVAL;	}	frame->width = pix->width;	frame->height = pix->height;	frame->bytesperline = pix->bytesperline;	frame->sizeimage = pix->sizeimage;	frame->field = pix->field;	if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)		frame->colorspace = pix->colorspace;	frame->crop.width = frame->width;	frame->crop.height = frame->height;	frame->crop.left = 0;	frame->crop.top = 0;	state = BDISP_PARAMS;	state |= (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) ?			BDISP_DST_FMT : BDISP_SRC_FMT;	bdisp_ctx_state_lock_set(state, ctx);	return 0;}

static int jpeg_dec_m2m_reqbufs(struct file *file, void *priv,			  struct v4l2_requestbuffers *reqbufs){	struct jpeg_ctx *ctx = priv;	struct vb2_queue *vq;	vq = v4l2_m2m_get_vq(ctx->m2m_ctx, reqbufs->type);	if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)		ctx->dev->vb2->set_cacheable(ctx->dev->alloc_ctx, ctx->input_cacheable);	else if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)		ctx->dev->vb2->set_cacheable(ctx->dev->alloc_ctx, ctx->output_cacheable);	return v4l2_m2m_reqbufs(file, ctx->m2m_ctx, reqbufs);}

int v4l2_m2m_reqbufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,                     struct v4l2_requestbuffers *reqbufs){    struct vb2_queue *vq;    int ret;    vq = v4l2_m2m_get_vq(m2m_ctx, reqbufs->type);    ret = vb2_reqbufs(vq, reqbufs);    /* If count == 0, then the owner has released all buffers and he       is no longer owner of the queue. Otherwise we have an owner. */    if (ret == 0)        vq->owner = reqbufs->count ? file->private_data : NULL;    return ret;}

static int gsc_m2m_s_fmt_mplane(struct file *file, void *fh,				 struct v4l2_format *f){	struct gsc_ctx *ctx = fh_to_ctx(fh);	struct vb2_queue *vq;	struct gsc_frame *frame;	struct v4l2_pix_format_mplane *pix;	int i, ret = 0;	ret = gsc_m2m_try_fmt_mplane(file, fh, f);	if (ret)		return ret;	vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);	if (vb2_is_streaming(vq)) {		pr_err("queue (%d) busy", f->type);		return -EBUSY;	}	if (V4L2_TYPE_IS_OUTPUT(f->type))		frame = &ctx->s_frame;	else		frame = &ctx->d_frame;	pix = &f->fmt.pix_mp;	frame->fmt = find_fmt(&pix->pixelformat, NULL, 0);	frame->colorspace = pix->colorspace;	if (!frame->fmt)		return -EINVAL;	for (i = 0; i < frame->fmt->num_planes; i++)		frame->payload[i] = pix->plane_fmt[i].sizeimage;	gsc_set_frame_size(frame, pix->width, pix->height);	if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)		gsc_ctx_state_lock_set(GSC_PARAMS | GSC_DST_FMT, ctx);	else		gsc_ctx_state_lock_set(GSC_PARAMS | GSC_SRC_FMT, ctx);	pr_debug("f_w: %d, f_h: %d", frame->f_width, frame->f_height);	return 0;}

static int jpeg_dec_vidioc_s_fmt_out(struct file *file, void *priv,			struct v4l2_format *f){	struct jpeg_ctx *ctx = priv;	struct vb2_queue *vq;	struct v4l2_pix_format_mplane *pix;	struct jpeg_fmt *fmt;	int ret;	int i;	ret = jpeg_dec_vidioc_try_fmt(file, priv, f);	if (ret)		return ret;	vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);	if (!vq)		return -EINVAL;	if (vb2_is_busy(vq)) {		v4l2_err(&ctx->dev->v4l2_dev, "queue (%d) busy/n", f->type);		return -EBUSY;	}	/* TODO: width & height has to be multiple of two */	pix = &f->fmt.pix_mp;	fmt = find_format(f);	for (i = 0; i < fmt->memplanes; i++)		ctx->payload[i] =			pix->plane_fmt[i].bytesperline * pix->height;	ctx->param.dec_param.in_width = pix->width;	ctx->param.dec_param.in_height = pix->height;	ctx->param.dec_param.in_plane = fmt->memplanes;	ctx->param.dec_param.in_depth = fmt->depth[0];	ctx->param.dec_param.in_fmt = fmt->color;	if((pix->plane_fmt[0].sizeimage % 32) == 0)		ctx->param.dec_param.size = (pix->plane_fmt[0].sizeimage / 32);	else		ctx->param.dec_param.size = (pix->plane_fmt[0].sizeimage / 32) + 1;	ctx->param.dec_param.mem_size = pix->plane_fmt[0].sizeimage;	return 0;}

static int vidioc_g_fmt(struct file *file, void *prv, struct v4l2_format *f){	struct g2d_ctx *ctx = prv;	struct vb2_queue *vq;	struct g2d_frame *frm;	vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);	if (!vq)		return -EINVAL;	frm = get_frame(ctx, f->type);	if (IS_ERR(frm))		return PTR_ERR(frm);	f->fmt.pix.width		= frm->width;	f->fmt.pix.height		= frm->height;	f->fmt.pix.field		= V4L2_FIELD_NONE;	f->fmt.pix.pixelformat		= frm->fmt->fourcc;	f->fmt.pix.bytesperline		= (frm->width * frm->fmt->depth) >> 3;	f->fmt.pix.sizeimage		= frm->size;	return 0;}

static int jpeg_enc_vidioc_s_fmt_cap(struct file *file, void *priv,				struct v4l2_format *f){	struct jpeg_ctx *ctx = priv;	struct vb2_queue *vq;	struct v4l2_pix_format_mplane *pix;	struct jpeg_fmt *fmt;	int ret;	int i;	ret = jpeg_enc_vidioc_try_fmt(file, priv, f);	if (ret)		return ret;	vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);	if (!vq)		return -EINVAL;	if (vb2_is_busy(vq)) {		v4l2_err(&ctx->dev->v4l2_dev, "queue (%d) busy/n", f->type);		return -EBUSY;	}	pix = &f->fmt.pix_mp;	fmt = find_format(f);	if (!fmt)		return -EINVAL;	for (i = 0; i < fmt->memplanes; i++)		ctx->payload[i] =			pix->plane_fmt[i].bytesperline * pix->height;	ctx->param.enc_param.out_width = pix->height;	ctx->param.enc_param.out_height = pix->width;	ctx->param.enc_param.out_plane = fmt->memplanes;	ctx->param.enc_param.out_depth = fmt->depth[0];	ctx->param.enc_param.out_fmt = fmt->color;	return 0;}

static int nxp_video_streamoff(struct file *file, void *fh,        enum v4l2_buf_type i){    int ret;    u32 pad;    struct nxp_video *me;    struct v4l2_subdev *subdev;    void *hostdata_back;    me = file->private_data;    subdev = _get_remote_subdev(me, i, &pad);    if (me->vbq) {        ret = vb2_streamoff(me->vbq, i);        if (ret < 0) {            printk(KERN_ERR "%s: failed to vb2_streamoff() %s/n", __func__, me->name);            return 0;        }    } else {        struct vb2_queue *vq = v4l2_m2m_get_vq(me->m2m_ctx, i);        ret = vb2_streamoff(vq, i);        if (ret < 0) {            pr_err(KERN_ERR "%s: m2m, failed to vb2_streamoff() %s/n", __func__, me->name);            return 0;        }    }    vmsg("%s %s/n", __func__, me->name);    hostdata_back = v4l2_get_subdev_hostdata(subdev);    v4l2_set_subdev_hostdata(subdev, me->name);    ret = v4l2_subdev_call(subdev, video, s_stream, 0);    v4l2_set_subdev_hostdata(subdev, hostdata_back);    vmsg("%s: %s exit/n", __func__, me->name);    return ret;}

static int vidioc_s_fmt(struct file *file, void *prv, struct v4l2_format *f){	struct g2d_ctx *ctx = prv;	struct g2d_dev *dev = ctx->dev;	struct vb2_queue *vq;	struct g2d_frame *frm;	struct g2d_fmt *fmt;	int ret = 0;	/* Adjust all values accordingly to the hardware capabilities	 * and chosen format. */	ret = vidioc_try_fmt(file, prv, f);	if (ret)		return ret;	vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);	if (vb2_is_busy(vq)) {		v4l2_err(&dev->v4l2_dev, "queue (%d) bust/n", f->type);		return -EBUSY;	}	frm = get_frame(ctx, f->type);	if (IS_ERR(frm))		return PTR_ERR(frm);	fmt = find_fmt(f);	if (!fmt)		return -EINVAL;	frm->width	= f->fmt.pix.width;	frm->height	= f->fmt.pix.height;	frm->size	= f->fmt.pix.sizeimage;	/* Reset crop settings */	frm->o_width	= 0;	frm->o_height	= 0;	frm->c_width	= frm->width;	frm->c_height	= frm->height;	frm->right	= frm->width;	frm->bottom	= frm->height;	frm->fmt	= fmt;	frm->stride	= f->fmt.pix.bytesperline;	return 0;}