FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/dvdec.c
Date: 2024-04-20 14:10:07
Exec Total Coverage
Lines: 290 333 87.1%
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/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 32370770 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
279 {
280 32370770 int last_index = gb->size_in_bits;
281 32370770 const uint8_t *scan_table = mb->scan_table;
282 32370770 const uint32_t *factor_table = mb->factor_table;
283 32370770 int pos = mb->pos;
284 32370770 int partial_bit_count = mb->partial_bit_count;
285 int level, run, vlc_len, index;
286
287 32370770 OPEN_READER_NOSIZE(re, gb);
288 32370770 UPDATE_CACHE(re, gb);
289
290 /* if we must parse a partial VLC, we do it here */
291
2/2
✓ Branch 0 taken 7428217 times.
✓ Branch 1 taken 24942553 times.
32370770 if (partial_bit_count > 0) {
292 7428217 re_cache = re_cache >> partial_bit_count |
293 7428217 mb->partial_bit_buffer;
294 7428217 re_index -= partial_bit_count;
295 7428217 mb->partial_bit_count = 0;
296 }
297
298 /* get the AC coefficients until last_index is reached */
299 for (;;) {
300 216755727 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 249126497 index = NEG_USR32(re_cache, TEX_VLC_BITS);
304 249126497 vlc_len = dv_rl_vlc[index].len;
305
2/2
✓ Branch 0 taken 19048052 times.
✓ Branch 1 taken 230078445 times.
249126497 if (vlc_len < 0) {
306 19048052 index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
307 19048052 dv_rl_vlc[index].level;
308 19048052 vlc_len = TEX_VLC_BITS - vlc_len;
309 }
310 249126497 level = dv_rl_vlc[index].level;
311 249126497 run = dv_rl_vlc[index].run;
312
313 /* gotta check if we're still within gb boundaries */
314
2/2
✓ Branch 0 taken 8910972 times.
✓ Branch 1 taken 240215525 times.
249126497 if (re_index + vlc_len > last_index) {
315 /* should be < 16 bits otherwise a codeword could have been parsed */
316 8910972 mb->partial_bit_count = last_index - re_index;
317 8910972 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
318 8910972 re_index = last_index;
319 8910972 break;
320 }
321 240215525 re_index += vlc_len;
322
323 ff_dlog(NULL, "run=%d level=%d\n", run, level);
324 240215525 pos += run;
325
2/2
✓ Branch 0 taken 23459798 times.
✓ Branch 1 taken 216755727 times.
240215525 if (pos >= 64)
326 23459798 break;
327
328 216755727 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
329 dv_iweight_bits;
330 216755727 block[scan_table[pos]] = level;
331
332 216755727 UPDATE_CACHE(re, gb);
333 }
334 32370770 CLOSE_READER(re, gb);
335 32370770 mb->pos = pos;
336 32370770 }
337
338 17816092 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
339 {
340 17816092 int bits_left = get_bits_left(gb);
341
2/2
✓ Branch 0 taken 37998362 times.
✓ Branch 1 taken 17816092 times.
55814454 while (bits_left >= MIN_CACHE_BITS) {
342 37998362 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
343 37998362 bits_left -= MIN_CACHE_BITS;
344 }
345
2/2
✓ Branch 0 taken 17191992 times.
✓ Branch 1 taken 624100 times.
17816092 if (bits_left > 0)
346 17191992 put_bits(pb, bits_left, get_bits(gb, bits_left));
347 17816092 }
348
349 static av_always_inline void put_block_8x4(int16_t *block, uint8_t *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 2565513 times.
✓ Branch 1 taken 5294757 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 18752005 times.
✓ Branch 1 taken 2216607 times.
20968612 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
501
4/4
✓ Branch 0 taken 5259506 times.
✓ Branch 1 taken 13492499 times.
✓ Branch 3 taken 4666985 times.
✓ Branch 4 taken 592521 times.
18752005 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
502 4666985 dv_decode_ac(&gb, mb, block);
503 /* if still not finished, no need to parse other blocks */
504
2/2
✓ Branch 0 taken 1044187 times.
✓ Branch 1 taken 3622798 times.
4666985 if (mb->pos < 64)
505 1044187 break;
506
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 3622796 times.
3622798 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 2216607 times.
✓ Branch 1 taken 1044187 times.
3260794 if (j >= s->sys->bpm)
513 2216607 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 4243987 times.
✓ Branch 1 taken 19222283 times.
✓ Branch 3 taken 4237515 times.
✓ Branch 4 taken 6472 times.
✓ Branch 5 taken 4237515 times.
✗ Branch 6 not taken.
23466270 if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
526 ff_dlog(avctx, "start %d:%d\n", mb_index, j);
527 4237515 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 ff_dv_init_dynamic_tables(s->work_chunks, sys);
641 60 dv_init_weight_tables(s, sys);
642 60 s->sys = sys;
643 }
644
645 1069 s->frame = frame;
646 1069 frame->flags |= AV_FRAME_FLAG_KEY;
647 1069 frame->pict_type = AV_PICTURE_TYPE_I;
648 1069 avctx->pix_fmt = s->sys->pix_fmt;
649 1069 avctx->framerate = av_inv_q(s->sys->time_base);
650 1069 avctx->bit_rate = av_rescale_q(s->sys->frame_size,
651 1069 (AVRational) { 8, 1 },
652 1069 s->sys->time_base);
653
654 1069 ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
655
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1069 times.
1069 if (ret < 0)
656 return ret;
657
658 /* Determine the codec's sample_aspect ratio from the packet */
659 1069 vsc_pack = buf + 80 * 5 + 48 + 5;
660
1/2
✓ Branch 0 taken 1069 times.
✗ Branch 1 not taken.
1069 if (*vsc_pack == DV_VIDEO_CONTROL) {
661 1069 apt = buf[4] & 0x07;
662
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 ||
663
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 269 times.
269 (!apt && (vsc_pack[2] & 0x07) == 0x07);
664 1069 ff_set_sar(avctx, s->sys->sar[is16_9]);
665 }
666
667
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1069 times.
1069 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 1069 times.
✗ Branch 1 not taken.
1069 if ( *vsc_pack == DV_VIDEO_CONTROL ) {
672
2/2
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 864 times.
1069 if (avctx->height == 720) {
673 205 frame->flags &= ~AV_FRAME_FLAG_INTERLACED;
674 205 frame->flags &= ~AV_FRAME_FLAG_TOP_FIELD_FIRST;
675
2/2
✓ Branch 0 taken 230 times.
✓ Branch 1 taken 634 times.
864 } else if (avctx->height == 1080) {
676 230 frame->flags |= AV_FRAME_FLAG_INTERLACED;
677 230 frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * ((vsc_pack[3] & 0x40) == 0x40);
678 } else {
679 634 frame->flags |= AV_FRAME_FLAG_INTERLACED * ((vsc_pack[3] & 0x10) == 0x10);
680
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 634 times.
634 frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * !(vsc_pack[3] & 0x40);
681 }
682 }
683
684 1069 s->buf = buf;
685 1069 avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
686 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
687
688 1069 emms_c();
689
690 /* return image */
691 1069 *got_frame = 1;
692
693 1069 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