Lines Matching refs:ctx
91 static void set_default_params(struct hva_ctx *ctx)
93 struct hva_frameinfo *frameinfo = &ctx->frameinfo;
94 struct hva_streaminfo *streaminfo = &ctx->streaminfo;
111 ctx->colorspace = V4L2_COLORSPACE_REC709;
112 ctx->xfer_func = V4L2_XFER_FUNC_DEFAULT;
113 ctx->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
114 ctx->quantization = V4L2_QUANTIZATION_DEFAULT;
116 ctx->max_stream_size = estimated_stream_size(streaminfo->width,
120 static const struct hva_enc *hva_find_encoder(struct hva_ctx *ctx,
124 struct hva_dev *hva = ctx_to_hdev(ctx);
189 static int hva_open_encoder(struct hva_ctx *ctx, u32 streamformat,
192 struct hva_dev *hva = ctx_to_hdev(ctx);
193 struct device *dev = ctx_to_dev(ctx);
198 enc = (struct hva_enc *)hva_find_encoder(ctx, pixelformat,
202 ctx->name, (char *)&pixelformat, (char *)&streamformat);
207 ctx->name, (char *)&pixelformat, (char *)&streamformat);
210 snprintf(ctx->name, sizeof(ctx->name), "[%3d:%4.4s]",
214 ret = enc->open(ctx);
217 ctx->name, ret);
221 dev_dbg(dev, "%s %s encoder opened\n", ctx->name, enc->name);
228 static void hva_dbg_summary(struct hva_ctx *ctx)
230 struct device *dev = ctx_to_dev(ctx);
231 struct hva_streaminfo *stream = &ctx->streaminfo;
232 struct hva_frameinfo *frame = &ctx->frameinfo;
234 if (!(ctx->flags & HVA_FLAG_STREAMINFO))
238 ctx->name,
244 ctx->encoded_frames,
245 ctx->sys_errors,
246 ctx->encode_errors,
247 ctx->frame_errors);
257 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
258 struct hva_dev *hva = ctx_to_hdev(ctx);
271 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
272 struct hva_dev *hva = ctx_to_hdev(ctx);
285 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
286 struct hva_dev *hva = ctx_to_hdev(ctx);
298 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
299 struct hva_streaminfo *streaminfo = &ctx->streaminfo;
304 f->fmt.pix.colorspace = ctx->colorspace;
305 f->fmt.pix.xfer_func = ctx->xfer_func;
306 f->fmt.pix.ycbcr_enc = ctx->ycbcr_enc;
307 f->fmt.pix.quantization = ctx->quantization;
310 f->fmt.pix.sizeimage = ctx->max_stream_size;
317 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
318 struct hva_frameinfo *frameinfo = &ctx->frameinfo;
323 f->fmt.pix.colorspace = ctx->colorspace;
324 f->fmt.pix.xfer_func = ctx->xfer_func;
325 f->fmt.pix.ycbcr_enc = ctx->ycbcr_enc;
326 f->fmt.pix.quantization = ctx->quantization;
338 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
339 struct device *dev = ctx_to_dev(ctx);
346 enc = hva_find_encoder(ctx, ctx->frameinfo.pixelformat, streamformat);
350 ctx->name, (char *)&pix->pixelformat);
356 if (ctx->flags & HVA_FLAG_FRAMEINFO) {
361 pix->width = ctx->frameinfo.width;
362 pix->height = ctx->frameinfo.height;
366 ctx->name, width, height,
381 ctx->name, width, height,
390 pix->colorspace = ctx->colorspace;
391 pix->xfer_func = ctx->xfer_func;
392 pix->ycbcr_enc = ctx->ycbcr_enc;
393 pix->quantization = ctx->quantization;
402 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
403 struct device *dev = ctx_to_dev(ctx);
409 enc = hva_find_encoder(ctx, pixelformat, ctx->streaminfo.streamformat);
413 ctx->name, (char *)&pixelformat);
431 ctx->name, width, height, pix->width, pix->height);
452 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
453 struct device *dev = ctx_to_dev(ctx);
460 ctx->name, (char *)&f->fmt.pix.pixelformat);
464 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
467 ctx->name);
471 ctx->max_stream_size = f->fmt.pix.sizeimage;
472 ctx->streaminfo.width = f->fmt.pix.width;
473 ctx->streaminfo.height = f->fmt.pix.height;
474 ctx->streaminfo.streamformat = f->fmt.pix.pixelformat;
475 ctx->flags |= HVA_FLAG_STREAMINFO;
482 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
483 struct device *dev = ctx_to_dev(ctx);
491 ctx->name, (char *)&pix->pixelformat);
495 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
497 dev_dbg(dev, "%s V4L2 S_FMT (OUTPUT): queue busy\n", ctx->name);
501 ctx->colorspace = pix->colorspace;
502 ctx->xfer_func = pix->xfer_func;
503 ctx->ycbcr_enc = pix->ycbcr_enc;
504 ctx->quantization = pix->quantization;
506 ctx->frameinfo.aligned_width = ALIGN(pix->width, HVA_WIDTH_ALIGNMENT);
507 ctx->frameinfo.aligned_height = ALIGN(pix->height,
509 ctx->frameinfo.size = pix->sizeimage;
510 ctx->frameinfo.pixelformat = pix->pixelformat;
511 ctx->frameinfo.width = pix->width;
512 ctx->frameinfo.height = pix->height;
513 ctx->flags |= HVA_FLAG_FRAMEINFO;
520 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
521 struct v4l2_fract *time_per_frame = &ctx->ctrls.time_per_frame;
536 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
537 struct v4l2_fract *time_per_frame = &ctx->ctrls.time_per_frame;
556 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
557 struct device *dev = ctx_to_dev(ctx);
571 vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, buf->type);
574 dev_dbg(dev, "%s buffer index %d not found\n", ctx->name, buf->index);
581 return v4l2_m2m_qbuf(file, ctx->fh.m2m_ctx, buf);
615 struct hva_ctx *ctx = container_of(ctrl->handler, struct hva_ctx,
617 struct device *dev = ctx_to_dev(ctx);
619 dev_dbg(dev, "%s S_CTRL: id = %d, val = %d\n", ctx->name,
624 ctx->ctrls.bitrate_mode = ctrl->val;
627 ctx->ctrls.gop_size = ctrl->val;
630 ctx->ctrls.bitrate = ctrl->val;
633 ctx->ctrls.aspect = ctrl->val;
636 ctx->ctrls.profile = ctrl->val;
637 snprintf(ctx->streaminfo.profile,
638 sizeof(ctx->streaminfo.profile),
643 ctx->ctrls.level = ctrl->val;
644 snprintf(ctx->streaminfo.level,
645 sizeof(ctx->streaminfo.level),
650 ctx->ctrls.entropy_mode = ctrl->val;
653 ctx->ctrls.cpb_size = ctrl->val;
656 ctx->ctrls.dct8x8 = ctrl->val;
659 ctx->ctrls.qpmin = ctrl->val;
662 ctx->ctrls.qpmax = ctrl->val;
665 ctx->ctrls.vui_sar = ctrl->val;
668 ctx->ctrls.vui_sar_idc = ctrl->val;
671 ctx->ctrls.sei_fp = ctrl->val;
674 ctx->ctrls.sei_fp_type = ctrl->val;
678 ctx->name, ctrl->id);
690 static int hva_ctrls_setup(struct hva_ctx *ctx)
692 struct device *dev = ctx_to_dev(ctx);
697 v4l2_ctrl_handler_init(&ctx->ctrl_handler, 15);
699 v4l2_ctrl_new_std_menu(&ctx->ctrl_handler, &hva_ctrl_ops,
705 v4l2_ctrl_new_std(&ctx->ctrl_handler, &hva_ctrl_ops,
709 v4l2_ctrl_new_std(&ctx->ctrl_handler, &hva_ctrl_ops,
714 v4l2_ctrl_new_std_menu(&ctx->ctrl_handler, &hva_ctrl_ops,
724 v4l2_ctrl_new_std_menu(&ctx->ctrl_handler, &hva_ctrl_ops,
730 v4l2_ctrl_new_std_menu(&ctx->ctrl_handler, &hva_ctrl_ops,
736 v4l2_ctrl_new_std_menu(&ctx->ctrl_handler, &hva_ctrl_ops,
742 v4l2_ctrl_new_std(&ctx->ctrl_handler, &hva_ctrl_ops,
746 v4l2_ctrl_new_std(&ctx->ctrl_handler, &hva_ctrl_ops,
750 v4l2_ctrl_new_std(&ctx->ctrl_handler, &hva_ctrl_ops,
754 v4l2_ctrl_new_std(&ctx->ctrl_handler, &hva_ctrl_ops,
758 v4l2_ctrl_new_std(&ctx->ctrl_handler, &hva_ctrl_ops,
763 v4l2_ctrl_new_std_menu(&ctx->ctrl_handler, &hva_ctrl_ops,
769 v4l2_ctrl_new_std(&ctx->ctrl_handler, &hva_ctrl_ops,
774 v4l2_ctrl_new_std_menu(&ctx->ctrl_handler, &hva_ctrl_ops,
780 if (ctx->ctrl_handler.error) {
781 int err = ctx->ctrl_handler.error;
784 ctx->name, err);
785 v4l2_ctrl_handler_free(&ctx->ctrl_handler);
789 v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
792 ctx->ctrls.time_per_frame.numerator = HVA_DEFAULT_FRAME_NUM;
793 ctx->ctrls.time_per_frame.denominator = HVA_DEFAULT_FRAME_DEN;
804 struct hva_ctx *ctx = container_of(work, struct hva_ctx, run_work);
806 const struct hva_enc *enc = ctx->enc;
812 mutex_lock(&ctx->lock);
815 hva_dbg_perf_begin(ctx);
818 src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
819 dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
823 frame->vbuf.sequence = ctx->frame_num++;
825 ret = enc->encode(ctx, frame, stream);
835 dst_buf->sequence = ctx->stream_num - 1;
837 ctx->encoded_frames++;
840 hva_dbg_perf_end(ctx, stream);
847 mutex_unlock(&ctx->lock);
849 v4l2_m2m_job_finish(ctx->hva_dev->m2m_dev, ctx->fh.m2m_ctx);
854 struct hva_ctx *ctx = priv;
855 struct hva_dev *hva = ctx_to_hdev(ctx);
857 queue_work(hva->work_queue, &ctx->run_work);
862 struct hva_ctx *ctx = priv;
863 struct device *dev = ctx_to_dev(ctx);
865 dev_dbg(dev, "%s aborting job\n", ctx->name);
867 ctx->aborting = true;
872 struct hva_ctx *ctx = priv;
873 struct device *dev = ctx_to_dev(ctx);
875 if (!v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx)) {
877 ctx->name);
881 if (!v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx)) {
883 ctx->name);
887 if (ctx->aborting) {
888 dev_dbg(dev, "%s job not ready: aborting\n", ctx->name);
910 struct hva_ctx *ctx = vb2_get_drv_priv(vq);
911 struct device *dev = ctx_to_dev(ctx);
914 dev_dbg(dev, "%s %s queue setup: num_buffers %d\n", ctx->name,
918 ctx->frameinfo.size : ctx->max_stream_size;
932 struct hva_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
933 struct device *dev = ctx_to_dev(ctx);
944 ctx->name, vb->index, vbuf->field);
953 frame->info = ctx->frameinfo;
958 ctx->name, vb->index,
974 ctx->name, vb->index,
984 struct hva_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
987 if (ctx->fh.m2m_ctx)
988 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
993 struct hva_ctx *ctx = vb2_get_drv_priv(vq);
994 struct hva_dev *hva = ctx_to_hdev(ctx);
995 struct device *dev = ctx_to_dev(ctx);
1001 dev_dbg(dev, "%s %s start streaming\n", ctx->name,
1006 if (!vb2_start_streaming_called(&ctx->fh.m2m_ctx->cap_q_ctx.q))
1009 if (!vb2_start_streaming_called(&ctx->fh.m2m_ctx->out_q_ctx.q))
1016 hva->instances[i] = ctx;
1018 ctx->id = i;
1025 dev_err(dev, "%s maximum instances reached\n", ctx->name);
1032 if (!ctx->enc) {
1033 ret = hva_open_encoder(ctx,
1034 ctx->streaminfo.streamformat,
1035 ctx->frameinfo.pixelformat,
1036 &ctx->enc);
1044 hva->instances[ctx->id] = NULL;
1049 while ((vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx)))
1053 while ((vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx)))
1057 ctx->sys_errors++;
1064 struct hva_ctx *ctx = vb2_get_drv_priv(vq);
1065 struct hva_dev *hva = ctx_to_hdev(ctx);
1066 struct device *dev = ctx_to_dev(ctx);
1067 const struct hva_enc *enc = ctx->enc;
1070 dev_dbg(dev, "%s %s stop streaming\n", ctx->name,
1075 ctx->frame_num = 0;
1076 while ((vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx)))
1080 ctx->stream_num = 0;
1081 while ((vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx)))
1086 vb2_is_streaming(&ctx->fh.m2m_ctx->cap_q_ctx.q)) ||
1088 vb2_is_streaming(&ctx->fh.m2m_ctx->out_q_ctx.q))) {
1090 ctx->name, to_type_str(vq->type),
1091 vb2_is_streaming(&ctx->fh.m2m_ctx->out_q_ctx.q),
1092 vb2_is_streaming(&ctx->fh.m2m_ctx->cap_q_ctx.q));
1098 dev_dbg(dev, "%s %s encoder closed\n", ctx->name, enc->name);
1099 enc->close(ctx);
1100 ctx->enc = NULL;
1103 hva->instances[ctx->id] = NULL;
1107 ctx->aborting = false;
1125 static int queue_init(struct hva_ctx *ctx, struct vb2_queue *vq)
1128 vq->drv_priv = ctx;
1132 vq->lock = &ctx->hva_dev->lock;
1140 struct hva_ctx *ctx = priv;
1146 src_vq->dev = ctx->hva_dev->dev;
1148 ret = queue_init(ctx, src_vq);
1155 dst_vq->dev = ctx->hva_dev->dev;
1157 return queue_init(ctx, dst_vq);
1164 struct hva_ctx *ctx;
1167 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
1168 if (!ctx) {
1172 ctx->hva_dev = hva;
1174 INIT_WORK(&ctx->run_work, hva_run_work);
1175 v4l2_fh_init(&ctx->fh, video_devdata(file));
1176 file->private_data = &ctx->fh;
1177 v4l2_fh_add(&ctx->fh);
1179 ret = hva_ctrls_setup(ctx);
1183 ctx->sys_errors++;
1186 ctx->fh.ctrl_handler = &ctx->ctrl_handler;
1188 mutex_init(&ctx->lock);
1190 ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(hva->m2m_dev, ctx,
1192 if (IS_ERR(ctx->fh.m2m_ctx)) {
1193 ret = PTR_ERR(ctx->fh.m2m_ctx);
1196 ctx->sys_errors++;
1203 snprintf(ctx->name, sizeof(ctx->name), "[%3d:----]",
1208 set_default_params(ctx);
1211 hva_dbg_ctx_create(ctx);
1214 dev_info(dev, "%s encoder instance created\n", ctx->name);
1219 v4l2_ctrl_handler_free(&ctx->ctrl_handler);
1221 v4l2_fh_del(&ctx->fh);
1222 v4l2_fh_exit(&ctx->fh);
1223 kfree(ctx);
1230 struct hva_ctx *ctx = fh_to_ctx(file->private_data);
1231 struct hva_dev *hva = ctx_to_hdev(ctx);
1232 struct device *dev = ctx_to_dev(ctx);
1233 const struct hva_enc *enc = ctx->enc;
1236 dev_dbg(dev, "%s %s encoder closed\n", ctx->name, enc->name);
1237 enc->close(ctx);
1238 ctx->enc = NULL;
1241 hva->instances[ctx->id] = NULL;
1246 hva_dbg_summary(ctx);
1248 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
1250 v4l2_ctrl_handler_free(&ctx->ctrl_handler);
1252 v4l2_fh_del(&ctx->fh);
1253 v4l2_fh_exit(&ctx->fh);
1256 hva_dbg_ctx_remove(ctx);
1259 dev_info(dev, "%s encoder instance released\n", ctx->name);
1261 kfree(ctx);