FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/dvdec.c
Date: 2026-09-21 15:08:56
Exec Total Coverage
Lines: 287 330 87.0%
Functions: 7 10 70.0%
Branches: 154 178 86.5%
Line Branch Exec Source
1 /*
2 * DV decoder
3 * Copyright (c) 2002 Fabrice Bellard
4 * Copyright (c) 2004 Roman Shaposhnik
5 *
6 * 50 Mbps (DVCPRO50) support
7 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
8 *
9 * 100 Mbps (DVCPRO HD) support
10 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
11 * Final code by Roman Shaposhnik
12 *
13 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
14 * of DV technical info.
15 *
16 * This file is part of FFmpeg.
17 *
18 * FFmpeg is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU Lesser General Public
20 * License as published by the Free Software Foundation; either
21 * version 2.1 of the License, or (at your option) any later version.
22 *
23 * FFmpeg is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 * Lesser General Public License for more details.
27 *
28 * You should have received a copy of the GNU Lesser General Public
29 * License along with FFmpeg; if not, write to the Free Software
30 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 */
32
33 /**
34 * @file
35 * DV decoder
36 */
37
38 #include "libavutil/avassert.h"
39 #include "libavutil/internal.h"
40 #include "libavutil/mem_internal.h"
41 #include "libavutil/thread.h"
42
43 #include "avcodec.h"
44 #include "codec_internal.h"
45 #include "decode.h"
46 #include "dv.h"
47 #include "dv_internal.h"
48 #include "dv_profile_internal.h"
49 #include "dvdata.h"
50 #include "get_bits.h"
51 #include "idctdsp.h"
52 #include "put_bits.h"
53 #include "simple_idct.h"
54 #include "thread.h"
55
56 typedef struct BlockInfo {
57 const uint32_t *factor_table;
58 const uint8_t *scan_table;
59 uint8_t pos; /* position in block */
60 void (*idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
61 uint8_t partial_bit_count;
62 uint32_t partial_bit_buffer;
63 int shift_offset;
64 } BlockInfo;
65
66 typedef struct DVDecContext {
67 const AVDVProfile *sys;
68 const AVFrame *frame;
69 const uint8_t *buf;
70
71 uint8_t dv_zigzag[2][64];
72 DVwork_chunk work_chunks[4 * 12 * 27];
73 uint32_t idct_factor[2 * 4 * 16 * 64];
74 void (*idct_put[2])(uint8_t *dest, ptrdiff_t stride, int16_t *block);
75
76 IDCTDSPContext idsp;
77 } DVDecContext;
78
79 static const int dv_iweight_bits = 14;
80
81 static const uint16_t dv_iweight_88[64] = {
82 32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081,
83 18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266,
84 19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267,
85 20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806,
86 20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400,
87 21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786,
88 24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172,
89 25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521,
90 };
91 static const uint16_t dv_iweight_248[64] = {
92 32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734,
93 18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091,
94 19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705,
95 20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806,
96 20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853,
97 21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018,
98 23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465,
99 25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692
100 };
101
102 /**
103 * The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
104 */
105 static const uint16_t dv_iweight_1080_y[64] = {
106 128, 16, 16, 17, 17, 17, 18, 18,
107 18, 18, 18, 18, 19, 18, 18, 19,
108 19, 19, 19, 19, 19, 42, 38, 40,
109 40, 40, 38, 42, 44, 43, 41, 41,
110 41, 41, 43, 44, 45, 45, 42, 42,
111 42, 45, 45, 48, 46, 43, 43, 46,
112 48, 49, 48, 44, 48, 49, 101, 98,
113 98, 101, 104, 109, 104, 116, 116, 123,
114 };
115 static const uint16_t dv_iweight_1080_c[64] = {
116 128, 16, 16, 17, 17, 17, 25, 25,
117 25, 25, 26, 25, 26, 25, 26, 26,
118 26, 27, 27, 26, 26, 42, 38, 40,
119 40, 40, 38, 42, 44, 43, 41, 41,
120 41, 41, 43, 44, 91, 91, 84, 84,
121 84, 91, 91, 96, 93, 86, 86, 93,
122 96, 197, 191, 177, 191, 197, 203, 197,
123 197, 203, 209, 219, 209, 232, 232, 246,
124 };
125 static const uint16_t dv_iweight_720_y[64] = {
126 128, 16, 16, 17, 17, 17, 18, 18,
127 18, 18, 18, 18, 19, 18, 18, 19,
128 19, 19, 19, 19, 19, 42, 38, 40,
129 40, 40, 38, 42, 44, 43, 41, 41,
130 41, 41, 43, 44, 68, 68, 63, 63,
131 63, 68, 68, 96, 92, 86, 86, 92,
132 96, 98, 96, 88, 96, 98, 202, 196,
133 196, 202, 208, 218, 208, 232, 232, 246,
134 };
135 static const uint16_t dv_iweight_720_c[64] = {
136 128, 24, 24, 26, 26, 26, 36, 36,
137 36, 36, 36, 36, 38, 36, 36, 38,
138 38, 38, 38, 38, 38, 84, 76, 80,
139 80, 80, 76, 84, 88, 86, 82, 82,
140 82, 82, 86, 88, 182, 182, 168, 168,
141 168, 182, 182, 192, 186, 192, 172, 186,
142 192, 394, 382, 354, 382, 394, 406, 394,
143 394, 406, 418, 438, 418, 464, 464, 492,
144 };
145
146 #define TEX_VLC_BITS 10
147
148 /* XXX: also include quantization */
149 static RL_VLC_ELEM dv_rl_vlc[1664];
150
151 38 static av_cold void dv_init_static(void)
152 {
153 38 VLCElem vlc_buf[FF_ARRAY_ELEMS(dv_rl_vlc)] = { 0 };
154 38 VLC dv_vlc = { .table = vlc_buf, .table_allocated = FF_ARRAY_ELEMS(vlc_buf) };
155 38 const unsigned offset = FF_ARRAY_ELEMS(dv_rl_vlc) - (2 * NB_DV_VLC - NB_DV_ZERO_LEVEL_ENTRIES);
156 38 RL_VLC_ELEM *tmp = dv_rl_vlc + offset;
157 int i, j;
158
159 /* it's faster to include sign bit in a generic VLC parsing scheme */
160
2/2
✓ Branch 0 taken 15542 times.
✓ Branch 1 taken 38 times.
 15580 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
161 15542 tmp[j].len8 = ff_dv_vlc_len[i];
162 15542 tmp[j].run = ff_dv_vlc_run[i];
163 15542 tmp[j].level = ff_dv_vlc_level[i];
164
165
2/2
✓ Branch 0 taken 12806 times.
✓ Branch 1 taken 2736 times.
 15542 if (ff_dv_vlc_level[i]) {
166 12806 tmp[j].len8++;
167
168 12806 j++;
169 12806 tmp[j].len8 = ff_dv_vlc_len[i] + 1;
170 12806 tmp[j].run = ff_dv_vlc_run[i];
171 12806 tmp[j].level = -ff_dv_vlc_level[i];
172 }
173 }
174
175 /* NOTE: as a trick, we use the fact the no codes are unused
176 * to accelerate the parsing of partial codes */
177 38 ff_vlc_init_from_lengths(&dv_vlc, TEX_VLC_BITS, j,
178 38 &tmp[0].len8, sizeof(tmp[0]),
179 NULL, 0, 0, 0, VLC_INIT_USE_STATIC, NULL);
180 av_assert1(dv_vlc.table_size == 1664);
181
182
2/2
✓ Branch 0 taken 63232 times.
✓ Branch 1 taken 38 times.
 63270 for (int i = 0; i < dv_vlc.table_size; i++) {
183 63232 int code = dv_vlc.table[i].sym;
184 63232 int len = dv_vlc.table[i].len;
185 int level, run;
186
187
2/2
✓ Branch 0 taken 1216 times.
✓ Branch 1 taken 62016 times.
 63232 if (len < 0) { // more bits needed
188 1216 run = 0;
189 1216 level = code;
190 } else {
191 av_assert1(i <= code + offset);
192 62016 run = tmp[code].run + 1;
193 62016 level = tmp[code].level;
194 }
195 63232 dv_rl_vlc[i].len8 = len;
196 63232 dv_rl_vlc[i].level = level;
197 63232 dv_rl_vlc[i].run = run;
198 }
199 38 }
200
201 63 static void dv_init_weight_tables(DVDecContext *ctx, const AVDVProfile *d)
202 {
203 int j, i, c, s;
204 63 uint32_t *factor1 = &ctx->idct_factor[0],
205
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 44 times.
 63 *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
206
207
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 44 times.
 63 if (DV_PROFILE_IS_HD(d)) {
208 /* quantization quanta by QNO for DV100 */
209 static const uint8_t dv100_qstep[16] = {
210 1, /* QNO = 0 and 1 both have no quantization */
211 1,
212 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
213 };
214 const uint16_t *iweight1, *iweight2;
215
216
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 10 times.
 19 if (d->height == 720) {
217 9 iweight1 = &dv_iweight_720_y[0];
218 9 iweight2 = &dv_iweight_720_c[0];
219 } else {
220 10 iweight1 = &dv_iweight_1080_y[0];
221 10 iweight2 = &dv_iweight_1080_c[0];
222 }
223
2/2
✓ Branch 0 taken 76 times.
✓ Branch 1 taken 19 times.
 95 for (c = 0; c < 4; c++) {
224
2/2
✓ Branch 0 taken 1216 times.
✓ Branch 1 taken 76 times.
 1292 for (s = 0; s < 16; s++) {
225
2/2
✓ Branch 0 taken 77824 times.
✓ Branch 1 taken 1216 times.
 79040 for (i = 0; i < 64; i++) {
226 77824 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
227 77824 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
228 }
229 }
230 }
231 } else {
232 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
233 44 const uint16_t *iweight1 = &dv_iweight_88[0];
234
2/2
✓ Branch 0 taken 88 times.
✓ Branch 1 taken 44 times.
 132 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
235
2/2
✓ Branch 0 taken 1936 times.
✓ Branch 1 taken 88 times.
 2024 for (s = 0; s < 22; s++) {
236
2/2
✓ Branch 0 taken 7744 times.
✓ Branch 1 taken 1936 times.
 9680 for (i = c = 0; c < 4; c++) {
237
2/2
✓ Branch 0 taken 123904 times.
✓ Branch 1 taken 7744 times.
 131648 for (; i < dv_quant_areas[c]; i++) {
238 123904 *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
239 123904 *factor2++ = (*factor1++) << 1;
240 }
241 }
242 }
243 }
244 }
245 63 }
246
247 68 static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
248 {
249 static AVOnce init_static_once = AV_ONCE_INIT;
250 68 DVDecContext *s = avctx->priv_data;
251 int i;
252
253 68 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
254
255 68 ff_idctdsp_init(&s->idsp, avctx);
256
257
2/2
✓ Branch 0 taken 4352 times.
✓ Branch 1 taken 68 times.
 4420 for (i = 0; i < 64; i++)
258 4352 s->dv_zigzag[0][i] = s->idsp.idct_permutation[ff_zigzag_direct[i]];
259
260
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 68 times.
 68 if (avctx->lowres){
261 ✗ for (i = 0; i < 64; i++){
262 ✗ int j = ff_dv_zigzag248_direct[i];
263 ✗ s->dv_zigzag[1][i] = s->idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
264 }
265 }else
266 68 memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
267
268 68 s->idct_put[0] = s->idsp.idct_put;
269 68 s->idct_put[1] = ff_simple_idct248_put;
270
271 68 ff_thread_once(&init_static_once, dv_init_static);
272
273 68 return 0;
274 }
275
276 /* decode AC coefficients */
277 32396855 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
278 {
279 32396855 int last_index = gb->size_in_bits;
280 32396855 const uint8_t *scan_table = mb->scan_table;
281 32396855 const uint32_t *factor_table = mb->factor_table;
282 32396855 int pos = mb->pos;
283 32396855 int partial_bit_count = mb->partial_bit_count;
284 int level, run, vlc_len, index;
285
286 32396855 OPEN_READER_NOSIZE(re, gb);
287 32396855 UPDATE_CACHE(re, gb);
288
289 /* if we must parse a partial VLC, we do it here */
290
2/2
✓ Branch 0 taken 7429987 times.
✓ Branch 1 taken 24966868 times.
 32396855 if (partial_bit_count > 0) {
291 7429987 re_cache = re_cache >> partial_bit_count |
292 7429987 mb->partial_bit_buffer;
293 7429987 re_index -= partial_bit_count;
294 7429987 mb->partial_bit_count = 0;
295 }
296
297 /* get the AC coefficients until last_index is reached */
298 for (;;) {
299 216781977 ff_dlog(NULL, "%2d: bits=%04"PRIx32" index=%u\n",
300 pos, SHOW_UBITS(re, gb, 16), re_index);
301 /* our own optimized GET_RL_VLC */
302 249178832 index = NEG_USR32(re_cache, TEX_VLC_BITS);
303 249178832 vlc_len = dv_rl_vlc[index].len8;
304
2/2
✓ Branch 0 taken 19062722 times.
✓ Branch 1 taken 230116110 times.
 249178832 if (vlc_len < 0) {
305 19062722 index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
306 19062722 dv_rl_vlc[index].level;
307 19062722 vlc_len = TEX_VLC_BITS - vlc_len;
308 }
309 249178832 level = dv_rl_vlc[index].level;
310 249178832 run = dv_rl_vlc[index].run;
311
312 /* gotta check if we're still within gb boundaries */
313
2/2
✓ Branch 0 taken 8912757 times.
✓ Branch 1 taken 240266075 times.
 249178832 if (re_index + vlc_len > last_index) {
314 /* should be < 16 bits otherwise a codeword could have been parsed */
315 8912757 mb->partial_bit_count = last_index - re_index;
316 8912757 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
317 8912757 re_index = last_index;
318 8912757 break;
319 }
320 240266075 re_index += vlc_len;
321
322 ff_dlog(NULL, "run=%d level=%d\n", run, level);
323 240266075 pos += run;
324
2/2
✓ Branch 0 taken 23484098 times.
✓ Branch 1 taken 216781977 times.
 240266075 if (pos >= 64)
325 23484098 break;
326
327 216781977 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
328 dv_iweight_bits;
329 216781977 block[scan_table[pos]] = level;
330
331 216781977 UPDATE_CACHE(re, gb);
332 }
333 32396855 CLOSE_READER(re, gb);
334 32396855 mb->pos = pos;
335 32396855 }
336
337 17842657 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
338 {
339 17842657 int bits_left = get_bits_left(gb);
340
2/2
✓ Branch 0 taken 38126372 times.
✓ Branch 1 taken 17842657 times.
 55969029 while (bits_left >= MIN_CACHE_BITS) {
341 38126372 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
342 38126372 bits_left -= MIN_CACHE_BITS;
343 }
344
2/2
✓ Branch 0 taken 17218407 times.
✓ Branch 1 taken 624250 times.
 17842657 if (bits_left > 0)
345 17218407 put_bits(pb, bits_left, get_bits(gb, bits_left));
346 17842657 }
347
348 ✗ static av_always_inline void put_block_8x4(int16_t *block, uint8_t *restrict p, int stride)
349 {
350 int i, j;
351
352 ✗ for (i = 0; i < 4; i++) {
353 ✗ for (j = 0; j < 8; j++)
354 ✗ p[j] = av_clip_uint8(block[j]);
355 ✗ block += 8;
356 ✗ p += stride;
357 }
358 ✗ }
359
360 ✗ static void dv100_idct_put_last_row_field_chroma(const DVDecContext *s, uint8_t *data,
361 int stride, int16_t *blocks)
362 {
363 ✗ s->idsp.idct(blocks + 0*64);
364 ✗ s->idsp.idct(blocks + 1*64);
365
366 ✗ put_block_8x4(blocks+0*64, data, stride<<1);
367 ✗ put_block_8x4(blocks+0*64 + 4*8, data + 8, stride<<1);
368 ✗ put_block_8x4(blocks+1*64, data + stride, stride<<1);
369 ✗ put_block_8x4(blocks+1*64 + 4*8, data + 8 + stride, stride<<1);
370 ✗ }
371
372 ✗ static void dv100_idct_put_last_row_field_luma(const DVDecContext *s, uint8_t *data,
373 int stride, int16_t *blocks)
374 {
375 ✗ s->idsp.idct(blocks + 0*64);
376 ✗ s->idsp.idct(blocks + 1*64);
377 ✗ s->idsp.idct(blocks + 2*64);
378 ✗ s->idsp.idct(blocks + 3*64);
379
380 ✗ put_block_8x4(blocks+0*64, data, stride<<1);
381 ✗ put_block_8x4(blocks+0*64 + 4*8, data + 16, stride<<1);
382 ✗ put_block_8x4(blocks+1*64, data + 8, stride<<1);
383 ✗ put_block_8x4(blocks+1*64 + 4*8, data + 24, stride<<1);
384 ✗ put_block_8x4(blocks+2*64, data + stride, stride<<1);
385 ✗ put_block_8x4(blocks+2*64 + 4*8, data + 16 + stride, stride<<1);
386 ✗ put_block_8x4(blocks+3*64, data + 8 + stride, stride<<1);
387 ✗ put_block_8x4(blocks+3*64 + 4*8, data + 24 + stride, stride<<1);
388 ✗ }
389
390 /* mb_x and mb_y are in units of 8 pixels */
391 652968 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
392 {
393 652968 const DVDecContext *s = avctx->priv_data;
394 652968 DVwork_chunk *work_chunk = arg;
395 int quant, dc, dct_mode, class1, j;
396 int mb_index, mb_x, mb_y, last_index;
397 int y_stride, linesize;
398 int16_t *block, *block1;
399 int c_offset;
400 uint8_t *y_ptr;
401 const uint8_t *buf_ptr;
402 PutBitContext pb, vs_pb;
403 GetBitContext gb;
404 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
405 652968 LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
406 652968 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
407 652968 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
408 652968 const int log2_blocksize = 3 - avctx->lowres;
409 int is_field_mode[5];
410 652968 int vs_bit_buffer_damaged = 0;
411 652968 int mb_bit_buffer_damaged[5] = {0};
412 652968 int retried = 0;
413 int sta;
414
415 av_assert1((((uintptr_t) mb_bit_buffer) & 7) == 0);
416 av_assert1((((uintptr_t) vs_bit_buffer) & 7) == 0);
417
418 652969 retry:
419
420 652969 memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
421
422 /* pass 1: read DC and AC coefficients in blocks */
423 652969 buf_ptr = &s->buf[work_chunk->buf_offset * 80];
424 652969 block1 = &sblock[0][0];
425 652969 mb1 = mb_data;
426 652969 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
427
2/2
✓ Branch 0 taken 3264845 times.
✓ Branch 1 taken 652969 times.
 3917814 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
428 /* skip header */
429 3264845 quant = buf_ptr[3] & 0x0f;
430
1/2
✓ Branch 0 taken 3264845 times.
✗ Branch 1 not taken.
 3264845 if (avctx->error_concealment) {
431
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3264845 times.
 3264845 if ((buf_ptr[3] >> 4) == 0x0E)
432 ✗ vs_bit_buffer_damaged = 1;
433
2/2
✓ Branch 0 taken 652969 times.
✓ Branch 1 taken 2611876 times.
 3264845 if (!mb_index) {
434 652969 sta = buf_ptr[3] >> 4;
435
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2611876 times.
 2611876 } else if (sta != (buf_ptr[3] >> 4))
436 ✗ vs_bit_buffer_damaged = 1;
437 }
438 3264845 buf_ptr += 4;
439 3264845 init_put_bits(&pb, mb_bit_buffer, 80);
440 3264845 mb = mb1;
441 3264845 block = block1;
442 3264845 is_field_mode[mb_index] = 0;
443
2/2
✓ Branch 0 taken 23490570 times.
✓ Branch 1 taken 3264845 times.
 26755415 for (j = 0; j < s->sys->bpm; j++) {
444 23490570 last_index = s->sys->block_sizes[j];
445 23490570 init_get_bits(&gb, buf_ptr, last_index);
446
447 /* get the DC */
448 23490570 dc = get_sbits(&gb, 9);
449 23490570 dct_mode = get_bits1(&gb);
450 23490570 class1 = get_bits(&gb, 2);
451
2/2
✓ Branch 0 taken 15606000 times.
✓ Branch 1 taken 7884570 times.
 23490570 if (DV_PROFILE_IS_HD(s->sys)) {
452 15606000 mb->idct_put = s->idct_put[0];
453 15606000 mb->scan_table = s->dv_zigzag[0];
454
2/2
✓ Branch 0 taken 7803000 times.
✓ Branch 1 taken 7803000 times.
 15606000 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
455 15606000 class1 * 16 * 64 +
456 15606000 quant * 64];
457
3/4
✓ Branch 0 taken 1950750 times.
✓ Branch 1 taken 13655250 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1950750 times.
 15606000 is_field_mode[mb_index] |= !j && dct_mode;
458 } else {
459
3/4
✓ Branch 0 taken 7576 times.
✓ Branch 1 taken 7876994 times.
✓ Branch 2 taken 7576 times.
✗ Branch 3 not taken.
 7884570 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
460 7884570 mb->scan_table = s->dv_zigzag[dct_mode];
461 7884570 mb->factor_table =
462
2/2
✓ Branch 0 taken 2586963 times.
✓ Branch 1 taken 5297607 times.
 7884570 &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
463 7884570 dct_mode * 22 * 64 +
464 7884570 (quant + ff_dv_quant_offset[class1]) * 64];
465 }
466 23490570 dc = dc * 4;
467 /* convert to unsigned because 128 is not added in the
468 * standard IDCT */
469 23490570 dc += 1024;
470 23490570 block[0] = dc;
471 23490570 buf_ptr += last_index >> 3;
472 23490570 mb->pos = 0;
473 23490570 mb->partial_bit_count = 0;
474
475 ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
476 23490570 dv_decode_ac(&gb, mb, block);
477
478 /* write the remaining bits in a new buffer only if the
479 * block is finished */
480
2/2
✓ Branch 0 taken 15622000 times.
✓ Branch 1 taken 7868570 times.
 23490570 if (mb->pos >= 64)
481 15622000 bit_copy(&pb, &gb);
482
3/4
✓ Branch 0 taken 15622000 times.
✓ Branch 1 taken 7868570 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 15622000 times.
 23490570 if (mb->pos >= 64 && mb->pos < 127)
483 ✗ vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
484
485 23490570 block += 64;
486 23490570 mb++;
487 }
488
489
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3264844 times.
 3264845 if (mb_bit_buffer_damaged[mb_index] > 0)
490 1 continue;
491
492 /* pass 2: we can do it just after */
493 ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
494 3264844 block = block1;
495 3264844 mb = mb1;
496 3264844 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
497 3264844 put_bits32(&pb, 0); // padding must be zeroed
498 3264844 flush_put_bits(&pb);
499
2/2
✓ Branch 0 taken 18776305 times.
✓ Branch 1 taken 2220657 times.
 20996962 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
500
4/4
✓ Branch 0 taken 5261291 times.
✓ Branch 1 taken 13515014 times.
✓ Branch 3 taken 4668770 times.
✓ Branch 4 taken 592521 times.
 18776305 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
501 4668770 dv_decode_ac(&gb, mb, block);
502 /* if still not finished, no need to parse other blocks */
503
2/2
✓ Branch 0 taken 1044187 times.
✓ Branch 1 taken 3624583 times.
 4668770 if (mb->pos < 64)
504 1044187 break;
505
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 3624581 times.
 3624583 if (mb->pos < 127)
506 2 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
507 }
508 }
509 /* all blocks are finished, so the extra bytes can be used at
510 * the video segment level */
511
2/2
✓ Branch 0 taken 2220657 times.
✓ Branch 1 taken 1044187 times.
 3264844 if (j >= s->sys->bpm)
512 2220657 bit_copy(&vs_pb, &gb);
513 }
514
515 /* we need a pass over the whole video segment */
516 ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
517 652969 block = &sblock[0][0];
518 652969 mb = mb_data;
519 652969 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
520 652969 put_bits32(&vs_pb, 0); // padding must be zeroed
521 652969 flush_put_bits(&vs_pb);
522
2/2
✓ Branch 0 taken 3264845 times.
✓ Branch 1 taken 652969 times.
 3917814 for (mb_index = 0; mb_index < 5; mb_index++) {
523
2/2
✓ Branch 0 taken 23490570 times.
✓ Branch 1 taken 3264845 times.
 26755415 for (j = 0; j < s->sys->bpm; j++) {
524
5/6
✓ Branch 0 taken 4243987 times.
✓ Branch 1 taken 19246583 times.
✓ Branch 3 taken 4237515 times.
✓ Branch 4 taken 6472 times.
✓ Branch 5 taken 4237515 times.
✗ Branch 6 not taken.
 23490570 if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
525 ff_dlog(avctx, "start %d:%d\n", mb_index, j);
526 4237515 dv_decode_ac(&gb, mb, block);
527 }
528
529
4/4
✓ Branch 0 taken 23484098 times.
✓ Branch 1 taken 6472 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 23484096 times.
 23490570 if (mb->pos >= 64 && mb->pos < 127) {
530 2 av_log(avctx, AV_LOG_ERROR,
531 2 "AC EOB marker is absent pos=%d\n", mb->pos);
532 2 vs_bit_buffer_damaged = 1;
533 }
534 23490570 block += 64;
535 23490570 mb++;
536 }
537 }
538
4/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 652967 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
 652969 if (vs_bit_buffer_damaged && !retried) {
539 1 av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
540 1 retried = 1;
541 1 goto retry;
542 }
543
544 /* compute idct and place blocks */
545 652968 block = &sblock[0][0];
546 652968 mb = mb_data;
547
2/2
✓ Branch 0 taken 3264840 times.
✓ Branch 1 taken 652968 times.
 3917808 for (mb_index = 0; mb_index < 5; mb_index++) {
548 3264840 dv_calculate_mb_xy(s->sys, s->buf, work_chunk, mb_index, &mb_x, &mb_y);
549
550 /* idct_put'ting luminance */
551
2/2
✓ Branch 0 taken 2842020 times.
✓ Branch 1 taken 422820 times.
 3264840 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
552
4/4
✓ Branch 0 taken 304830 times.
✓ Branch 1 taken 2537190 times.
✓ Branch 2 taken 298056 times.
✓ Branch 3 taken 6774 times.
 2842020 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
553
4/4
✓ Branch 0 taken 1950750 times.
✓ Branch 1 taken 884496 times.
✓ Branch 2 taken 1940400 times.
✓ Branch 3 taken 10350 times.
 2835246 (s->sys->height >= 720 && mb_y != 134)) {
554 2369994 y_stride = (s->frame->linesize[0] <<
555 2369994 ((!is_field_mode[mb_index]) * log2_blocksize));
556 } else {
557 894846 y_stride = (2 << log2_blocksize);
558 }
559 3264840 y_ptr = s->frame->data[0] +
560 3264840 ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
561
3/4
✓ Branch 0 taken 10350 times.
✓ Branch 1 taken 3254490 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10350 times.
 3264840 if (mb_y == 134 && is_field_mode[mb_index]) {
562 ✗ dv100_idct_put_last_row_field_luma(s, y_ptr, s->frame->linesize[0], block);
563 } else {
564 3264840 linesize = s->frame->linesize[0] << is_field_mode[mb_index];
565 3264840 mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
566
2/2
✓ Branch 0 taken 586440 times.
✓ Branch 1 taken 2678400 times.
 3264840 if (s->sys->video_stype == 4) { /* SD 422 */
567 586440 mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
568 } else {
569 2678400 mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
570 2678400 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
571 2678400 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
572 }
573 }
574 3264840 mb += 4;
575 3264840 block += 4 * 64;
576
577 /* idct_put'ting chrominance */
578 6529680 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
579
2/2
✓ Branch 0 taken 304830 times.
✓ Branch 1 taken 2960010 times.
 3264840 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
580
2/2
✓ Branch 0 taken 6529680 times.
✓ Branch 1 taken 3264840 times.
 9794520 for (j = 2; j; j--) {
581 6529680 uint8_t *c_ptr = s->frame->data[j] + c_offset;
582
4/4
✓ Branch 0 taken 609660 times.
✓ Branch 1 taken 5920020 times.
✓ Branch 2 taken 13548 times.
✓ Branch 3 taken 596112 times.
 6529680 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
583 uint64_t aligned_pixels[64 / 8];
584 13548 uint8_t *pixels = (uint8_t *) aligned_pixels;
585 uint8_t *c_ptr1, *ptr1;
586 int x, y;
587 13548 mb->idct_put(pixels, 8, block);
588
2/2
✓ Branch 0 taken 108384 times.
✓ Branch 1 taken 13548 times.
 121932 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
589 108384 ptr1 = pixels + ((1 << (log2_blocksize))>>1);
590 108384 c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
591
2/2
✓ Branch 0 taken 433536 times.
✓ Branch 1 taken 108384 times.
 541920 for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
592 433536 c_ptr[x] = pixels[x];
593 433536 c_ptr1[x] = ptr1[x];
594 }
595 }
596 13548 block += 64;
597 13548 mb++;
598 } else {
599
2/2
✓ Branch 0 taken 20700 times.
✓ Branch 1 taken 6495432 times.
 6516132 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
600 6495432 s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
601
3/4
✓ Branch 0 taken 20700 times.
✓ Branch 1 taken 6495432 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 20700 times.
 6516132 if (mb_y == 134 && is_field_mode[mb_index]) {
602 ✗ dv100_idct_put_last_row_field_chroma(s, c_ptr, s->frame->linesize[j], block);
603 ✗ mb += 2;
604 ✗ block += 2*64;
605 } else {
606 6516132 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
607 6516132 (mb++)->idct_put(c_ptr, linesize, block);
608 6516132 block += 64;
609
2/2
✓ Branch 0 taken 3901500 times.
✓ Branch 1 taken 2614632 times.
 6516132 if (s->sys->bpm == 8) {
610 3901500 (mb++)->idct_put(c_ptr + y_stride, linesize, block);
611 3901500 block += 64;
612 }
613 }
614 }
615 }
616 }
617 652968 return 0;
618 }
619
620 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
621 * 144000 bytes for PAL - or twice those for 50Mbps) */
622 1072 static int dvvideo_decode_frame(AVCodecContext *avctx, AVFrame *frame,
623 int *got_frame, AVPacket *avpkt)
624 {
625 1072 uint8_t *buf = avpkt->data;
626 1072 int buf_size = avpkt->size;
627 1072 DVDecContext *s = avctx->priv_data;
628 const uint8_t *vsc_pack;
629 int apt, is16_9, ret;
630 const AVDVProfile *sys;
631
632 1072 sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
633
2/4
✓ Branch 0 taken 1072 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1072 times.
 1072 if (!sys || buf_size < sys->frame_size) {
634 ✗ av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
635 ✗ return -1; /* NOTE: we only accept several full frames */
636 }
637
638
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 1009 times.
 1072 if (sys != s->sys) {
639 63 ff_dv_init_dynamic_tables(s->work_chunks, sys);
640 63 dv_init_weight_tables(s, sys);
641 63 s->sys = sys;
642 }
643
644 1072 s->frame = frame;
645 1072 avctx->pix_fmt = s->sys->pix_fmt;
646 1072 avctx->framerate = av_inv_q(s->sys->time_base);
647 1072 avctx->bit_rate = av_rescale_q(s->sys->frame_size,
648 1072 (AVRational) { 8, 1 },
649 1072 s->sys->time_base);
650
651 1072 ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
652
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1072 times.
 1072 if (ret < 0)
653 ✗ return ret;
654
655 /* Determine the codec's sample_aspect ratio from the packet */
656 1072 vsc_pack = buf + 80 * 5 + 48 + 5;
657
1/2
✓ Branch 0 taken 1072 times.
✗ Branch 1 not taken.
 1072 if (*vsc_pack == DV_VIDEO_CONTROL) {
658 1072 apt = buf[4] & 0x07;
659
4/4
✓ Branch 0 taken 610 times.
✓ Branch 1 taken 462 times.
✓ Branch 2 taken 272 times.
✓ Branch 3 taken 338 times.
 1344 is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
660
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 272 times.
 272 (!apt && (vsc_pack[2] & 0x07) == 0x07);
661 1072 ff_set_sar(avctx, s->sys->sar[is16_9]);
662 }
663
664
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1072 times.
 1072 if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
665 ✗ return ret;
666
667 /* Determine the codec's field order from the packet */
668
1/2
✓ Branch 0 taken 1072 times.
✗ Branch 1 not taken.
 1072 if ( *vsc_pack == DV_VIDEO_CONTROL ) {
669
2/2
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 867 times.
 1072 if (avctx->height == 720) {
670 205 frame->flags &= ~AV_FRAME_FLAG_INTERLACED;
671 205 frame->flags &= ~AV_FRAME_FLAG_TOP_FIELD_FIRST;
672
2/2
✓ Branch 0 taken 230 times.
✓ Branch 1 taken 637 times.
 867 } else if (avctx->height == 1080) {
673 230 frame->flags |= AV_FRAME_FLAG_INTERLACED;
674 230 frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * ((vsc_pack[3] & 0x40) == 0x40);
675 } else {
676 637 frame->flags |= AV_FRAME_FLAG_INTERLACED * ((vsc_pack[3] & 0x10) == 0x10);
677
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 637 times.
 637 frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * !(vsc_pack[3] & 0x40);
678 }
679 }
680
681 1072 s->buf = buf;
682 1072 avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
683 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
684
685 /* return image */
686 1072 *got_frame = 1;
687
688 1072 return s->sys->frame_size;
689 }
690
691 const FFCodec ff_dvvideo_decoder = {
692 .p.name = "dvvideo",
693 CODEC_LONG_NAME("DV (Digital Video)"),
694 .p.type = AVMEDIA_TYPE_VIDEO,
695 .p.id = AV_CODEC_ID_DVVIDEO,
696 .priv_data_size = sizeof(DVDecContext),
697 .init = dvvideo_decode_init,
698 FF_CODEC_DECODE_CB(dvvideo_decode_frame),
699 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
700 .p.max_lowres = 3,
701 };
702