649 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Contains the virtual decoder logic. The functions here control the4 * tracing/TPG on a per-frame basis5 */6 7#include "visl.h"8#include "visl-debugfs.h"9#include "visl-dec.h"10#include "visl-trace-fwht.h"11#include "visl-trace-mpeg2.h"12#include "visl-trace-vp8.h"13#include "visl-trace-vp9.h"14#include "visl-trace-h264.h"15#include "visl-trace-hevc.h"16#include "visl-trace-av1.h"17 18#include <linux/delay.h>19#include <linux/workqueue.h>20#include <media/v4l2-mem2mem.h>21#include <media/tpg/v4l2-tpg.h>22 23#define LAST_BUF_IDX (V4L2_AV1_REF_LAST_FRAME - V4L2_AV1_REF_LAST_FRAME)24#define LAST2_BUF_IDX (V4L2_AV1_REF_LAST2_FRAME - V4L2_AV1_REF_LAST_FRAME)25#define LAST3_BUF_IDX (V4L2_AV1_REF_LAST3_FRAME - V4L2_AV1_REF_LAST_FRAME)26#define GOLDEN_BUF_IDX (V4L2_AV1_REF_GOLDEN_FRAME - V4L2_AV1_REF_LAST_FRAME)27#define BWD_BUF_IDX (V4L2_AV1_REF_BWDREF_FRAME - V4L2_AV1_REF_LAST_FRAME)28#define ALT2_BUF_IDX (V4L2_AV1_REF_ALTREF2_FRAME - V4L2_AV1_REF_LAST_FRAME)29#define ALT_BUF_IDX (V4L2_AV1_REF_ALTREF_FRAME - V4L2_AV1_REF_LAST_FRAME)30 31static void *plane_vaddr(struct tpg_data *tpg, struct vb2_buffer *buf,32 u32 p, u32 bpl[TPG_MAX_PLANES], u32 h)33{34 u32 i;35 void *vbuf;36 37 if (p == 0 || tpg_g_buffers(tpg) > 1)38 return vb2_plane_vaddr(buf, p);39 vbuf = vb2_plane_vaddr(buf, 0);40 for (i = 0; i < p; i++)41 vbuf += bpl[i] * h / tpg->vdownsampling[i];42 return vbuf;43}44 45static void visl_print_ts_idx(u8 **buf, __kernel_size_t *buflen, const char *name,46 u64 ts, struct vb2_buffer *vb2_buf)47{48 u32 len;49 50 if (tpg_verbose && vb2_buf) {51 len = scnprintf(*buf, *buflen, "%s: %lld, vb2_idx: %d\n", name,52 ts, vb2_buf->index);53 } else {54 len = scnprintf(*buf, *buflen, "%s: %lld\n", name, ts);55 }56 57 *buf += len;58 *buflen -= len;59}60 61static void visl_get_ref_frames(struct visl_ctx *ctx, u8 *buf,62 __kernel_size_t buflen, struct visl_run *run)63{64 struct vb2_queue *cap_q = &ctx->fh.m2m_ctx->cap_q_ctx.q;65 char header[] = "Reference frames:\n";66 u32 i;67 u32 len;68 69 len = scnprintf(buf, buflen, header);70 buf += len;71 buflen -= len;72 73 switch (ctx->current_codec) {74 case VISL_CODEC_NONE:75 break;76 77 case VISL_CODEC_FWHT: {78 struct vb2_buffer *vb2_buf;79 80 vb2_buf = vb2_find_buffer(cap_q, run->fwht.params->backward_ref_ts);81 82 visl_print_ts_idx(&buf, &buflen, "backwards_ref_ts",83 run->fwht.params->backward_ref_ts, vb2_buf);84 85 break;86 }87 88 case VISL_CODEC_MPEG2: {89 struct vb2_buffer *b_ref;90 struct vb2_buffer *f_ref;91 92 b_ref = vb2_find_buffer(cap_q, run->mpeg2.pic->backward_ref_ts);93 f_ref = vb2_find_buffer(cap_q, run->mpeg2.pic->forward_ref_ts);94 95 visl_print_ts_idx(&buf, &buflen, "backward_ref_ts",96 run->mpeg2.pic->backward_ref_ts, b_ref);97 visl_print_ts_idx(&buf, &buflen, "forward_ref_ts",98 run->mpeg2.pic->forward_ref_ts, f_ref);99 100 break;101 }102 103 case VISL_CODEC_VP8: {104 struct vb2_buffer *last;105 struct vb2_buffer *golden;106 struct vb2_buffer *alt;107 108 last = vb2_find_buffer(cap_q, run->vp8.frame->last_frame_ts);109 golden = vb2_find_buffer(cap_q, run->vp8.frame->golden_frame_ts);110 alt = vb2_find_buffer(cap_q, run->vp8.frame->alt_frame_ts);111 112 visl_print_ts_idx(&buf, &buflen, "last_ref_ts",113 run->vp8.frame->last_frame_ts, last);114 visl_print_ts_idx(&buf, &buflen, "golden_ref_ts",115 run->vp8.frame->golden_frame_ts, golden);116 visl_print_ts_idx(&buf, &buflen, "alt_ref_ts",117 run->vp8.frame->alt_frame_ts, alt);118 119 break;120 }121 122 case VISL_CODEC_VP9: {123 struct vb2_buffer *last;124 struct vb2_buffer *golden;125 struct vb2_buffer *alt;126 127 last = vb2_find_buffer(cap_q, run->vp9.frame->last_frame_ts);128 golden = vb2_find_buffer(cap_q, run->vp9.frame->golden_frame_ts);129 alt = vb2_find_buffer(cap_q, run->vp9.frame->alt_frame_ts);130 131 visl_print_ts_idx(&buf, &buflen, "last_ref_ts",132 run->vp9.frame->last_frame_ts, last);133 visl_print_ts_idx(&buf, &buflen, "golden_ref_ts",134 run->vp9.frame->golden_frame_ts, golden);135 visl_print_ts_idx(&buf, &buflen, "alt_ref_ts",136 run->vp9.frame->alt_frame_ts, alt);137 138 break;139 }140 141 case VISL_CODEC_H264: {142 char entry[] = "dpb[%d]:%u, vb2_index: %d\n";143 char entry_stable[] = "dpb[%d]:%u\n";144 struct vb2_buffer *vb2_buf;145 146 for (i = 0; i < ARRAY_SIZE(run->h264.dpram->dpb); i++) {147 vb2_buf = vb2_find_buffer(cap_q,148 run->h264.dpram->dpb[i].reference_ts);149 if (tpg_verbose && vb2_buf) {150 len = scnprintf(buf, buflen, entry, i,151 run->h264.dpram->dpb[i].reference_ts,152 vb2_buf->index);153 } else {154 len = scnprintf(buf, buflen, entry_stable, i,155 run->h264.dpram->dpb[i].reference_ts);156 }157 buf += len;158 buflen -= len;159 }160 161 break;162 }163 164 case VISL_CODEC_HEVC: {165 char entry[] = "dpb[%d]:%u, vb2_index: %d\n";166 char entry_stable[] = "dpb[%d]:%u\n";167 struct vb2_buffer *vb2_buf;168 169 for (i = 0; i < ARRAY_SIZE(run->hevc.dpram->dpb); i++) {170 vb2_buf = vb2_find_buffer(cap_q, run->hevc.dpram->dpb[i].timestamp);171 if (tpg_verbose && vb2_buf) {172 len = scnprintf(buf, buflen, entry, i,173 run->hevc.dpram->dpb[i].timestamp,174 vb2_buf->index);175 } else {176 len = scnprintf(buf, buflen, entry_stable, i,177 run->hevc.dpram->dpb[i].timestamp);178 }179 180 buf += len;181 buflen -= len;182 }183 184 break;185 }186 187 case VISL_CODEC_AV1: {188 int idx_last = run->av1.frame->ref_frame_idx[LAST_BUF_IDX];189 int idx_last2 = run->av1.frame->ref_frame_idx[LAST2_BUF_IDX];190 int idx_last3 = run->av1.frame->ref_frame_idx[LAST3_BUF_IDX];191 int idx_golden = run->av1.frame->ref_frame_idx[GOLDEN_BUF_IDX];192 int idx_bwd = run->av1.frame->ref_frame_idx[BWD_BUF_IDX];193 int idx_alt2 = run->av1.frame->ref_frame_idx[ALT2_BUF_IDX];194 int idx_alt = run->av1.frame->ref_frame_idx[ALT_BUF_IDX];195 196 const u64 *reference_frame_ts = run->av1.frame->reference_frame_ts;197 198 struct vb2_buffer *ref_last =199 vb2_find_buffer(cap_q, reference_frame_ts[idx_last]);200 struct vb2_buffer *ref_last2 =201 vb2_find_buffer(cap_q, reference_frame_ts[idx_last2]);202 struct vb2_buffer *ref_last3 =203 vb2_find_buffer(cap_q, reference_frame_ts[idx_last3]);204 struct vb2_buffer *ref_golden =205 vb2_find_buffer(cap_q, reference_frame_ts[idx_golden]);206 struct vb2_buffer *ref_bwd =207 vb2_find_buffer(cap_q, reference_frame_ts[idx_bwd]);208 struct vb2_buffer *ref_alt2 =209 vb2_find_buffer(cap_q, reference_frame_ts[idx_alt2]);210 struct vb2_buffer *ref_alt =211 vb2_find_buffer(cap_q, reference_frame_ts[idx_alt]);212 213 visl_print_ts_idx(&buf, &buflen, "ref_last_ts",214 reference_frame_ts[idx_last], ref_last);215 visl_print_ts_idx(&buf, &buflen, "ref_last2_ts",216 reference_frame_ts[idx_last2], ref_last2);217 visl_print_ts_idx(&buf, &buflen, "ref_last3_ts",218 reference_frame_ts[idx_last3], ref_last3);219 visl_print_ts_idx(&buf, &buflen, "ref_golden_ts",220 reference_frame_ts[idx_golden], ref_golden);221 visl_print_ts_idx(&buf, &buflen, "ref_bwd_ts",222 reference_frame_ts[idx_bwd], ref_bwd);223 visl_print_ts_idx(&buf, &buflen, "ref_alt2_ts",224 reference_frame_ts[idx_alt2], ref_alt2);225 visl_print_ts_idx(&buf, &buflen, "ref_alt_ts",226 reference_frame_ts[idx_alt], ref_alt);227 228 break;229 }230 }231}232 233static char *visl_get_vb2_state(enum vb2_buffer_state state)234{235 switch (state) {236 case VB2_BUF_STATE_DEQUEUED:237 return "Dequeued";238 case VB2_BUF_STATE_IN_REQUEST:239 return "In request";240 case VB2_BUF_STATE_PREPARING:241 return "Preparing";242 case VB2_BUF_STATE_QUEUED:243 return "Queued";244 case VB2_BUF_STATE_ACTIVE:245 return "Active";246 case VB2_BUF_STATE_DONE:247 return "Done";248 case VB2_BUF_STATE_ERROR:249 return "Error";250 default:251 return "";252 }253}254 255static int visl_fill_bytesused(struct vb2_v4l2_buffer *v4l2_vb2_buf, char *buf, size_t bufsz)256{257 int len = 0;258 u32 i;259 260 for (i = 0; i < v4l2_vb2_buf->vb2_buf.num_planes; i++)261 len += scnprintf(buf, bufsz,262 "bytesused[%u]: %u length[%u]: %u data_offset[%u]: %u",263 i, v4l2_vb2_buf->planes[i].bytesused,264 i, v4l2_vb2_buf->planes[i].length,265 i, v4l2_vb2_buf->planes[i].data_offset);266 267 return len;268}269 270static void visl_tpg_fill_sequence(struct visl_ctx *ctx,271 struct visl_run *run, char buf[], size_t bufsz)272{273 u32 stream_ms;274 int len;275 276 if (tpg_verbose) {277 stream_ms = jiffies_to_msecs(get_jiffies_64() - ctx->capture_streamon_jiffies);278 279 len = scnprintf(buf, bufsz,280 "stream time: %02d:%02d:%02d:%03d ",281 (stream_ms / (60 * 60 * 1000)) % 24,282 (stream_ms / (60 * 1000)) % 60,283 (stream_ms / 1000) % 60,284 stream_ms % 1000);285 buf += len;286 bufsz -= len;287 }288 289 scnprintf(buf, bufsz,290 "sequence:%u timestamp:%lld field:%s",291 run->dst->sequence,292 run->dst->vb2_buf.timestamp,293 (run->dst->field == V4L2_FIELD_ALTERNATE) ?294 (run->dst->field == V4L2_FIELD_TOP ?295 " top" : " bottom") : "none");296}297 298static bool visl_tpg_fill_codec_specific(struct visl_ctx *ctx,299 struct visl_run *run,300 char buf[], size_t bufsz)301{302 /*303 * To add variability, we need a value that is stable for a given304 * input but is different than already shown fields.305 * The pic order count value defines the display order of the frames306 * (which can be different than the decoding order that is shown with307 * the sequence number).308 * Therefore it is stable for a given input and will add a different309 * value that is more specific to the way the input is encoded.310 */311 switch (ctx->current_codec) {312 case VISL_CODEC_H264:313 scnprintf(buf, bufsz,314 "H264: %u", run->h264.dpram->pic_order_cnt_lsb);315 break;316 case VISL_CODEC_HEVC:317 scnprintf(buf, bufsz,318 "HEVC: %d", run->hevc.dpram->pic_order_cnt_val);319 break;320 default:321 return false;322 }323 324 return true;325}326 327static void visl_tpg_fill(struct visl_ctx *ctx, struct visl_run *run)328{329 u8 *basep[TPG_MAX_PLANES][2];330 char *buf = ctx->tpg_str_buf;331 char *tmp = buf;332 char *line_str;333 u32 line = 1;334 const u32 line_height = 16;335 u32 len;336 struct vb2_queue *out_q = &ctx->fh.m2m_ctx->out_q_ctx.q;337 struct vb2_queue *cap_q = &ctx->fh.m2m_ctx->cap_q_ctx.q;338 struct v4l2_pix_format_mplane *coded_fmt = &ctx->coded_fmt.fmt.pix_mp;339 struct v4l2_pix_format_mplane *decoded_fmt = &ctx->decoded_fmt.fmt.pix_mp;340 u32 p;341 u32 i;342 343 for (p = 0; p < tpg_g_planes(&ctx->tpg); p++) {344 void *vbuf = plane_vaddr(&ctx->tpg,345 &run->dst->vb2_buf, p,346 ctx->tpg.bytesperline,347 ctx->tpg.buf_height);348 349 tpg_calc_text_basep(&ctx->tpg, basep, p, vbuf);350 tpg_fill_plane_buffer(&ctx->tpg, 0, p, vbuf);351 }352 353 visl_tpg_fill_sequence(ctx, run, buf, TPG_STR_BUF_SZ);354 tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, buf);355 frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);356 frame_dprintk(ctx->dev, run->dst->sequence, "");357 line++;358 359 if (visl_tpg_fill_codec_specific(ctx, run, buf, TPG_STR_BUF_SZ)) {360 tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, buf);361 frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);362 frame_dprintk(ctx->dev, run->dst->sequence, "");363 line++;364 }365 366 visl_get_ref_frames(ctx, buf, TPG_STR_BUF_SZ, run);367 368 while ((line_str = strsep(&tmp, "\n")) && strlen(line_str)) {369 tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, line_str);370 frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", line_str);371 }372 373 frame_dprintk(ctx->dev, run->dst->sequence, "");374 line++;375 376 scnprintf(buf,377 TPG_STR_BUF_SZ,378 "OUTPUT pixelformat: %c%c%c%c, resolution: %dx%d, num_planes: %d",379 coded_fmt->pixelformat,380 (coded_fmt->pixelformat >> 8) & 0xff,381 (coded_fmt->pixelformat >> 16) & 0xff,382 (coded_fmt->pixelformat >> 24) & 0xff,383 coded_fmt->width,384 coded_fmt->height,385 coded_fmt->num_planes);386 387 tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, buf);388 frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);389 390 for (i = 0; i < coded_fmt->num_planes; i++) {391 scnprintf(buf,392 TPG_STR_BUF_SZ,393 "plane[%d]: bytesperline: %d, sizeimage: %d",394 i,395 coded_fmt->plane_fmt[i].bytesperline,396 coded_fmt->plane_fmt[i].sizeimage);397 398 tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, buf);399 frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);400 }401 402 if (tpg_verbose) {403 line++;404 frame_dprintk(ctx->dev, run->dst->sequence, "");405 scnprintf(buf, TPG_STR_BUF_SZ, "Output queue status:");406 tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, buf);407 frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);408 409 len = 0;410 for (i = 0; i < vb2_get_num_buffers(out_q); i++) {411 char entry[] = "index: %u, state: %s, request_fd: %d, ";412 u32 old_len = len;413 struct vb2_buffer *vb2;414 char *q_status;415 416 vb2 = vb2_get_buffer(out_q, i);417 if (!vb2)418 continue;419 420 q_status = visl_get_vb2_state(vb2->state);421 422 len += scnprintf(&buf[len], TPG_STR_BUF_SZ - len,423 entry, i, q_status,424 to_vb2_v4l2_buffer(vb2)->request_fd);425 426 len += visl_fill_bytesused(to_vb2_v4l2_buffer(vb2),427 &buf[len],428 TPG_STR_BUF_SZ - len);429 430 tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, &buf[old_len]);431 frame_dprintk(ctx->dev, run->dst->sequence, "%s", &buf[old_len]);432 }433 }434 435 line++;436 frame_dprintk(ctx->dev, run->dst->sequence, "");437 438 scnprintf(buf,439 TPG_STR_BUF_SZ,440 "CAPTURE pixelformat: %c%c%c%c, resolution: %dx%d, num_planes: %d",441 decoded_fmt->pixelformat,442 (decoded_fmt->pixelformat >> 8) & 0xff,443 (decoded_fmt->pixelformat >> 16) & 0xff,444 (decoded_fmt->pixelformat >> 24) & 0xff,445 decoded_fmt->width,446 decoded_fmt->height,447 decoded_fmt->num_planes);448 449 tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, buf);450 frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);451 452 for (i = 0; i < decoded_fmt->num_planes; i++) {453 scnprintf(buf,454 TPG_STR_BUF_SZ,455 "plane[%d]: bytesperline: %d, sizeimage: %d",456 i,457 decoded_fmt->plane_fmt[i].bytesperline,458 decoded_fmt->plane_fmt[i].sizeimage);459 460 tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, buf);461 frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);462 }463 464 if (tpg_verbose) {465 line++;466 frame_dprintk(ctx->dev, run->dst->sequence, "");467 scnprintf(buf, TPG_STR_BUF_SZ, "Capture queue status:");468 tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, buf);469 frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);470 471 len = 0;472 for (i = 0; i < vb2_get_num_buffers(cap_q); i++) {473 u32 old_len = len;474 struct vb2_buffer *vb2;475 char *q_status;476 477 vb2 = vb2_get_buffer(cap_q, i);478 if (!vb2)479 continue;480 481 q_status = visl_get_vb2_state(vb2->state);482 483 len += scnprintf(&buf[len], TPG_STR_BUF_SZ - len,484 "index: %u, status: %s, timestamp: %llu, is_held: %d",485 vb2->index, q_status,486 vb2->timestamp,487 to_vb2_v4l2_buffer(vb2)->is_held);488 489 tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, &buf[old_len]);490 frame_dprintk(ctx->dev, run->dst->sequence, "%s", &buf[old_len]);491 }492 }493}494 495static void visl_trace_ctrls(struct visl_ctx *ctx, struct visl_run *run)496{497 int i;498 499 switch (ctx->current_codec) {500 default:501 case VISL_CODEC_NONE:502 break;503 case VISL_CODEC_FWHT:504 trace_v4l2_ctrl_fwht_params(run->fwht.params);505 break;506 case VISL_CODEC_MPEG2:507 trace_v4l2_ctrl_mpeg2_sequence(run->mpeg2.seq);508 trace_v4l2_ctrl_mpeg2_picture(run->mpeg2.pic);509 trace_v4l2_ctrl_mpeg2_quantisation(run->mpeg2.quant);510 break;511 case VISL_CODEC_VP8:512 trace_v4l2_ctrl_vp8_frame(run->vp8.frame);513 trace_v4l2_ctrl_vp8_entropy(run->vp8.frame);514 break;515 case VISL_CODEC_VP9:516 trace_v4l2_ctrl_vp9_frame(run->vp9.frame);517 trace_v4l2_ctrl_vp9_compressed_hdr(run->vp9.probs);518 trace_v4l2_ctrl_vp9_compressed_coeff(run->vp9.probs);519 trace_v4l2_vp9_mv_probs(&run->vp9.probs->mv);520 break;521 case VISL_CODEC_H264:522 trace_v4l2_ctrl_h264_sps(run->h264.sps);523 trace_v4l2_ctrl_h264_pps(run->h264.pps);524 trace_v4l2_ctrl_h264_scaling_matrix(run->h264.sm);525 trace_v4l2_ctrl_h264_slice_params(run->h264.spram);526 527 for (i = 0; i < ARRAY_SIZE(run->h264.spram->ref_pic_list0); i++)528 trace_v4l2_h264_ref_pic_list0(&run->h264.spram->ref_pic_list0[i], i);529 for (i = 0; i < ARRAY_SIZE(run->h264.spram->ref_pic_list0); i++)530 trace_v4l2_h264_ref_pic_list1(&run->h264.spram->ref_pic_list1[i], i);531 532 trace_v4l2_ctrl_h264_decode_params(run->h264.dpram);533 534 for (i = 0; i < ARRAY_SIZE(run->h264.dpram->dpb); i++)535 trace_v4l2_h264_dpb_entry(&run->h264.dpram->dpb[i], i);536 537 trace_v4l2_ctrl_h264_pred_weights(run->h264.pwht);538 break;539 case VISL_CODEC_HEVC:540 trace_v4l2_ctrl_hevc_sps(run->hevc.sps);541 trace_v4l2_ctrl_hevc_pps(run->hevc.pps);542 trace_v4l2_ctrl_hevc_slice_params(run->hevc.spram);543 trace_v4l2_ctrl_hevc_scaling_matrix(run->hevc.sm);544 trace_v4l2_ctrl_hevc_decode_params(run->hevc.dpram);545 546 for (i = 0; i < ARRAY_SIZE(run->hevc.dpram->dpb); i++)547 trace_v4l2_hevc_dpb_entry(&run->hevc.dpram->dpb[i]);548 549 trace_v4l2_hevc_pred_weight_table(&run->hevc.spram->pred_weight_table);550 break;551 case VISL_CODEC_AV1:552 trace_v4l2_ctrl_av1_sequence(run->av1.seq);553 trace_v4l2_ctrl_av1_frame(run->av1.frame);554 trace_v4l2_ctrl_av1_film_grain(run->av1.grain);555 trace_v4l2_ctrl_av1_tile_group_entry(run->av1.tge);556 break;557 }558}559 560void visl_device_run(void *priv)561{562 struct visl_ctx *ctx = priv;563 struct visl_run run = {};564 struct media_request *src_req;565 566 run.src = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);567 run.dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);568 569 /* Apply request(s) controls if needed. */570 src_req = run.src->vb2_buf.req_obj.req;571 572 if (src_req)573 v4l2_ctrl_request_setup(src_req, &ctx->hdl);574 575 v4l2_m2m_buf_copy_metadata(run.src, run.dst, true);576 run.dst->sequence = ctx->q_data[V4L2_M2M_DST].sequence++;577 run.src->sequence = ctx->q_data[V4L2_M2M_SRC].sequence++;578 run.dst->field = ctx->decoded_fmt.fmt.pix.field;579 580 switch (ctx->current_codec) {581 default:582 case VISL_CODEC_NONE:583 break;584 case VISL_CODEC_FWHT:585 run.fwht.params = visl_find_control_data(ctx, V4L2_CID_STATELESS_FWHT_PARAMS);586 break;587 case VISL_CODEC_MPEG2:588 run.mpeg2.seq = visl_find_control_data(ctx, V4L2_CID_STATELESS_MPEG2_SEQUENCE);589 run.mpeg2.pic = visl_find_control_data(ctx, V4L2_CID_STATELESS_MPEG2_PICTURE);590 run.mpeg2.quant = visl_find_control_data(ctx,591 V4L2_CID_STATELESS_MPEG2_QUANTISATION);592 break;593 case VISL_CODEC_VP8:594 run.vp8.frame = visl_find_control_data(ctx, V4L2_CID_STATELESS_VP8_FRAME);595 break;596 case VISL_CODEC_VP9:597 run.vp9.frame = visl_find_control_data(ctx, V4L2_CID_STATELESS_VP9_FRAME);598 run.vp9.probs = visl_find_control_data(ctx, V4L2_CID_STATELESS_VP9_COMPRESSED_HDR);599 break;600 case VISL_CODEC_H264:601 run.h264.sps = visl_find_control_data(ctx, V4L2_CID_STATELESS_H264_SPS);602 run.h264.pps = visl_find_control_data(ctx, V4L2_CID_STATELESS_H264_PPS);603 run.h264.sm = visl_find_control_data(ctx, V4L2_CID_STATELESS_H264_SCALING_MATRIX);604 run.h264.spram = visl_find_control_data(ctx, V4L2_CID_STATELESS_H264_SLICE_PARAMS);605 run.h264.dpram = visl_find_control_data(ctx, V4L2_CID_STATELESS_H264_DECODE_PARAMS);606 run.h264.pwht = visl_find_control_data(ctx, V4L2_CID_STATELESS_H264_PRED_WEIGHTS);607 break;608 case VISL_CODEC_HEVC:609 run.hevc.sps = visl_find_control_data(ctx, V4L2_CID_STATELESS_HEVC_SPS);610 run.hevc.pps = visl_find_control_data(ctx, V4L2_CID_STATELESS_HEVC_PPS);611 run.hevc.spram = visl_find_control_data(ctx, V4L2_CID_STATELESS_HEVC_SLICE_PARAMS);612 run.hevc.sm = visl_find_control_data(ctx, V4L2_CID_STATELESS_HEVC_SCALING_MATRIX);613 run.hevc.dpram = visl_find_control_data(ctx, V4L2_CID_STATELESS_HEVC_DECODE_PARAMS);614 break;615 case VISL_CODEC_AV1:616 run.av1.seq = visl_find_control_data(ctx, V4L2_CID_STATELESS_AV1_SEQUENCE);617 run.av1.frame = visl_find_control_data(ctx, V4L2_CID_STATELESS_AV1_FRAME);618 run.av1.tge = visl_find_control_data(ctx, V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY);619 run.av1.grain = visl_find_control_data(ctx, V4L2_CID_STATELESS_AV1_FILM_GRAIN);620 break;621 }622 623 frame_dprintk(ctx->dev, run.dst->sequence,624 "Got OUTPUT buffer sequence %d, timestamp %llu\n",625 run.src->sequence, run.src->vb2_buf.timestamp);626 627 frame_dprintk(ctx->dev, run.dst->sequence,628 "Got CAPTURE buffer sequence %d, timestamp %llu\n",629 run.dst->sequence, run.dst->vb2_buf.timestamp);630 631 visl_tpg_fill(ctx, &run);632 visl_trace_ctrls(ctx, &run);633 634 if (bitstream_trace_frame_start > -1 &&635 run.dst->sequence >= bitstream_trace_frame_start &&636 run.dst->sequence < bitstream_trace_frame_start + bitstream_trace_nframes)637 visl_trace_bitstream(ctx, &run);638 639 /* Complete request(s) controls if needed. */640 if (src_req)641 v4l2_ctrl_request_complete(src_req, &ctx->hdl);642 643 if (visl_transtime_ms)644 usleep_range(visl_transtime_ms * 1000, 2 * visl_transtime_ms * 1000);645 646 v4l2_m2m_buf_done_and_job_finish(ctx->dev->m2m_dev,647 ctx->fh.m2m_ctx, VB2_BUF_STATE_DONE);648}649