FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/dvdec.c
Date: 2025-11-10 16:28:23
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 35 static av_cold void dv_init_static(void)
152 {
153 35 VLCElem vlc_buf[FF_ARRAY_ELEMS(dv_rl_vlc)] = { 0 };
154 35 VLC dv_vlc = { .table = vlc_buf, .table_allocated = FF_ARRAY_ELEMS(vlc_buf) };
155 35 const unsigned offset = FF_ARRAY_ELEMS(dv_rl_vlc) - (2 * NB_DV_VLC - NB_DV_ZERO_LEVEL_ENTRIES);
156 35 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 14315 times.
✓ Branch 1 taken 35 times.
 14350 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
161 14315 tmp[j].len8 = ff_dv_vlc_len[i];
162 14315 tmp[j].run = ff_dv_vlc_run[i];
163 14315 tmp[j].level = ff_dv_vlc_level[i];
164
165
2/2
✓ Branch 0 taken 11795 times.
✓ Branch 1 taken 2520 times.
 14315 if (ff_dv_vlc_level[i]) {
166 11795 tmp[j].len8++;
167
168 11795 j++;
169 11795 tmp[j].len8 = ff_dv_vlc_len[i] + 1;
170 11795 tmp[j].run = ff_dv_vlc_run[i];
171 11795 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 35 ff_vlc_init_from_lengths(&dv_vlc, TEX_VLC_BITS, j,
178 35 &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 58240 times.
✓ Branch 1 taken 35 times.
 58275 for (int i = 0; i < dv_vlc.table_size; i++) {
183 58240 int code = dv_vlc.table[i].sym;
184 58240 int len = dv_vlc.table[i].len;
185 int level, run;
186
187
2/2
✓ Branch 0 taken 1120 times.
✓ Branch 1 taken 57120 times.
 58240 if (len < 0) { // more bits needed
188 1120 run = 0;
189 1120 level = code;
190 } else {
191 av_assert1(i <= code + offset);
192 57120 run = tmp[code].run + 1;
193 57120 level = tmp[code].level;
194 }
195 58240 dv_rl_vlc[i].len8 = len;
196 58240 dv_rl_vlc[i].level = level;
197 58240 dv_rl_vlc[i].run = run;
198 }
199 35 }
200
201 60 static void dv_init_weight_tables(DVDecContext *ctx, const AVDVProfile *d)
202 {
203 int j, i, c, s;
204 60 uint32_t *factor1 = &ctx->idct_factor[0],
205
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 41 times.
 60 *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
206
207
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 41 times.
 60 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 41 const uint16_t *iweight1 = &dv_iweight_88[0];
234
2/2
✓ Branch 0 taken 82 times.
✓ Branch 1 taken 41 times.
 123 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
235
2/2
✓ Branch 0 taken 1804 times.
✓ Branch 1 taken 82 times.
 1886 for (s = 0; s < 22; s++) {
236
2/2
✓ Branch 0 taken 7216 times.
✓ Branch 1 taken 1804 times.
 9020 for (i = c = 0; c < 4; c++) {
237
2/2
✓ Branch 0 taken 115456 times.
✓ Branch 1 taken 7216 times.
 122672 for (; i < dv_quant_areas[c]; i++) {
238 115456 *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
239 115456 *factor2++ = (*factor1++) << 1;
240 }
241 }
242 }
243 }
244 }
245 60 }
246
247 62 static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
248 {
249 static AVOnce init_static_once = AV_ONCE_INIT;
250 62 DVDecContext *s = avctx->priv_data;
251 int i;
252
253 62 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
254
255 62 ff_idctdsp_init(&s->idsp, avctx);
256
257
2/2
✓ Branch 0 taken 3968 times.
✓ Branch 1 taken 62 times.
 4030 for (i = 0; i < 64; i++)
258 3968 s->dv_zigzag[0][i] = s->idsp.idct_permutation[ff_zigzag_direct[i]];
259
260
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 62 times.
 62 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 62 memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
267
268 62 s->idct_put[0] = s->idsp.idct_put;
269 62 s->idct_put[1] = ff_simple_idct248_put;
270
271 62 ff_thread_once(&init_static_once, dv_init_static);
272
273 62 return 0;
274 }
275
276 /* decode AC coefficients */
277 32370770 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
278 {
279 32370770 int last_index = gb->size_in_bits;
280 32370770 const uint8_t *scan_table = mb->scan_table;
281 32370770 const uint32_t *factor_table = mb->factor_table;
282 32370770 int pos = mb->pos;
283 32370770 int partial_bit_count = mb->partial_bit_count;
284 int level, run, vlc_len, index;
285
286 32370770 OPEN_READER_NOSIZE(re, gb);
287 32370770 UPDATE_CACHE(re, gb);
288
289 /* if we must parse a partial VLC, we do it here */
290
2/2
✓ Branch 0 taken 7428217 times.
✓ Branch 1 taken 24942553 times.
 32370770 if (partial_bit_count > 0) {
291 7428217 re_cache = re_cache >> partial_bit_count |
292 7428217 mb->partial_bit_buffer;
293 7428217 re_index -= partial_bit_count;
294 7428217 mb->partial_bit_count = 0;
295 }
296
297 /* get the AC coefficients until last_index is reached */
298 for (;;) {
299 216755727 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 249126497 index = NEG_USR32(re_cache, TEX_VLC_BITS);
303 249126497 vlc_len = dv_rl_vlc[index].len8;
304
2/2
✓ Branch 0 taken 19048052 times.
✓ Branch 1 taken 230078445 times.
 249126497 if (vlc_len < 0) {
305 19048052 index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
306 19048052 dv_rl_vlc[index].level;
307 19048052 vlc_len = TEX_VLC_BITS - vlc_len;
308 }
309 249126497 level = dv_rl_vlc[index].level;
310 249126497 run = dv_rl_vlc[index].run;
311
312 /* gotta check if we're still within gb boundaries */
313
2/2
✓ Branch 0 taken 8910972 times.
✓ Branch 1 taken 240215525 times.
 249126497 if (re_index + vlc_len > last_index) {
314 /* should be < 16 bits otherwise a codeword could have been parsed */
315 8910972 mb->partial_bit_count = last_index - re_index;
316 8910972 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
317 8910972 re_index = last_index;
318 8910972 break;
319 }
320 240215525 re_index += vlc_len;
321
322 ff_dlog(NULL, "run=%d level=%d\n", run, level);
323 240215525 pos += run;
324
2/2
✓ Branch 0 taken 23459798 times.
✓ Branch 1 taken 216755727 times.
 240215525 if (pos >= 64)
325 23459798 break;
326
327 216755727 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
328 dv_iweight_bits;
329 216755727 block[scan_table[pos]] = level;
330
331 216755727 UPDATE_CACHE(re, gb);
332 }
333 32370770 CLOSE_READER(re, gb);
334 32370770 mb->pos = pos;
335 32370770 }
336
337 17816092 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
338 {
339 17816092 int bits_left = get_bits_left(gb);
340
2/2
✓ Branch 0 taken 37998362 times.
✓ Branch 1 taken 17816092 times.
 55814454 while (bits_left >= MIN_CACHE_BITS) {
341 37998362 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
342 37998362 bits_left -= MIN_CACHE_BITS;
343 }
344
2/2
✓ Branch 0 taken 17191992 times.
✓ Branch 1 taken 624100 times.
 17816092 if (bits_left > 0)
345 17191992 put_bits(pb, bits_left, get_bits(gb, bits_left));
346 17816092 }
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 652158 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
392 {
393 652158 const DVDecContext *s = avctx->priv_data;
394 652158 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 652158 LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
406 652158 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
407 652158 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
408 652158 const int log2_blocksize = 3 - avctx->lowres;
409 int is_field_mode[5];
410 652158 int vs_bit_buffer_damaged = 0;
411 652158 int mb_bit_buffer_damaged[5] = {0};
412 652158 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 652159 retry:
419
420 652159 memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
421
422 /* pass 1: read DC and AC coefficients in blocks */
423 652159 buf_ptr = &s->buf[work_chunk->buf_offset * 80];
424 652159 block1 = &sblock[0][0];
425 652159 mb1 = mb_data;
426 652159 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
427
2/2
✓ Branch 0 taken 3260795 times.
✓ Branch 1 taken 652159 times.
 3912954 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
428 /* skip header */
429 3260795 quant = buf_ptr[3] & 0x0f;
430
1/2
✓ Branch 0 taken 3260795 times.
✗ Branch 1 not taken.
 3260795 if (avctx->error_concealment) {
431
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3260795 times.
 3260795 if ((buf_ptr[3] >> 4) == 0x0E)
432 ✗ vs_bit_buffer_damaged = 1;
433
2/2
✓ Branch 0 taken 652159 times.
✓ Branch 1 taken 2608636 times.
 3260795 if (!mb_index) {
434 652159 sta = buf_ptr[3] >> 4;
435
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2608636 times.
 2608636 } else if (sta != (buf_ptr[3] >> 4))
436 ✗ vs_bit_buffer_damaged = 1;
437 }
438 3260795 buf_ptr += 4;
439 3260795 init_put_bits(&pb, mb_bit_buffer, 80);
440 3260795 mb = mb1;
441 3260795 block = block1;
442 3260795 is_field_mode[mb_index] = 0;
443
2/2
✓ Branch 0 taken 23466270 times.
✓ Branch 1 taken 3260795 times.
 26727065 for (j = 0; j < s->sys->bpm; j++) {
444 23466270 last_index = s->sys->block_sizes[j];
445 23466270 init_get_bits(&gb, buf_ptr, last_index);
446
447 /* get the DC */
448 23466270 dc = get_sbits(&gb, 9);
449 23466270 dct_mode = get_bits1(&gb);
450 23466270 class1 = get_bits(&gb, 2);
451
2/2
✓ Branch 0 taken 15606000 times.
✓ Branch 1 taken 7860270 times.
 23466270 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 7852694 times.
✓ Branch 2 taken 7576 times.
✗ Branch 3 not taken.
 7860270 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
460 7860270 mb->scan_table = s->dv_zigzag[dct_mode];
461 7860270 mb->factor_table =
462
2/2
✓ Branch 0 taken 2565513 times.
✓ Branch 1 taken 5294757 times.
 7860270 &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
463 7860270 dct_mode * 22 * 64 +
464 7860270 (quant + ff_dv_quant_offset[class1]) * 64];
465 }
466 23466270 dc = dc * 4;
467 /* convert to unsigned because 128 is not added in the
468 * standard IDCT */
469 23466270 dc += 1024;
470 23466270 block[0] = dc;
471 23466270 buf_ptr += last_index >> 3;
472 23466270 mb->pos = 0;
473 23466270 mb->partial_bit_count = 0;
474
475 ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
476 23466270 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 15599485 times.
✓ Branch 1 taken 7866785 times.
 23466270 if (mb->pos >= 64)
481 15599485 bit_copy(&pb, &gb);
482
3/4
✓ Branch 0 taken 15599485 times.
✓ Branch 1 taken 7866785 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 15599485 times.
 23466270 if (mb->pos >= 64 && mb->pos < 127)
483 ✗ vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
484
485 23466270 block += 64;
486 23466270 mb++;
487 }
488
489
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3260794 times.
 3260795 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 3260794 block = block1;
495 3260794 mb = mb1;
496 3260794 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
497 3260794 put_bits32(&pb, 0); // padding must be zeroed
498 3260794 flush_put_bits(&pb);
499
2/2
✓ Branch 0 taken 18752005 times.
✓ Branch 1 taken 2216607 times.
 20968612 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
500
4/4
✓ Branch 0 taken 5259506 times.
✓ Branch 1 taken 13492499 times.
✓ Branch 3 taken 4666985 times.
✓ Branch 4 taken 592521 times.
 18752005 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
501 4666985 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 3622798 times.
 4666985 if (mb->pos < 64)
504 1044187 break;
505
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 3622796 times.
 3622798 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 2216607 times.
✓ Branch 1 taken 1044187 times.
 3260794 if (j >= s->sys->bpm)
512 2216607 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 652159 block = &sblock[0][0];
518 652159 mb = mb_data;
519 652159 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
520 652159 put_bits32(&vs_pb, 0); // padding must be zeroed
521 652159 flush_put_bits(&vs_pb);
522
2/2
✓ Branch 0 taken 3260795 times.
✓ Branch 1 taken 652159 times.
 3912954 for (mb_index = 0; mb_index < 5; mb_index++) {
523
2/2
✓ Branch 0 taken 23466270 times.
✓ Branch 1 taken 3260795 times.
 26727065 for (j = 0; j < s->sys->bpm; j++) {
524
5/6
✓ Branch 0 taken 4243987 times.
✓ Branch 1 taken 19222283 times.
✓ Branch 3 taken 4237515 times.
✓ Branch 4 taken 6472 times.
✓ Branch 5 taken 4237515 times.
✗ Branch 6 not taken.
 23466270 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 23459798 times.
✓ Branch 1 taken 6472 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 23459796 times.
 23466270 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 23466270 block += 64;
535 23466270 mb++;
536 }
537 }
538
4/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 652157 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
 652159 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 652158 block = &sblock[0][0];
546 652158 mb = mb_data;
547
2/2
✓ Branch 0 taken 3260790 times.
✓ Branch 1 taken 652158 times.
 3912948 for (mb_index = 0; mb_index < 5; mb_index++) {
548 3260790 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 2837970 times.
✓ Branch 1 taken 422820 times.
 3260790 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
552
4/4
✓ Branch 0 taken 300780 times.
✓ Branch 1 taken 2537190 times.
✓ Branch 2 taken 294096 times.
✓ Branch 3 taken 6684 times.
 2837970 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
553
4/4
✓ Branch 0 taken 1950750 times.
✓ Branch 1 taken 880536 times.
✓ Branch 2 taken 1940400 times.
✓ Branch 3 taken 10350 times.
 2831286 (s->sys->height >= 720 && mb_y != 134)) {
554 2369904 y_stride = (s->frame->linesize[0] <<
555 2369904 ((!is_field_mode[mb_index]) * log2_blocksize));
556 } else {
557 890886 y_stride = (2 << log2_blocksize);
558 }
559 3260790 y_ptr = s->frame->data[0] +
560 3260790 ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
561
3/4
✓ Branch 0 taken 10350 times.
✓ Branch 1 taken 3250440 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10350 times.
 3260790 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 3260790 linesize = s->frame->linesize[0] << is_field_mode[mb_index];
565 3260790 mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
566
2/2
✓ Branch 0 taken 586440 times.
✓ Branch 1 taken 2674350 times.
 3260790 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 2674350 mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
570 2674350 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
571 2674350 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
572 }
573 }
574 3260790 mb += 4;
575 3260790 block += 4 * 64;
576
577 /* idct_put'ting chrominance */
578 6521580 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
579
2/2
✓ Branch 0 taken 300780 times.
✓ Branch 1 taken 2960010 times.
 3260790 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
580
2/2
✓ Branch 0 taken 6521580 times.
✓ Branch 1 taken 3260790 times.
 9782370 for (j = 2; j; j--) {
581 6521580 uint8_t *c_ptr = s->frame->data[j] + c_offset;
582
4/4
✓ Branch 0 taken 601560 times.
✓ Branch 1 taken 5920020 times.
✓ Branch 2 taken 13368 times.
✓ Branch 3 taken 588192 times.
 6521580 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
583 uint64_t aligned_pixels[64 / 8];
584 13368 uint8_t *pixels = (uint8_t *) aligned_pixels;
585 uint8_t *c_ptr1, *ptr1;
586 int x, y;
587 13368 mb->idct_put(pixels, 8, block);
588
2/2
✓ Branch 0 taken 106944 times.
✓ Branch 1 taken 13368 times.
 120312 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
589 106944 ptr1 = pixels + ((1 << (log2_blocksize))>>1);
590 106944 c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
591
2/2
✓ Branch 0 taken 427776 times.
✓ Branch 1 taken 106944 times.
 534720 for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
592 427776 c_ptr[x] = pixels[x];
593 427776 c_ptr1[x] = ptr1[x];
594 }
595 }
596 13368 block += 64;
597 13368 mb++;
598 } else {
599
2/2
✓ Branch 0 taken 20700 times.
✓ Branch 1 taken 6487512 times.
 6508212 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
600 6487512 s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
601
3/4
✓ Branch 0 taken 20700 times.
✓ Branch 1 taken 6487512 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 20700 times.
 6508212 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 6508212 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
607 6508212 (mb++)->idct_put(c_ptr, linesize, block);
608 6508212 block += 64;
609
2/2
✓ Branch 0 taken 3901500 times.
✓ Branch 1 taken 2606712 times.
 6508212 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 652158 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 1069 static int dvvideo_decode_frame(AVCodecContext *avctx, AVFrame *frame,
623 int *got_frame, AVPacket *avpkt)
624 {
625 1069 uint8_t *buf = avpkt->data;
626 1069 int buf_size = avpkt->size;
627 1069 DVDecContext *s = avctx->priv_data;
628 const uint8_t *vsc_pack;
629 int apt, is16_9, ret;
630 const AVDVProfile *sys;
631
632 1069 sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
633
2/4
✓ Branch 0 taken 1069 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1069 times.
 1069 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 60 times.
✓ Branch 1 taken 1009 times.
 1069 if (sys != s->sys) {
639 60 ff_dv_init_dynamic_tables(s->work_chunks, sys);
640 60 dv_init_weight_tables(s, sys);
641 60 s->sys = sys;
642 }
643
644 1069 s->frame = frame;
645 1069 avctx->pix_fmt = s->sys->pix_fmt;
646 1069 avctx->framerate = av_inv_q(s->sys->time_base);
647 1069 avctx->bit_rate = av_rescale_q(s->sys->frame_size,
648 1069 (AVRational) { 8, 1 },
649 1069 s->sys->time_base);
650
651 1069 ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
652
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1069 times.
 1069 if (ret < 0)
653 ✗ return ret;
654
655 /* Determine the codec's sample_aspect ratio from the packet */
656 1069 vsc_pack = buf + 80 * 5 + 48 + 5;
657
1/2
✓ Branch 0 taken 1069 times.
✗ Branch 1 not taken.
 1069 if (*vsc_pack == DV_VIDEO_CONTROL) {
658 1069 apt = buf[4] & 0x07;
659
4/4
✓ Branch 0 taken 607 times.
✓ Branch 1 taken 462 times.
✓ Branch 2 taken 269 times.
✓ Branch 3 taken 338 times.
 1338 is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
660
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 269 times.
 269 (!apt && (vsc_pack[2] & 0x07) == 0x07);
661 1069 ff_set_sar(avctx, s->sys->sar[is16_9]);
662 }
663
664
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1069 times.
 1069 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 1069 times.
✗ Branch 1 not taken.
 1069 if ( *vsc_pack == DV_VIDEO_CONTROL ) {
669
2/2
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 864 times.
 1069 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 634 times.
 864 } 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 634 frame->flags |= AV_FRAME_FLAG_INTERLACED * ((vsc_pack[3] & 0x10) == 0x10);
677
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 634 times.
 634 frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * !(vsc_pack[3] & 0x40);
678 }
679 }
680
681 1069 s->buf = buf;
682 1069 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 1069 *got_frame = 1;
687
688 1069 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