FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/dvdec.c
Date: 2022-07-04 00:18:54
Exec Total Coverage
Lines: 287 329 87.2%
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/imgutils.h"
40 #include "libavutil/internal.h"
41 #include "libavutil/mem_internal.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/thread.h"
44
45 #include "avcodec.h"
46 #include "codec_internal.h"
47 #include "dv.h"
48 #include "dv_profile_internal.h"
49 #include "dvdata.h"
50 #include "get_bits.h"
51 #include "internal.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 static const int dv_iweight_bits = 14;
67
68 static const uint16_t dv_iweight_88[64] = {
69 32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081,
70 18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266,
71 19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267,
72 20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806,
73 20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400,
74 21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786,
75 24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172,
76 25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521,
77 };
78 static const uint16_t dv_iweight_248[64] = {
79 32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734,
80 18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091,
81 19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705,
82 20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806,
83 20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853,
84 21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018,
85 23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465,
86 25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692
87 };
88
89 /**
90 * The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
91 */
92 static const uint16_t dv_iweight_1080_y[64] = {
93 128, 16, 16, 17, 17, 17, 18, 18,
94 18, 18, 18, 18, 19, 18, 18, 19,
95 19, 19, 19, 19, 19, 42, 38, 40,
96 40, 40, 38, 42, 44, 43, 41, 41,
97 41, 41, 43, 44, 45, 45, 42, 42,
98 42, 45, 45, 48, 46, 43, 43, 46,
99 48, 49, 48, 44, 48, 49, 101, 98,
100 98, 101, 104, 109, 104, 116, 116, 123,
101 };
102 static const uint16_t dv_iweight_1080_c[64] = {
103 128, 16, 16, 17, 17, 17, 25, 25,
104 25, 25, 26, 25, 26, 25, 26, 26,
105 26, 27, 27, 26, 26, 42, 38, 40,
106 40, 40, 38, 42, 44, 43, 41, 41,
107 41, 41, 43, 44, 91, 91, 84, 84,
108 84, 91, 91, 96, 93, 86, 86, 93,
109 96, 197, 191, 177, 191, 197, 203, 197,
110 197, 203, 209, 219, 209, 232, 232, 246,
111 };
112 static const uint16_t dv_iweight_720_y[64] = {
113 128, 16, 16, 17, 17, 17, 18, 18,
114 18, 18, 18, 18, 19, 18, 18, 19,
115 19, 19, 19, 19, 19, 42, 38, 40,
116 40, 40, 38, 42, 44, 43, 41, 41,
117 41, 41, 43, 44, 68, 68, 63, 63,
118 63, 68, 68, 96, 92, 86, 86, 92,
119 96, 98, 96, 88, 96, 98, 202, 196,
120 196, 202, 208, 218, 208, 232, 232, 246,
121 };
122 static const uint16_t dv_iweight_720_c[64] = {
123 128, 24, 24, 26, 26, 26, 36, 36,
124 36, 36, 36, 36, 38, 36, 36, 38,
125 38, 38, 38, 38, 38, 84, 76, 80,
126 80, 80, 76, 84, 88, 86, 82, 82,
127 82, 82, 86, 88, 182, 182, 168, 168,
128 168, 182, 182, 192, 186, 192, 172, 186,
129 192, 394, 382, 354, 382, 394, 406, 394,
130 394, 406, 418, 438, 418, 464, 464, 492,
131 };
132
133 #define TEX_VLC_BITS 10
134
135 /* XXX: also include quantization */
136 static RL_VLC_ELEM dv_rl_vlc[1664];
137
138 34 static void dv_init_static(void)
139 {
140 34 VLCElem vlc_buf[FF_ARRAY_ELEMS(dv_rl_vlc)] = { 0 };
141 34 VLC dv_vlc = { .table = vlc_buf, .table_allocated = FF_ARRAY_ELEMS(vlc_buf) };
142 uint16_t new_dv_vlc_bits[NB_DV_VLC * 2];
143 uint8_t new_dv_vlc_len[NB_DV_VLC * 2];
144 uint8_t new_dv_vlc_run[NB_DV_VLC * 2];
145 int16_t new_dv_vlc_level[NB_DV_VLC * 2];
146 int i, j;
147
148 /* it's faster to include sign bit in a generic VLC parsing scheme */
149
2/2
✓ Branch 0 taken 13906 times.
✓ Branch 1 taken 34 times.
13940 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
150 13906 new_dv_vlc_bits[j] = ff_dv_vlc_bits[i];
151 13906 new_dv_vlc_len[j] = ff_dv_vlc_len[i];
152 13906 new_dv_vlc_run[j] = ff_dv_vlc_run[i];
153 13906 new_dv_vlc_level[j] = ff_dv_vlc_level[i];
154
155
2/2
✓ Branch 0 taken 11458 times.
✓ Branch 1 taken 2448 times.
13906 if (ff_dv_vlc_level[i]) {
156 11458 new_dv_vlc_bits[j] <<= 1;
157 11458 new_dv_vlc_len[j]++;
158
159 11458 j++;
160 11458 new_dv_vlc_bits[j] = (ff_dv_vlc_bits[i] << 1) | 1;
161 11458 new_dv_vlc_len[j] = ff_dv_vlc_len[i] + 1;
162 11458 new_dv_vlc_run[j] = ff_dv_vlc_run[i];
163 11458 new_dv_vlc_level[j] = -ff_dv_vlc_level[i];
164 }
165 }
166
167 /* NOTE: as a trick, we use the fact the no codes are unused
168 * to accelerate the parsing of partial codes */
169 34 init_vlc(&dv_vlc, TEX_VLC_BITS, j, new_dv_vlc_len,
170 1, 1, new_dv_vlc_bits, 2, 2, INIT_VLC_USE_NEW_STATIC);
171 av_assert1(dv_vlc.table_size == 1664);
172
173
2/2
✓ Branch 0 taken 56576 times.
✓ Branch 1 taken 34 times.
56610 for (int i = 0; i < dv_vlc.table_size; i++) {
174 56576 int code = dv_vlc.table[i].sym;
175 56576 int len = dv_vlc.table[i].len;
176 int level, run;
177
178
2/2
✓ Branch 0 taken 1088 times.
✓ Branch 1 taken 55488 times.
56576 if (len < 0) { // more bits needed
179 1088 run = 0;
180 1088 level = code;
181 } else {
182 55488 run = new_dv_vlc_run[code] + 1;
183 55488 level = new_dv_vlc_level[code];
184 }
185 56576 dv_rl_vlc[i].len = len;
186 56576 dv_rl_vlc[i].level = level;
187 56576 dv_rl_vlc[i].run = run;
188 }
189 34 }
190
191 58 static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
192 {
193 int j, i, c, s;
194 58 uint32_t *factor1 = &ctx->idct_factor[0],
195
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 41 times.
58 *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
196
197
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 41 times.
58 if (DV_PROFILE_IS_HD(d)) {
198 /* quantization quanta by QNO for DV100 */
199 static const uint8_t dv100_qstep[16] = {
200 1, /* QNO = 0 and 1 both have no quantization */
201 1,
202 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
203 };
204 const uint16_t *iweight1, *iweight2;
205
206
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 8 times.
17 if (d->height == 720) {
207 9 iweight1 = &dv_iweight_720_y[0];
208 9 iweight2 = &dv_iweight_720_c[0];
209 } else {
210 8 iweight1 = &dv_iweight_1080_y[0];
211 8 iweight2 = &dv_iweight_1080_c[0];
212 }
213
2/2
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 17 times.
85 for (c = 0; c < 4; c++) {
214
2/2
✓ Branch 0 taken 1088 times.
✓ Branch 1 taken 68 times.
1156 for (s = 0; s < 16; s++) {
215
2/2
✓ Branch 0 taken 69632 times.
✓ Branch 1 taken 1088 times.
70720 for (i = 0; i < 64; i++) {
216 69632 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
217 69632 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
218 }
219 }
220 }
221 } else {
222 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
223 41 const uint16_t *iweight1 = &dv_iweight_88[0];
224
2/2
✓ Branch 0 taken 82 times.
✓ Branch 1 taken 41 times.
123 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
225
2/2
✓ Branch 0 taken 1804 times.
✓ Branch 1 taken 82 times.
1886 for (s = 0; s < 22; s++) {
226
2/2
✓ Branch 0 taken 7216 times.
✓ Branch 1 taken 1804 times.
9020 for (i = c = 0; c < 4; c++) {
227
2/2
✓ Branch 0 taken 115456 times.
✓ Branch 1 taken 7216 times.
122672 for (; i < dv_quant_areas[c]; i++) {
228 115456 *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
229 115456 *factor2++ = (*factor1++) << 1;
230 }
231 }
232 }
233 }
234 }
235 58 }
236
237 60 static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
238 {
239 static AVOnce init_static_once = AV_ONCE_INIT;
240 60 DVVideoContext *s = avctx->priv_data;
241 int i;
242
243 60 ff_idctdsp_init(&s->idsp, avctx);
244
245
2/2
✓ Branch 0 taken 3840 times.
✓ Branch 1 taken 60 times.
3900 for (i = 0; i < 64; i++)
246 3840 s->dv_zigzag[0][i] = s->idsp.idct_permutation[ff_zigzag_direct[i]];
247
248
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 60 times.
60 if (avctx->lowres){
249 for (i = 0; i < 64; i++){
250 int j = ff_dv_zigzag248_direct[i];
251 s->dv_zigzag[1][i] = s->idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
252 }
253 }else
254 60 memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
255
256 60 s->idct_put[0] = s->idsp.idct_put;
257 60 s->idct_put[1] = ff_simple_idct248_put;
258
259 60 ff_thread_once(&init_static_once, dv_init_static);
260
261 60 return ff_dvvideo_init(avctx);
262 }
263
264 /* decode AC coefficients */
265 30597572 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
266 {
267 30597572 int last_index = gb->size_in_bits;
268 30597572 const uint8_t *scan_table = mb->scan_table;
269 30597572 const uint32_t *factor_table = mb->factor_table;
270 30597572 int pos = mb->pos;
271 30597572 int partial_bit_count = mb->partial_bit_count;
272 int level, run, vlc_len, index;
273
274 30597572 OPEN_READER_NOSIZE(re, gb);
275 30597572 UPDATE_CACHE(re, gb);
276
277 /* if we must parse a partial VLC, we do it here */
278
2/2
✓ Branch 0 taken 7006249 times.
✓ Branch 1 taken 23591323 times.
30597572 if (partial_bit_count > 0) {
279 7006249 re_cache = re_cache >> partial_bit_count |
280 7006249 mb->partial_bit_buffer;
281 7006249 re_index -= partial_bit_count;
282 7006249 mb->partial_bit_count = 0;
283 }
284
285 /* get the AC coefficients until last_index is reached */
286 for (;;) {
287 205743711 ff_dlog(NULL, "%2d: bits=%04"PRIx32" index=%u\n",
288 pos, SHOW_UBITS(re, gb, 16), re_index);
289 /* our own optimized GET_RL_VLC */
290 236341283 index = NEG_USR32(re_cache, TEX_VLC_BITS);
291 236341283 vlc_len = dv_rl_vlc[index].len;
292
2/2
✓ Branch 0 taken 18065775 times.
✓ Branch 1 taken 218275508 times.
236341283 if (vlc_len < 0) {
293 18065775 index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
294 18065775 dv_rl_vlc[index].level;
295 18065775 vlc_len = TEX_VLC_BITS - vlc_len;
296 }
297 236341283 level = dv_rl_vlc[index].level;
298 236341283 run = dv_rl_vlc[index].run;
299
300 /* gotta check if we're still within gb boundaries */
301
2/2
✓ Branch 0 taken 8401374 times.
✓ Branch 1 taken 227939909 times.
236341283 if (re_index + vlc_len > last_index) {
302 /* should be < 16 bits otherwise a codeword could have been parsed */
303 8401374 mb->partial_bit_count = last_index - re_index;
304 8401374 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
305 8401374 re_index = last_index;
306 8401374 break;
307 }
308 227939909 re_index += vlc_len;
309
310 ff_dlog(NULL, "run=%d level=%d\n", run, level);
311 227939909 pos += run;
312
2/2
✓ Branch 0 taken 22196198 times.
✓ Branch 1 taken 205743711 times.
227939909 if (pos >= 64)
313 22196198 break;
314
315 205743711 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
316 dv_iweight_bits;
317 205743711 block[scan_table[pos]] = level;
318
319 205743711 UPDATE_CACHE(re, gb);
320 }
321 30597572 CLOSE_READER(re, gb);
322 30597572 mb->pos = pos;
323 30597572 }
324
325 16904140 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
326 {
327 16904140 int bits_left = get_bits_left(gb);
328
2/2
✓ Branch 0 taken 36664216 times.
✓ Branch 1 taken 16904140 times.
53568356 while (bits_left >= MIN_CACHE_BITS) {
329 36664216 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
330 36664216 bits_left -= MIN_CACHE_BITS;
331 }
332
2/2
✓ Branch 0 taken 16344707 times.
✓ Branch 1 taken 559433 times.
16904140 if (bits_left > 0)
333 16344707 put_bits(pb, bits_left, get_bits(gb, bits_left));
334 16904140 }
335
336 static av_always_inline void put_block_8x4(int16_t *block, uint8_t *av_restrict p, int stride)
337 {
338 int i, j;
339
340 for (i = 0; i < 4; i++) {
341 for (j = 0; j < 8; j++)
342 p[j] = av_clip_uint8(block[j]);
343 block += 8;
344 p += stride;
345 }
346 }
347
348 static void dv100_idct_put_last_row_field_chroma(DVVideoContext *s, uint8_t *data,
349 int stride, int16_t *blocks)
350 {
351 s->idsp.idct(blocks + 0*64);
352 s->idsp.idct(blocks + 1*64);
353
354 put_block_8x4(blocks+0*64, data, stride<<1);
355 put_block_8x4(blocks+0*64 + 4*8, data + 8, stride<<1);
356 put_block_8x4(blocks+1*64, data + stride, stride<<1);
357 put_block_8x4(blocks+1*64 + 4*8, data + 8 + stride, stride<<1);
358 }
359
360 static void dv100_idct_put_last_row_field_luma(DVVideoContext *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 s->idsp.idct(blocks + 2*64);
366 s->idsp.idct(blocks + 3*64);
367
368 put_block_8x4(blocks+0*64, data, stride<<1);
369 put_block_8x4(blocks+0*64 + 4*8, data + 16, stride<<1);
370 put_block_8x4(blocks+1*64, data + 8, stride<<1);
371 put_block_8x4(blocks+1*64 + 4*8, data + 24, stride<<1);
372 put_block_8x4(blocks+2*64, data + stride, stride<<1);
373 put_block_8x4(blocks+2*64 + 4*8, data + 16 + stride, stride<<1);
374 put_block_8x4(blocks+3*64, data + 8 + stride, stride<<1);
375 put_block_8x4(blocks+3*64 + 4*8, data + 24 + stride, stride<<1);
376 }
377
378 /* mb_x and mb_y are in units of 8 pixels */
379 620568 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
380 {
381 620568 DVVideoContext *s = avctx->priv_data;
382 620568 DVwork_chunk *work_chunk = arg;
383 int quant, dc, dct_mode, class1, j;
384 int mb_index, mb_x, mb_y, last_index;
385 int y_stride, linesize;
386 int16_t *block, *block1;
387 int c_offset;
388 uint8_t *y_ptr;
389 const uint8_t *buf_ptr;
390 PutBitContext pb, vs_pb;
391 GetBitContext gb;
392 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
393 620568 LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
394 620568 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
395 620568 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
396 620568 const int log2_blocksize = 3-s->avctx->lowres;
397 int is_field_mode[5];
398 620568 int vs_bit_buffer_damaged = 0;
399 620568 int mb_bit_buffer_damaged[5] = {0};
400 620568 int retried = 0;
401 int sta;
402
403 av_assert1((((uintptr_t) mb_bit_buffer) & 7) == 0);
404 av_assert1((((uintptr_t) vs_bit_buffer) & 7) == 0);
405
406 620569 retry:
407
408 620569 memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
409
410 /* pass 1: read DC and AC coefficients in blocks */
411 620569 buf_ptr = &s->buf[work_chunk->buf_offset * 80];
412 620569 block1 = &sblock[0][0];
413 620569 mb1 = mb_data;
414 620569 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
415
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) {
416 /* skip header */
417 3102845 quant = buf_ptr[3] & 0x0f;
418
1/2
✓ Branch 0 taken 3102845 times.
✗ Branch 1 not taken.
3102845 if (avctx->error_concealment) {
419
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3102845 times.
3102845 if ((buf_ptr[3] >> 4) == 0x0E)
420 vs_bit_buffer_damaged = 1;
421
2/2
✓ Branch 0 taken 620569 times.
✓ Branch 1 taken 2482276 times.
3102845 if (!mb_index) {
422 620569 sta = buf_ptr[3] >> 4;
423
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2482276 times.
2482276 } else if (sta != (buf_ptr[3] >> 4))
424 vs_bit_buffer_damaged = 1;
425 }
426 3102845 buf_ptr += 4;
427 3102845 init_put_bits(&pb, mb_bit_buffer, 80);
428 3102845 mb = mb1;
429 3102845 block = block1;
430 3102845 is_field_mode[mb_index] = 0;
431
2/2
✓ Branch 0 taken 22202670 times.
✓ Branch 1 taken 3102845 times.
25305515 for (j = 0; j < s->sys->bpm; j++) {
432 22202670 last_index = s->sys->block_sizes[j];
433 22202670 init_get_bits(&gb, buf_ptr, last_index);
434
435 /* get the DC */
436 22202670 dc = get_sbits(&gb, 9);
437 22202670 dct_mode = get_bits1(&gb);
438 22202670 class1 = get_bits(&gb, 2);
439
2/2
✓ Branch 0 taken 14342400 times.
✓ Branch 1 taken 7860270 times.
22202670 if (DV_PROFILE_IS_HD(s->sys)) {
440 14342400 mb->idct_put = s->idct_put[0];
441 14342400 mb->scan_table = s->dv_zigzag[0];
442
2/2
✓ Branch 0 taken 7171200 times.
✓ Branch 1 taken 7171200 times.
14342400 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
443 14342400 class1 * 16 * 64 +
444 14342400 quant * 64];
445
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;
446 } else {
447
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];
448 7860270 mb->scan_table = s->dv_zigzag[dct_mode];
449 7860270 mb->factor_table =
450
2/2
✓ Branch 0 taken 2565500 times.
✓ Branch 1 taken 5294770 times.
7860270 &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
451 7860270 dct_mode * 22 * 64 +
452 7860270 (quant + ff_dv_quant_offset[class1]) * 64];
453 }
454 22202670 dc = dc * 4;
455 /* convert to unsigned because 128 is not added in the
456 * standard IDCT */
457 22202670 dc += 1024;
458 22202670 block[0] = dc;
459 22202670 buf_ptr += last_index >> 3;
460 22202670 mb->pos = 0;
461 22202670 mb->partial_bit_count = 0;
462
463 ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
464 22202670 dv_decode_ac(&gb, mb, block);
465
466 /* write the remaining bits in a new buffer only if the
467 * block is finished */
468
2/2
✓ Branch 0 taken 14800193 times.
✓ Branch 1 taken 7402477 times.
22202670 if (mb->pos >= 64)
469 14800193 bit_copy(&pb, &gb);
470
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)
471 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
472
473 22202670 block += 64;
474 22202670 mb++;
475 }
476
477
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 3102844 times.
3102845 if (mb_bit_buffer_damaged[mb_index] > 0)
478 1 continue;
479
480 /* pass 2: we can do it just after */
481 ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
482 3102844 block = block1;
483 3102844 mb = mb1;
484 3102844 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
485 3102844 put_bits32(&pb, 0); // padding must be zeroed
486 3102844 flush_put_bits(&pb);
487
2/2
✓ Branch 0 taken 17737356 times.
✓ Branch 1 taken 2103947 times.
19841303 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
488
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) {
489 4506592 dv_decode_ac(&gb, mb, block);
490 /* if still not finished, no need to parse other blocks */
491
2/2
✓ Branch 0 taken 998897 times.
✓ Branch 1 taken 3507695 times.
4506592 if (mb->pos < 64)
492 998897 break;
493
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 3507693 times.
3507695 if (mb->pos < 127)
494 2 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
495 }
496 }
497 /* all blocks are finished, so the extra bytes can be used at
498 * the video segment level */
499
2/2
✓ Branch 0 taken 2103947 times.
✓ Branch 1 taken 998897 times.
3102844 if (j >= s->sys->bpm)
500 2103947 bit_copy(&vs_pb, &gb);
501 }
502
503 /* we need a pass over the whole video segment */
504 ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
505 620569 block = &sblock[0][0];
506 620569 mb = mb_data;
507 620569 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
508 620569 put_bits32(&vs_pb, 0); // padding must be zeroed
509 620569 flush_put_bits(&vs_pb);
510
2/2
✓ Branch 0 taken 3102845 times.
✓ Branch 1 taken 620569 times.
3723414 for (mb_index = 0; mb_index < 5; mb_index++) {
511
2/2
✓ Branch 0 taken 22202670 times.
✓ Branch 1 taken 3102845 times.
25305515 for (j = 0; j < s->sys->bpm; j++) {
512
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) {
513 ff_dlog(avctx, "start %d:%d\n", mb_index, j);
514 3888310 dv_decode_ac(&gb, mb, block);
515 }
516
517
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) {
518 2 av_log(avctx, AV_LOG_ERROR,
519 2 "AC EOB marker is absent pos=%d\n", mb->pos);
520 2 vs_bit_buffer_damaged = 1;
521 }
522 22202670 block += 64;
523 22202670 mb++;
524 }
525 }
526
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) {
527 1 av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
528 1 retried = 1;
529 1 goto retry;
530 }
531
532 /* compute idct and place blocks */
533 620568 block = &sblock[0][0];
534 620568 mb = mb_data;
535
2/2
✓ Branch 0 taken 3102840 times.
✓ Branch 1 taken 620568 times.
3723408 for (mb_index = 0; mb_index < 5; mb_index++) {
536 3102840 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
537
538 /* idct_put'ting luminance */
539
2/2
✓ Branch 0 taken 2680020 times.
✓ Branch 1 taken 422820 times.
3102840 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
540
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)) ||
541
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)) {
542 2213124 y_stride = (s->frame->linesize[0] <<
543 2213124 ((!is_field_mode[mb_index]) * log2_blocksize));
544 } else {
545 889716 y_stride = (2 << log2_blocksize);
546 }
547 3102840 y_ptr = s->frame->data[0] +
548 3102840 ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
549
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]) {
550 dv100_idct_put_last_row_field_luma(s, y_ptr, s->frame->linesize[0], block);
551 } else {
552 3102840 linesize = s->frame->linesize[0] << is_field_mode[mb_index];
553 3102840 mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
554
2/2
✓ Branch 0 taken 586440 times.
✓ Branch 1 taken 2516400 times.
3102840 if (s->sys->video_stype == 4) { /* SD 422 */
555 586440 mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
556 } else {
557 2516400 mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
558 2516400 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
559 2516400 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
560 }
561 }
562 3102840 mb += 4;
563 3102840 block += 4 * 64;
564
565 /* idct_put'ting chrominance */
566 6205680 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
567
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);
568
2/2
✓ Branch 0 taken 6205680 times.
✓ Branch 1 taken 3102840 times.
9308520 for (j = 2; j; j--) {
569 6205680 uint8_t *c_ptr = s->frame->data[j] + c_offset;
570
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)) {
571 uint64_t aligned_pixels[64 / 8];
572 13368 uint8_t *pixels = (uint8_t *) aligned_pixels;
573 uint8_t *c_ptr1, *ptr1;
574 int x, y;
575 13368 mb->idct_put(pixels, 8, block);
576
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) {
577 106944 ptr1 = pixels + ((1 << (log2_blocksize))>>1);
578 106944 c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
579
2/2
✓ Branch 0 taken 427776 times.
✓ Branch 1 taken 106944 times.
534720 for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
580 427776 c_ptr[x] = pixels[x];
581 427776 c_ptr1[x] = ptr1[x];
582 }
583 }
584 13368 block += 64;
585 13368 mb++;
586 } else {
587
2/2
✓ Branch 0 taken 18360 times.
✓ Branch 1 taken 6173952 times.
6192312 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
588 6173952 s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
589
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]) {
590 dv100_idct_put_last_row_field_chroma(s, c_ptr, s->frame->linesize[j], block);
591 mb += 2;
592 block += 2*64;
593 } else {
594 6192312 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
595 6192312 (mb++)->idct_put(c_ptr, linesize, block);
596 6192312 block += 64;
597
2/2
✓ Branch 0 taken 3585600 times.
✓ Branch 1 taken 2606712 times.
6192312 if (s->sys->bpm == 8) {
598 3585600 (mb++)->idct_put(c_ptr + y_stride, linesize, block);
599 3585600 block += 64;
600 }
601 }
602 }
603 }
604 }
605 620568 return 0;
606 }
607
608 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
609 * 144000 bytes for PAL - or twice those for 50Mbps) */
610 1043 static int dvvideo_decode_frame(AVCodecContext *avctx, AVFrame *frame,
611 int *got_frame, AVPacket *avpkt)
612 {
613 1043 uint8_t *buf = avpkt->data;
614 1043 int buf_size = avpkt->size;
615 1043 DVVideoContext *s = avctx->priv_data;
616 const uint8_t *vsc_pack;
617 int apt, is16_9, ret;
618 const AVDVProfile *sys;
619
620 1043 sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
621
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) {
622 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
623 return -1; /* NOTE: we only accept several full frames */
624 }
625
626
2/2
✓ Branch 0 taken 58 times.
✓ Branch 1 taken 985 times.
1043 if (sys != s->sys) {
627 58 ret = ff_dv_init_dynamic_tables(s, sys);
628
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58 times.
58 if (ret < 0) {
629 av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
630 return ret;
631 }
632 58 dv_init_weight_tables(s, sys);
633 58 s->sys = sys;
634 }
635
636 1043 s->frame = frame;
637 1043 frame->key_frame = 1;
638 1043 frame->pict_type = AV_PICTURE_TYPE_I;
639 1043 avctx->pix_fmt = s->sys->pix_fmt;
640 1043 avctx->framerate = av_inv_q(s->sys->time_base);
641
642 1043 ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
643
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1043 times.
1043 if (ret < 0)
644 return ret;
645
646 /* Determine the codec's sample_aspect ratio from the packet */
647 1043 vsc_pack = buf + 80 * 5 + 48 + 5;
648
1/2
✓ Branch 0 taken 1043 times.
✗ Branch 1 not taken.
1043 if (*vsc_pack == dv_video_control) {
649 1043 apt = buf[4] & 0x07;
650
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 ||
651
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 269 times.
269 (!apt && (vsc_pack[2] & 0x07) == 0x07);
652 1043 ff_set_sar(avctx, s->sys->sar[is16_9]);
653 }
654
655
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1043 times.
1043 if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
656 return ret;
657
658 /* Determine the codec's field order from the packet */
659
1/2
✓ Branch 0 taken 1043 times.
✗ Branch 1 not taken.
1043 if ( *vsc_pack == dv_video_control ) {
660
2/2
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 838 times.
1043 if (avctx->height == 720) {
661 205 frame->interlaced_frame = 0;
662 205 frame->top_field_first = 0;
663
2/2
✓ Branch 0 taken 204 times.
✓ Branch 1 taken 634 times.
838 } else if (avctx->height == 1080) {
664 204 frame->interlaced_frame = 1;
665 204 frame->top_field_first = (vsc_pack[3] & 0x40) == 0x40;
666 } else {
667 634 frame->interlaced_frame = (vsc_pack[3] & 0x10) == 0x10;
668 634 frame->top_field_first = !(vsc_pack[3] & 0x40);
669 }
670 }
671
672 1043 s->buf = buf;
673 1043 avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
674 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
675
676 1043 emms_c();
677
678 /* return image */
679 1043 *got_frame = 1;
680
681 1043 return s->sys->frame_size;
682 }
683
684 const FFCodec ff_dvvideo_decoder = {
685 .p.name = "dvvideo",
686 .p.long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
687 .p.type = AVMEDIA_TYPE_VIDEO,
688 .p.id = AV_CODEC_ID_DVVIDEO,
689 .priv_data_size = sizeof(DVVideoContext),
690 .init = dvvideo_decode_init,
691 FF_CODEC_DECODE_CB(dvvideo_decode_frame),
692 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
693 .p.max_lowres = 3,
694 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
695 };
696