tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
media: visl: Add a tpg_verbose parameter
The text written on the output frames stable for a given input.
Remove the unstable elements like pointers, buffer indexes or queues
status so that frames are always identical and can be compared against
a reference in automatic tests.
As the unstable information can be relevant when debugging the API, add
a tpg_verbose parameter to show them.
Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
Signed-off-by: Hans Verkuil <hverkuil-cisco@xs4all.nl>
[hverkuil: correct a few small checkpatch issues]
authored by
Detlev Casanova
and committed by
Hans Verkuil
8901f20b
68f715a8
+158
-123
+5
drivers/media/test-drivers/visl/visl-core.c
+5
drivers/media/test-drivers/visl/visl-core.c
···
88
88
MODULE_PARM_DESC(bitstream_trace_nframes,
89
89
" the number of frames to dump the bitstream through debugfs");
90
90
91
+
bool tpg_verbose;
92
+
module_param(tpg_verbose, bool, 0644);
93
+
MODULE_PARM_DESC(tpg_verbose,
94
+
" add more verbose information on the generated output frames");
95
+
91
96
static const struct visl_ctrl_desc visl_fwht_ctrl_descs[] = {
92
97
{
93
98
.cfg.id = V4L2_CID_STATELESS_FWHT_PARAMS,
+152
-123
drivers/media/test-drivers/visl/visl-dec.c
+152
-123
drivers/media/test-drivers/visl/visl-dec.c
···
42
42
return vbuf;
43
43
}
44
44
45
+
static 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
+
45
61
static void visl_get_ref_frames(struct visl_ctx *ctx, u8 *buf,
46
62
__kernel_size_t buflen, struct visl_run *run)
47
63
{
···
79
63
80
64
vb2_buf = vb2_find_buffer(cap_q, run->fwht.params->backward_ref_ts);
81
65
82
-
scnprintf(buf, buflen, "backwards_ref_ts: %lld, vb2_idx: %d",
83
-
run->fwht.params->backward_ref_ts,
84
-
vb2_buf ? vb2_buf->index : -1);
66
+
visl_print_ts_idx(&buf, &buflen, "backwards_ref_ts",
67
+
run->fwht.params->backward_ref_ts, vb2_buf);
68
+
85
69
break;
86
70
}
87
71
···
92
76
b_ref = vb2_find_buffer(cap_q, run->mpeg2.pic->backward_ref_ts);
93
77
f_ref = vb2_find_buffer(cap_q, run->mpeg2.pic->forward_ref_ts);
94
78
95
-
scnprintf(buf, buflen,
96
-
"backward_ref_ts: %llu, vb2_idx: %d\n"
97
-
"forward_ref_ts: %llu, vb2_idx: %d\n",
98
-
run->mpeg2.pic->backward_ref_ts,
99
-
b_ref ? b_ref->index : -1,
100
-
run->mpeg2.pic->forward_ref_ts,
101
-
f_ref ? f_ref->index : -1);
79
+
visl_print_ts_idx(&buf, &buflen, "backward_ref_ts",
80
+
run->mpeg2.pic->backward_ref_ts, b_ref);
81
+
visl_print_ts_idx(&buf, &buflen, "forward_ref_ts",
82
+
run->mpeg2.pic->forward_ref_ts, f_ref);
83
+
102
84
break;
103
85
}
104
86
···
109
95
golden = vb2_find_buffer(cap_q, run->vp8.frame->golden_frame_ts);
110
96
alt = vb2_find_buffer(cap_q, run->vp8.frame->alt_frame_ts);
111
97
112
-
scnprintf(buf, buflen,
113
-
"last_ref_ts: %llu, vb2_idx: %d\n"
114
-
"golden_ref_ts: %llu, vb2_idx: %d\n"
115
-
"alt_ref_ts: %llu, vb2_idx: %d\n",
116
-
run->vp8.frame->last_frame_ts,
117
-
last ? last->index : -1,
118
-
run->vp8.frame->golden_frame_ts,
119
-
golden ? golden->index : -1,
120
-
run->vp8.frame->alt_frame_ts,
121
-
alt ? alt->index : -1);
98
+
visl_print_ts_idx(&buf, &buflen, "last_ref_ts",
99
+
run->vp8.frame->last_frame_ts, last);
100
+
visl_print_ts_idx(&buf, &buflen, "golden_ref_ts",
101
+
run->vp8.frame->golden_frame_ts, golden);
102
+
visl_print_ts_idx(&buf, &buflen, "alt_ref_ts",
103
+
run->vp8.frame->alt_frame_ts, alt);
104
+
122
105
break;
123
106
}
124
107
···
128
117
golden = vb2_find_buffer(cap_q, run->vp9.frame->golden_frame_ts);
129
118
alt = vb2_find_buffer(cap_q, run->vp9.frame->alt_frame_ts);
130
119
131
-
scnprintf(buf, buflen,
132
-
"last_ref_ts: %llu, vb2_idx: %d\n"
133
-
"golden_ref_ts: %llu, vb2_idx: %d\n"
134
-
"alt_ref_ts: %llu, vb2_idx: %d\n",
135
-
run->vp9.frame->last_frame_ts,
136
-
last ? last->index : -1,
137
-
run->vp9.frame->golden_frame_ts,
138
-
golden ? golden->index : -1,
139
-
run->vp9.frame->alt_frame_ts,
140
-
alt ? alt->index : -1);
120
+
visl_print_ts_idx(&buf, &buflen, "last_ref_ts",
121
+
run->vp9.frame->last_frame_ts, last);
122
+
visl_print_ts_idx(&buf, &buflen, "golden_ref_ts",
123
+
run->vp9.frame->golden_frame_ts, golden);
124
+
visl_print_ts_idx(&buf, &buflen, "alt_ref_ts",
125
+
run->vp9.frame->alt_frame_ts, alt);
126
+
141
127
break;
142
128
}
143
129
144
130
case VISL_CODEC_H264: {
145
131
char entry[] = "dpb[%d]:%u, vb2_index: %d\n";
132
+
char entry_stable[] = "dpb[%d]:%u\n";
146
133
struct vb2_buffer *vb2_buf;
147
134
148
135
for (i = 0; i < ARRAY_SIZE(run->h264.dpram->dpb); i++) {
149
-
vb2_buf = vb2_find_buffer(cap_q, run->h264.dpram->dpb[i].reference_ts);
150
-
len = scnprintf(buf, buflen, entry, i,
151
-
run->h264.dpram->dpb[i].reference_ts,
152
-
vb2_buf ? vb2_buf->index : -1);
136
+
vb2_buf = vb2_find_buffer(cap_q,
137
+
run->h264.dpram->dpb[i].reference_ts);
138
+
if (tpg_verbose && vb2_buf) {
139
+
len = scnprintf(buf, buflen, entry, i,
140
+
run->h264.dpram->dpb[i].reference_ts,
141
+
vb2_buf->index);
142
+
} else {
143
+
len = scnprintf(buf, buflen, entry_stable, i,
144
+
run->h264.dpram->dpb[i].reference_ts);
145
+
}
153
146
buf += len;
154
147
buflen -= len;
155
148
}
···
163
148
164
149
case VISL_CODEC_HEVC: {
165
150
char entry[] = "dpb[%d]:%u, vb2_index: %d\n";
151
+
char entry_stable[] = "dpb[%d]:%u\n";
166
152
struct vb2_buffer *vb2_buf;
167
153
168
154
for (i = 0; i < ARRAY_SIZE(run->hevc.dpram->dpb); i++) {
169
155
vb2_buf = vb2_find_buffer(cap_q, run->hevc.dpram->dpb[i].timestamp);
170
-
len = scnprintf(buf, buflen, entry, i,
171
-
run->hevc.dpram->dpb[i].timestamp,
172
-
vb2_buf ? vb2_buf->index : -1);
156
+
if (tpg_verbose && vb2_buf) {
157
+
len = scnprintf(buf, buflen, entry, i,
158
+
run->hevc.dpram->dpb[i].timestamp,
159
+
vb2_buf->index);
160
+
} else {
161
+
len = scnprintf(buf, buflen, entry_stable, i,
162
+
run->hevc.dpram->dpb[i].timestamp);
163
+
}
164
+
173
165
buf += len;
174
166
buflen -= len;
175
167
}
···
193
171
int idx_alt2 = run->av1.frame->ref_frame_idx[ALT2_BUF_IDX];
194
172
int idx_alt = run->av1.frame->ref_frame_idx[ALT_BUF_IDX];
195
173
196
-
struct vb2_buffer *ref_last =
197
-
vb2_find_buffer(cap_q, run->av1.frame->reference_frame_ts[idx_last]);
198
-
struct vb2_buffer *ref_last2 =
199
-
vb2_find_buffer(cap_q, run->av1.frame->reference_frame_ts[idx_last2]);
200
-
struct vb2_buffer *ref_last3 =
201
-
vb2_find_buffer(cap_q, run->av1.frame->reference_frame_ts[idx_last3]);
202
-
struct vb2_buffer *ref_golden =
203
-
vb2_find_buffer(cap_q, run->av1.frame->reference_frame_ts[idx_golden]);
204
-
struct vb2_buffer *ref_bwd =
205
-
vb2_find_buffer(cap_q, run->av1.frame->reference_frame_ts[idx_bwd]);
206
-
struct vb2_buffer *ref_alt2 =
207
-
vb2_find_buffer(cap_q, run->av1.frame->reference_frame_ts[idx_alt2]);
208
-
struct vb2_buffer *ref_alt =
209
-
vb2_find_buffer(cap_q, run->av1.frame->reference_frame_ts[idx_alt]);
174
+
const u64 *reference_frame_ts = run->av1.frame->reference_frame_ts;
210
175
211
-
scnprintf(buf, buflen,
212
-
"ref_last_ts: %llu, vb2_idx: %d\n"
213
-
"ref_last2_ts: %llu, vb2_idx: %d\n"
214
-
"ref_last3_ts: %llu, vb2_idx: %d\n"
215
-
"ref_golden_ts: %llu, vb2_idx: %d\n"
216
-
"ref_bwd_ts: %llu, vb2_idx: %d\n"
217
-
"ref_alt2_ts: %llu, vb2_idx: %d\n"
218
-
"ref_alt_ts: %llu, vb2_idx: %d\n",
219
-
run->av1.frame->reference_frame_ts[idx_last],
220
-
ref_last ? ref_last->index : -1,
221
-
run->av1.frame->reference_frame_ts[idx_last2],
222
-
ref_last2 ? ref_last2->index : -1,
223
-
run->av1.frame->reference_frame_ts[idx_last3],
224
-
ref_last3 ? ref_last3->index : -1,
225
-
run->av1.frame->reference_frame_ts[idx_golden],
226
-
ref_golden ? ref_golden->index : -1,
227
-
run->av1.frame->reference_frame_ts[idx_bwd],
228
-
ref_bwd ? ref_bwd->index : -1,
229
-
run->av1.frame->reference_frame_ts[idx_alt2],
230
-
ref_alt2 ? ref_alt2->index : -1,
231
-
run->av1.frame->reference_frame_ts[idx_alt],
232
-
ref_alt ? ref_alt->index : -1);
176
+
struct vb2_buffer *ref_last =
177
+
vb2_find_buffer(cap_q, reference_frame_ts[idx_last]);
178
+
struct vb2_buffer *ref_last2 =
179
+
vb2_find_buffer(cap_q, reference_frame_ts[idx_last2]);
180
+
struct vb2_buffer *ref_last3 =
181
+
vb2_find_buffer(cap_q, reference_frame_ts[idx_last3]);
182
+
struct vb2_buffer *ref_golden =
183
+
vb2_find_buffer(cap_q, reference_frame_ts[idx_golden]);
184
+
struct vb2_buffer *ref_bwd =
185
+
vb2_find_buffer(cap_q, reference_frame_ts[idx_bwd]);
186
+
struct vb2_buffer *ref_alt2 =
187
+
vb2_find_buffer(cap_q, reference_frame_ts[idx_alt2]);
188
+
struct vb2_buffer *ref_alt =
189
+
vb2_find_buffer(cap_q, reference_frame_ts[idx_alt]);
190
+
191
+
visl_print_ts_idx(&buf, &buflen, "ref_last_ts",
192
+
reference_frame_ts[idx_last], ref_last);
193
+
visl_print_ts_idx(&buf, &buflen, "ref_last2_ts",
194
+
reference_frame_ts[idx_last2], ref_last2);
195
+
visl_print_ts_idx(&buf, &buflen, "ref_last3_ts",
196
+
reference_frame_ts[idx_last3], ref_last3);
197
+
visl_print_ts_idx(&buf, &buflen, "ref_golden_ts",
198
+
reference_frame_ts[idx_golden], ref_golden);
199
+
visl_print_ts_idx(&buf, &buflen, "ref_bwd_ts",
200
+
reference_frame_ts[idx_bwd], ref_bwd);
201
+
visl_print_ts_idx(&buf, &buflen, "ref_alt2_ts",
202
+
reference_frame_ts[idx_alt2], ref_alt2);
203
+
visl_print_ts_idx(&buf, &buflen, "ref_alt_ts",
204
+
reference_frame_ts[idx_alt], ref_alt);
205
+
233
206
break;
234
207
}
235
208
}
···
271
254
struct visl_run *run, char buf[], size_t bufsz)
272
255
{
273
256
u32 stream_ms;
257
+
int len;
274
258
275
-
stream_ms = jiffies_to_msecs(get_jiffies_64() - ctx->capture_streamon_jiffies);
259
+
if (tpg_verbose) {
260
+
stream_ms = jiffies_to_msecs(get_jiffies_64() - ctx->capture_streamon_jiffies);
261
+
262
+
len = scnprintf(buf, bufsz,
263
+
"stream time: %02d:%02d:%02d:%03d ",
264
+
(stream_ms / (60 * 60 * 1000)) % 24,
265
+
(stream_ms / (60 * 1000)) % 60,
266
+
(stream_ms / 1000) % 60,
267
+
stream_ms % 1000);
268
+
buf += len;
269
+
bufsz -= len;
270
+
}
276
271
277
272
scnprintf(buf, bufsz,
278
-
"stream time: %02d:%02d:%02d:%03d sequence:%u timestamp:%lld field:%s",
279
-
(stream_ms / (60 * 60 * 1000)) % 24,
280
-
(stream_ms / (60 * 1000)) % 60,
281
-
(stream_ms / 1000) % 60,
282
-
stream_ms % 1000,
273
+
"sequence:%u timestamp:%lld field:%s",
283
274
run->dst->sequence,
284
275
run->dst->vb2_buf.timestamp,
285
276
(run->dst->field == V4L2_FIELD_ALTERNATE) ?
···
363
338
frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);
364
339
}
365
340
366
-
line++;
367
-
frame_dprintk(ctx->dev, run->dst->sequence, "");
368
-
scnprintf(buf, TPG_STR_BUF_SZ, "Output queue status:");
369
-
tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, buf);
370
-
frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);
341
+
if (tpg_verbose) {
342
+
line++;
343
+
frame_dprintk(ctx->dev, run->dst->sequence, "");
344
+
scnprintf(buf, TPG_STR_BUF_SZ, "Output queue status:");
345
+
tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, buf);
346
+
frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);
371
347
372
-
len = 0;
373
-
for (i = 0; i < vb2_get_num_buffers(out_q); i++) {
374
-
char entry[] = "index: %u, state: %s, request_fd: %d, ";
375
-
u32 old_len = len;
376
-
struct vb2_buffer *vb2;
377
-
char *q_status;
348
+
len = 0;
349
+
for (i = 0; i < vb2_get_num_buffers(out_q); i++) {
350
+
char entry[] = "index: %u, state: %s, request_fd: %d, ";
351
+
u32 old_len = len;
352
+
struct vb2_buffer *vb2;
353
+
char *q_status;
378
354
379
-
vb2 = vb2_get_buffer(out_q, i);
380
-
if (!vb2)
381
-
continue;
355
+
vb2 = vb2_get_buffer(out_q, i);
356
+
if (!vb2)
357
+
continue;
382
358
383
-
q_status = visl_get_vb2_state(vb2->state);
359
+
q_status = visl_get_vb2_state(vb2->state);
384
360
385
-
len += scnprintf(&buf[len], TPG_STR_BUF_SZ - len,
386
-
entry, i, q_status,
387
-
to_vb2_v4l2_buffer(vb2)->request_fd);
361
+
len += scnprintf(&buf[len], TPG_STR_BUF_SZ - len,
362
+
entry, i, q_status,
363
+
to_vb2_v4l2_buffer(vb2)->request_fd);
388
364
389
-
len += visl_fill_bytesused(to_vb2_v4l2_buffer(vb2),
390
-
&buf[len],
391
-
TPG_STR_BUF_SZ - len);
365
+
len += visl_fill_bytesused(to_vb2_v4l2_buffer(vb2),
366
+
&buf[len],
367
+
TPG_STR_BUF_SZ - len);
392
368
393
-
tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, &buf[old_len]);
394
-
frame_dprintk(ctx->dev, run->dst->sequence, "%s", &buf[old_len]);
369
+
tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, &buf[old_len]);
370
+
frame_dprintk(ctx->dev, run->dst->sequence, "%s", &buf[old_len]);
371
+
}
395
372
}
396
373
397
374
line++;
···
425
398
frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);
426
399
}
427
400
428
-
line++;
429
-
frame_dprintk(ctx->dev, run->dst->sequence, "");
430
-
scnprintf(buf, TPG_STR_BUF_SZ, "Capture queue status:");
431
-
tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, buf);
432
-
frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);
401
+
if (tpg_verbose) {
402
+
line++;
403
+
frame_dprintk(ctx->dev, run->dst->sequence, "");
404
+
scnprintf(buf, TPG_STR_BUF_SZ, "Capture queue status:");
405
+
tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, buf);
406
+
frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);
433
407
434
-
len = 0;
435
-
for (i = 0; i < vb2_get_num_buffers(cap_q); i++) {
436
-
u32 old_len = len;
437
-
struct vb2_buffer *vb2;
438
-
char *q_status;
408
+
len = 0;
409
+
for (i = 0; i < vb2_get_num_buffers(cap_q); i++) {
410
+
u32 old_len = len;
411
+
struct vb2_buffer *vb2;
412
+
char *q_status;
439
413
440
-
vb2 = vb2_get_buffer(cap_q, i);
441
-
if (!vb2)
442
-
continue;
414
+
vb2 = vb2_get_buffer(cap_q, i);
415
+
if (!vb2)
416
+
continue;
443
417
444
-
q_status = visl_get_vb2_state(vb2->state);
418
+
q_status = visl_get_vb2_state(vb2->state);
445
419
446
-
len += scnprintf(&buf[len], TPG_STR_BUF_SZ - len,
447
-
"index: %u, status: %s, timestamp: %llu, is_held: %d",
448
-
vb2->index, q_status,
449
-
vb2->timestamp,
450
-
to_vb2_v4l2_buffer(vb2)->is_held);
420
+
len += scnprintf(&buf[len], TPG_STR_BUF_SZ - len,
421
+
"index: %u, status: %s, timestamp: %llu, is_held: %d",
422
+
vb2->index, q_status,
423
+
vb2->timestamp,
424
+
to_vb2_v4l2_buffer(vb2)->is_held);
451
425
452
-
tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, &buf[old_len]);
453
-
frame_dprintk(ctx->dev, run->dst->sequence, "%s", &buf[old_len]);
426
+
tpg_gen_text(&ctx->tpg, basep, line++ * line_height, 16, &buf[old_len]);
427
+
frame_dprintk(ctx->dev, run->dst->sequence, "%s", &buf[old_len]);
428
+
}
454
429
}
455
430
}
456
431