FFmpeg coverage

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