FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/dvdec.c
Date: 2022-12-09 07:38:14
Exec Total Coverage
Lines: 288 330 87.3%
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 34 static av_cold void dv_init_static(void)
152 {
153 34 VLCElem vlc_buf[FF_ARRAY_ELEMS(dv_rl_vlc)] = { 0 };
154 34 VLC dv_vlc = { .table = vlc_buf, .table_allocated = FF_ARRAY_ELEMS(vlc_buf) };
155 34 const unsigned offset = FF_ARRAY_ELEMS(dv_rl_vlc) - (2 * NB_DV_VLC - NB_DV_ZERO_LEVEL_ENTRIES);
156 34 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 13906 times.
✓ Branch 1 taken 34 times.
13940 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
161 13906 tmp[j].len = ff_dv_vlc_len[i];
162 13906 tmp[j].run = ff_dv_vlc_run[i];
163 13906 tmp[j].level = ff_dv_vlc_level[i];
164
165
2/2
✓ Branch 0 taken 11458 times.
✓ Branch 1 taken 2448 times.
13906 if (ff_dv_vlc_level[i]) {
166 11458 tmp[j].len++;
167
168 11458 j++;
169 11458 tmp[j].len = ff_dv_vlc_len[i] + 1;
170 11458 tmp[j].run = ff_dv_vlc_run[i];
171 11458 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 34 ff_init_vlc_from_lengths(&dv_vlc, TEX_VLC_BITS, j,
178 34 &tmp[0].len, sizeof(tmp[0]),
179 NULL, 0, 0, 0, INIT_VLC_USE_NEW_STATIC, NULL);
180 av_assert1(dv_vlc.table_size == 1664);
181
182
2/2
✓ Branch 0 taken 56576 times.
✓ Branch 1 taken 34 times.
56610 for (int i = 0; i < dv_vlc.table_size; i++) {
183 56576 int code = dv_vlc.table[i].sym;
184 56576 int len = dv_vlc.table[i].len;
185 int level, run;
186
187
2/2
✓ Branch 0 taken 1088 times.
✓ Branch 1 taken 55488 times.
56576 if (len < 0) { // more bits needed
188 1088 run = 0;
189 1088 level = code;
190 } else {
191 av_assert1(i <= code + offset);
192 55488 run = tmp[code].run + 1;
193 55488 level = tmp[code].level;
194 }
195 56576 dv_rl_vlc[i].len = len;
196 56576 dv_rl_vlc[i].level = level;
197 56576 dv_rl_vlc[i].run = run;
198 }
199 34 }
200
201 58 static void dv_init_weight_tables(DVDecContext *ctx, const AVDVProfile *d)
202 {
203 int j, i, c, s;
204 58 uint32_t *factor1 = &ctx->idct_factor[0],
205
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 41 times.
58 *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
206
207
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 41 times.
58 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 8 times.
17 if (d->height == 720) {
217 9 iweight1 = &dv_iweight_720_y[0];
218 9 iweight2 = &dv_iweight_720_c[0];
219 } else {
220 8 iweight1 = &dv_iweight_1080_y[0];
221 8 iweight2 = &dv_iweight_1080_c[0];
222 }
223
2/2
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 17 times.
85 for (c = 0; c < 4; c++) {
224
2/2
✓ Branch 0 taken 1088 times.
✓ Branch 1 taken 68 times.
1156 for (s = 0; s < 16; s++) {
225
2/2
✓ Branch 0 taken 69632 times.
✓ Branch 1 taken 1088 times.
70720 for (i = 0; i < 64; i++) {
226 69632 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
227 69632 *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 58 }
246
247 60 static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
248 {
249 static AVOnce init_static_once = AV_ONCE_INIT;
250 60 DVDecContext *s = avctx->priv_data;
251 int i;
252
253 60 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
254
255 60 ff_idctdsp_init(&s->idsp, avctx);
256
257
2/2
✓ Branch 0 taken 3840 times.
✓ Branch 1 taken 60 times.
3900 for (i = 0; i < 64; i++)
258 3840 s->dv_zigzag[0][i] = s->idsp.idct_permutation[ff_zigzag_direct[i]];
259
260
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 60 times.
60 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 60 memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
267
268 60 s->idct_put[0] = s->idsp.idct_put;
269 60 s->idct_put[1] = ff_simple_idct248_put;
270
271 60 ff_thread_once(&init_static_once, dv_init_static);
272
273 60 return 0;
274 }
275
276 /* decode AC coefficients */
277 30597572 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
278 {
279 30597572 int last_index = gb->size_in_bits;
280 30597572 const uint8_t *scan_table = mb->scan_table;
281 30597572 const uint32_t *factor_table = mb->factor_table;
282 30597572 int pos = mb->pos;
283 30597572 int partial_bit_count = mb->partial_bit_count;
284 int level, run, vlc_len, index;
285
286 30597572 OPEN_READER_NOSIZE(re, gb);
287 30597572 UPDATE_CACHE(re, gb);
288
289 /* if we must parse a partial VLC, we do it here */
290
2/2
✓ Branch 0 taken 7006249 times.
✓ Branch 1 taken 23591323 times.
30597572 if (partial_bit_count > 0) {
291 7006249 re_cache = re_cache >> partial_bit_count |
292 7006249 mb->partial_bit_buffer;
293 7006249 re_index -= partial_bit_count;
294 7006249 mb->partial_bit_count = 0;
295 }
296
297 /* get the AC coefficients until last_index is reached */
298 for (;;) {
299 205743711 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 236341283 index = NEG_USR32(re_cache, TEX_VLC_BITS);
303 236341283 vlc_len = dv_rl_vlc[index].len;
304
2/2
✓ Branch 0 taken 18065775 times.
✓ Branch 1 taken 218275508 times.
236341283 if (vlc_len < 0) {
305 18065775 index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
306 18065775 dv_rl_vlc[index].level;
307 18065775 vlc_len = TEX_VLC_BITS - vlc_len;
308 }
309 236341283 level = dv_rl_vlc[index].level;
310 236341283 run = dv_rl_vlc[index].run;
311
312 /* gotta check if we're still within gb boundaries */
313
2/2
✓ Branch 0 taken 8401374 times.
✓ Branch 1 taken 227939909 times.
236341283 if (re_index + vlc_len > last_index) {
314 /* should be < 16 bits otherwise a codeword could have been parsed */
315 8401374 mb->partial_bit_count = last_index - re_index;
316 8401374 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
317 8401374 re_index = last_index;
318 8401374 break;
319 }
320 227939909 re_index += vlc_len;
321
322 ff_dlog(NULL, "run=%d level=%d\n", run, level);
323 227939909 pos += run;
324
2/2
✓ Branch 0 taken 22196198 times.
✓ Branch 1 taken 205743711 times.
227939909 if (pos >= 64)
325 22196198 break;
326
327 205743711 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
328 dv_iweight_bits;
329 205743711 block[scan_table[pos]] = level;
330
331 205743711 UPDATE_CACHE(re, gb);
332 }
333 30597572 CLOSE_READER(re, gb);
334 30597572 mb->pos = pos;
335 30597572 }
336
337 16904140 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
338 {
339 16904140 int bits_left = get_bits_left(gb);
340
2/2
✓ Branch 0 taken 36664216 times.
✓ Branch 1 taken 16904140 times.
53568356 while (bits_left >= MIN_CACHE_BITS) {
341 36664216 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
342 36664216 bits_left -= MIN_CACHE_BITS;
343 }
344
2/2
✓ Branch 0 taken 16344707 times.
✓ Branch 1 taken 559433 times.
16904140 if (bits_left > 0)
345 16344707 put_bits(pb, bits_left, get_bits(gb, bits_left));
346 16904140 }
347
348 static av_always_inline void put_block_8x4(int16_t *block, uint8_t *av_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 620568 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
392 {
393 620568 const DVDecContext *s = avctx->priv_data;
394 620568 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 620568 LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
406 620568 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
407 620568 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
408 620568 const int log2_blocksize = 3 - avctx->lowres;
409 int is_field_mode[5];
410 620568 int vs_bit_buffer_damaged = 0;
411 620568 int mb_bit_buffer_damaged[5] = {0};
412 620568 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 620569 retry:
419
420 620569 memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
421
422 /* pass 1: read DC and AC coefficients in blocks */
423 620569 buf_ptr = &s->buf[work_chunk->buf_offset * 80];
424 620569 block1 = &sblock[0][0];
425 620569 mb1 = mb_data;
426 620569 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
427
2/2
✓ Branch 0 taken 3102845 times.
✓ Branch 1 taken 620569 times.
3723414 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
428 /* skip header */
429 3102845 quant = buf_ptr[3] & 0x0f;
430
1/2
✓ Branch 0 taken 3102845 times.
✗ Branch 1 not taken.
3102845 if (avctx->error_concealment) {
431
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3102845 times.
3102845 if ((buf_ptr[3] >> 4) == 0x0E)
432 vs_bit_buffer_damaged = 1;
433
2/2
✓ Branch 0 taken 620569 times.
✓ Branch 1 taken 2482276 times.
3102845 if (!mb_index) {
434 620569 sta = buf_ptr[3] >> 4;
435
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2482276 times.
2482276 } else if (sta != (buf_ptr[3] >> 4))
436 vs_bit_buffer_damaged = 1;
437 }
438 3102845 buf_ptr += 4;
439 3102845 init_put_bits(&pb, mb_bit_buffer, 80);
440 3102845 mb = mb1;
441 3102845 block = block1;
442 3102845 is_field_mode[mb_index] = 0;
443
2/2
✓ Branch 0 taken 22202670 times.
✓ Branch 1 taken 3102845 times.
25305515 for (j = 0; j < s->sys->bpm; j++) {
444 22202670 last_index = s->sys->block_sizes[j];
445 22202670 init_get_bits(&gb, buf_ptr, last_index);
446
447 /* get the DC */
448 22202670 dc = get_sbits(&gb, 9);
449 22202670 dct_mode = get_bits1(&gb);
450 22202670 class1 = get_bits(&gb, 2);
451
2/2
✓ Branch 0 taken 14342400 times.
✓ Branch 1 taken 7860270 times.
22202670 if (DV_PROFILE_IS_HD(s->sys)) {
452 14342400 mb->idct_put = s->idct_put[0];
453 14342400 mb->scan_table = s->dv_zigzag[0];
454
2/2
✓ Branch 0 taken 7171200 times.
✓ Branch 1 taken 7171200 times.
14342400 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
455 14342400 class1 * 16 * 64 +
456 14342400 quant * 64];
457
3/4
✓ Branch 0 taken 1792800 times.
✓ Branch 1 taken 12549600 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1792800 times.
14342400 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 2565500 times.
✓ Branch 1 taken 5294770 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 22202670 dc = dc * 4;
467 /* convert to unsigned because 128 is not added in the
468 * standard IDCT */
469 22202670 dc += 1024;
470 22202670 block[0] = dc;
471 22202670 buf_ptr += last_index >> 3;
472 22202670 mb->pos = 0;
473 22202670 mb->partial_bit_count = 0;
474
475 ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
476 22202670 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 14800193 times.
✓ Branch 1 taken 7402477 times.
22202670 if (mb->pos >= 64)
481 14800193 bit_copy(&pb, &gb);
482
3/4
✓ Branch 0 taken 14800193 times.
✓ Branch 1 taken 7402477 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 14800193 times.
22202670 if (mb->pos >= 64 && mb->pos < 127)
483 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
484
485 22202670 block += 64;
486 22202670 mb++;
487 }
488
489
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3102844 times.
3102845 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 3102844 block = block1;
495 3102844 mb = mb1;
496 3102844 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
497 3102844 put_bits32(&pb, 0); // padding must be zeroed
498 3102844 flush_put_bits(&pb);
499
2/2
✓ Branch 0 taken 17737356 times.
✓ Branch 1 taken 2103947 times.
19841303 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
500
4/4
✓ Branch 0 taken 4961515 times.
✓ Branch 1 taken 12775841 times.
✓ Branch 3 taken 4506592 times.
✓ Branch 4 taken 454923 times.
17737356 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
501 4506592 dv_decode_ac(&gb, mb, block);
502 /* if still not finished, no need to parse other blocks */
503
2/2
✓ Branch 0 taken 998897 times.
✓ Branch 1 taken 3507695 times.
4506592 if (mb->pos < 64)
504 998897 break;
505
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 3507693 times.
3507695 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 2103947 times.
✓ Branch 1 taken 998897 times.
3102844 if (j >= s->sys->bpm)
512 2103947 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 620569 block = &sblock[0][0];
518 620569 mb = mb_data;
519 620569 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
520 620569 put_bits32(&vs_pb, 0); // padding must be zeroed
521 620569 flush_put_bits(&vs_pb);
522
2/2
✓ Branch 0 taken 3102845 times.
✓ Branch 1 taken 620569 times.
3723414 for (mb_index = 0; mb_index < 5; mb_index++) {
523
2/2
✓ Branch 0 taken 22202670 times.
✓ Branch 1 taken 3102845 times.
25305515 for (j = 0; j < s->sys->bpm; j++) {
524
5/6
✓ Branch 0 taken 3894782 times.
✓ Branch 1 taken 18307888 times.
✓ Branch 3 taken 3888310 times.
✓ Branch 4 taken 6472 times.
✓ Branch 5 taken 3888310 times.
✗ Branch 6 not taken.
22202670 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 3888310 dv_decode_ac(&gb, mb, block);
527 }
528
529
4/4
✓ Branch 0 taken 22196198 times.
✓ Branch 1 taken 6472 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 22196196 times.
22202670 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 22202670 block += 64;
535 22202670 mb++;
536 }
537 }
538
4/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 620567 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
620569 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 620568 block = &sblock[0][0];
546 620568 mb = mb_data;
547
2/2
✓ Branch 0 taken 3102840 times.
✓ Branch 1 taken 620568 times.
3723408 for (mb_index = 0; mb_index < 5; mb_index++) {
548 3102840 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 2680020 times.
✓ Branch 1 taken 422820 times.
3102840 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
552
4/4
✓ Branch 0 taken 300780 times.
✓ Branch 1 taken 2379240 times.
✓ Branch 2 taken 294096 times.
✓ Branch 3 taken 6684 times.
2680020 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
553
4/4
✓ Branch 0 taken 1792800 times.
✓ Branch 1 taken 880536 times.
✓ Branch 2 taken 1783620 times.
✓ Branch 3 taken 9180 times.
2673336 (s->sys->height >= 720 && mb_y != 134)) {
554 2213124 y_stride = (s->frame->linesize[0] <<
555 2213124 ((!is_field_mode[mb_index]) * log2_blocksize));
556 } else {
557 889716 y_stride = (2 << log2_blocksize);
558 }
559 3102840 y_ptr = s->frame->data[0] +
560 3102840 ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
561
3/4
✓ Branch 0 taken 9180 times.
✓ Branch 1 taken 3093660 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 9180 times.
3102840 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 3102840 linesize = s->frame->linesize[0] << is_field_mode[mb_index];
565 3102840 mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
566
2/2
✓ Branch 0 taken 586440 times.
✓ Branch 1 taken 2516400 times.
3102840 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 2516400 mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
570 2516400 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
571 2516400 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
572 }
573 }
574 3102840 mb += 4;
575 3102840 block += 4 * 64;
576
577 /* idct_put'ting chrominance */
578 6205680 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 2802060 times.
3102840 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
580
2/2
✓ Branch 0 taken 6205680 times.
✓ Branch 1 taken 3102840 times.
9308520 for (j = 2; j; j--) {
581 6205680 uint8_t *c_ptr = s->frame->data[j] + c_offset;
582
4/4
✓ Branch 0 taken 601560 times.
✓ Branch 1 taken 5604120 times.
✓ Branch 2 taken 13368 times.
✓ Branch 3 taken 588192 times.
6205680 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 18360 times.
✓ Branch 1 taken 6173952 times.
6192312 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
600 6173952 s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
601
3/4
✓ Branch 0 taken 18360 times.
✓ Branch 1 taken 6173952 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 18360 times.
6192312 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 6192312 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
607 6192312 (mb++)->idct_put(c_ptr, linesize, block);
608 6192312 block += 64;
609
2/2
✓ Branch 0 taken 3585600 times.
✓ Branch 1 taken 2606712 times.
6192312 if (s->sys->bpm == 8) {
610 3585600 (mb++)->idct_put(c_ptr + y_stride, linesize, block);
611 3585600 block += 64;
612 }
613 }
614 }
615 }
616 }
617 620568 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 1043 static int dvvideo_decode_frame(AVCodecContext *avctx, AVFrame *frame,
623 int *got_frame, AVPacket *avpkt)
624 {
625 1043 uint8_t *buf = avpkt->data;
626 1043 int buf_size = avpkt->size;
627 1043 DVDecContext *s = avctx->priv_data;
628 const uint8_t *vsc_pack;
629 int apt, is16_9, ret;
630 const AVDVProfile *sys;
631
632 1043 sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
633
2/4
✓ Branch 0 taken 1043 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1043 times.
1043 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 58 times.
✓ Branch 1 taken 985 times.
1043 if (sys != s->sys) {
639 58 ret = ff_dv_init_dynamic_tables(s->work_chunks, sys);
640
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58 times.
58 if (ret < 0) {
641 av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
642 return ret;
643 }
644 58 dv_init_weight_tables(s, sys);
645 58 s->sys = sys;
646 }
647
648 1043 s->frame = frame;
649 1043 frame->key_frame = 1;
650 1043 frame->pict_type = AV_PICTURE_TYPE_I;
651 1043 avctx->pix_fmt = s->sys->pix_fmt;
652 1043 avctx->framerate = av_inv_q(s->sys->time_base);
653
654 1043 ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
655
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1043 times.
1043 if (ret < 0)
656 return ret;
657
658 /* Determine the codec's sample_aspect ratio from the packet */
659 1043 vsc_pack = buf + 80 * 5 + 48 + 5;
660
1/2
✓ Branch 0 taken 1043 times.
✗ Branch 1 not taken.
1043 if (*vsc_pack == DV_VIDEO_CONTROL) {
661 1043 apt = buf[4] & 0x07;
662
4/4
✓ Branch 0 taken 607 times.
✓ Branch 1 taken 436 times.
✓ Branch 2 taken 269 times.
✓ Branch 3 taken 338 times.
1312 is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
663
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 269 times.
269 (!apt && (vsc_pack[2] & 0x07) == 0x07);
664 1043 ff_set_sar(avctx, s->sys->sar[is16_9]);
665 }
666
667
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1043 times.
1043 if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
668 return ret;
669
670 /* Determine the codec's field order from the packet */
671
1/2
✓ Branch 0 taken 1043 times.
✗ Branch 1 not taken.
1043 if ( *vsc_pack == DV_VIDEO_CONTROL ) {
672
2/2
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 838 times.
1043 if (avctx->height == 720) {
673 205 frame->interlaced_frame = 0;
674 205 frame->top_field_first = 0;
675
2/2
✓ Branch 0 taken 204 times.
✓ Branch 1 taken 634 times.
838 } else if (avctx->height == 1080) {
676 204 frame->interlaced_frame = 1;
677 204 frame->top_field_first = (vsc_pack[3] & 0x40) == 0x40;
678 } else {
679 634 frame->interlaced_frame = (vsc_pack[3] & 0x10) == 0x10;
680 634 frame->top_field_first = !(vsc_pack[3] & 0x40);
681 }
682 }
683
684 1043 s->buf = buf;
685 1043 avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
686 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
687
688 1043 emms_c();
689
690 /* return image */
691 1043 *got_frame = 1;
692
693 1043 return s->sys->frame_size;
694 }
695
696 const FFCodec ff_dvvideo_decoder = {
697 .p.name = "dvvideo",
698 CODEC_LONG_NAME("DV (Digital Video)"),
699 .p.type = AVMEDIA_TYPE_VIDEO,
700 .p.id = AV_CODEC_ID_DVVIDEO,
701 .priv_data_size = sizeof(DVDecContext),
702 .init = dvvideo_decode_init,
703 FF_CODEC_DECODE_CB(dvvideo_decode_frame),
704 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
705 .p.max_lowres = 3,
706 };
707