GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/dvdec.c Lines: 258 300 86.0 %
Date: 2019-11-20 04:07:19 Branches: 146 170 85.9 %

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/pixdesc.h"
42
43
#include "avcodec.h"
44
#include "dv.h"
45
#include "dv_profile_internal.h"
46
#include "dvdata.h"
47
#include "get_bits.h"
48
#include "internal.h"
49
#include "put_bits.h"
50
#include "simple_idct.h"
51
#include "thread.h"
52
53
typedef struct BlockInfo {
54
    const uint32_t *factor_table;
55
    const uint8_t *scan_table;
56
    uint8_t pos; /* position in block */
57
    void (*idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
58
    uint8_t partial_bit_count;
59
    uint32_t partial_bit_buffer;
60
    int shift_offset;
61
} BlockInfo;
62
63
static const int dv_iweight_bits = 14;
64
65
static const uint16_t dv_iweight_88[64] = {
66
    32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081,
67
    18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266,
68
    19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267,
69
    20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806,
70
    20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400,
71
    21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786,
72
    24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172,
73
    25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521,
74
};
75
static const uint16_t dv_iweight_248[64] = {
76
    32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734,
77
    18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091,
78
    19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705,
79
    20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806,
80
    20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853,
81
    21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018,
82
    23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465,
83
    25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692
84
};
85
86
/**
87
 * The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
88
 */
89
static const uint16_t dv_iweight_1080_y[64] = {
90
    128,  16,  16,  17,  17,  17,  18,  18,
91
     18,  18,  18,  18,  19,  18,  18,  19,
92
     19,  19,  19,  19,  19,  42,  38,  40,
93
     40,  40,  38,  42,  44,  43,  41,  41,
94
     41,  41,  43,  44,  45,  45,  42,  42,
95
     42,  45,  45,  48,  46,  43,  43,  46,
96
     48,  49,  48,  44,  48,  49, 101,  98,
97
     98, 101, 104, 109, 104, 116, 116, 123,
98
};
99
static const uint16_t dv_iweight_1080_c[64] = {
100
    128,  16,  16,  17,  17,  17,  25,  25,
101
     25,  25,  26,  25,  26,  25,  26,  26,
102
     26,  27,  27,  26,  26,  42,  38,  40,
103
     40,  40,  38,  42,  44,  43,  41,  41,
104
     41,  41,  43,  44,  91,  91,  84,  84,
105
     84,  91,  91,  96,  93,  86,  86,  93,
106
     96, 197, 191, 177, 191, 197, 203, 197,
107
    197, 203, 209, 219, 209, 232, 232, 246,
108
};
109
static const uint16_t dv_iweight_720_y[64] = {
110
    128,  16,  16,  17,  17,  17,  18,  18,
111
     18,  18,  18,  18,  19,  18,  18,  19,
112
     19,  19,  19,  19,  19,  42,  38,  40,
113
     40,  40,  38,  42,  44,  43,  41,  41,
114
     41,  41,  43,  44,  68,  68,  63,  63,
115
     63,  68,  68,  96,  92,  86,  86,  92,
116
     96,  98,  96,  88,  96,  98, 202, 196,
117
    196, 202, 208, 218, 208, 232, 232, 246,
118
};
119
static const uint16_t dv_iweight_720_c[64] = {
120
    128,  24,  24,  26,  26,  26,  36,  36,
121
     36,  36,  36,  36,  38,  36,  36,  38,
122
     38,  38,  38,  38,  38,  84,  76,  80,
123
     80,  80,  76,  84,  88,  86,  82,  82,
124
     82,  82,  86,  88, 182, 182, 168, 168,
125
    168, 182, 182, 192, 186, 192, 172, 186,
126
    192, 394, 382, 354, 382, 394, 406, 394,
127
    394, 406, 418, 438, 418, 464, 464, 492,
128
};
129
130
55
static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
131
{
132
    int j, i, c, s;
133
55
    uint32_t *factor1 = &ctx->idct_factor[0],
134
55
             *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
135
136
55
    if (DV_PROFILE_IS_HD(d)) {
137
        /* quantization quanta by QNO for DV100 */
138
        static const uint8_t dv100_qstep[16] = {
139
            1, /* QNO = 0 and 1 both have no quantization */
140
            1,
141
            2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
142
        };
143
        const uint16_t *iweight1, *iweight2;
144
145
16
        if (d->height == 720) {
146
8
            iweight1 = &dv_iweight_720_y[0];
147
8
            iweight2 = &dv_iweight_720_c[0];
148
        } else {
149
8
            iweight1 = &dv_iweight_1080_y[0];
150
8
            iweight2 = &dv_iweight_1080_c[0];
151
        }
152
80
        for (c = 0; c < 4; c++) {
153
1088
            for (s = 0; s < 16; s++) {
154
66560
                for (i = 0; i < 64; i++) {
155
65536
                    *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
156
65536
                    *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
157
                }
158
            }
159
        }
160
    } else {
161
        static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
162
39
        const uint16_t *iweight1 = &dv_iweight_88[0];
163
117
        for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
164
1794
            for (s = 0; s < 22; s++) {
165
8580
                for (i = c = 0; c < 4; c++) {
166
116688
                    for (; i < dv_quant_areas[c]; i++) {
167
109824
                        *factor1   = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
168
109824
                        *factor2++ = (*factor1++) << 1;
169
                    }
170
                }
171
            }
172
        }
173
    }
174
55
}
175
176
57
static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
177
{
178
57
    DVVideoContext *s = avctx->priv_data;
179
    int i;
180
181
57
    ff_idctdsp_init(&s->idsp, avctx);
182
183
3705
    for (i = 0; i < 64; i++)
184
3648
        s->dv_zigzag[0][i] = s->idsp.idct_permutation[ff_zigzag_direct[i]];
185
186
57
    if (avctx->lowres){
187
        for (i = 0; i < 64; i++){
188
            int j = ff_dv_zigzag248_direct[i];
189
            s->dv_zigzag[1][i] = s->idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
190
        }
191
    }else
192
57
        memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
193
194
57
    s->idct_put[0] = s->idsp.idct_put;
195
57
    s->idct_put[1] = ff_simple_idct248_put;
196
197
57
    return ff_dvvideo_init(avctx);
198
}
199
200
/* decode AC coefficients */
201
30293796
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
202
{
203
30293796
    int last_index = gb->size_in_bits;
204
30293796
    const uint8_t  *scan_table   = mb->scan_table;
205
30293796
    const uint32_t *factor_table = mb->factor_table;
206
30293796
    int pos                      = mb->pos;
207
30293796
    int partial_bit_count        = mb->partial_bit_count;
208
    int level, run, vlc_len, index;
209
210
30293796
    OPEN_READER_NOSIZE(re, gb);
211
30293796
    UPDATE_CACHE(re, gb);
212
213
    /* if we must parse a partial VLC, we do it here */
214
30293796
    if (partial_bit_count > 0) {
215
6979288
        re_cache              = re_cache >> partial_bit_count |
216
6979288
                                mb->partial_bit_buffer;
217
6979288
        re_index             -= partial_bit_count;
218
6979288
        mb->partial_bit_count = 0;
219
    }
220
221
    /* get the AC coefficients until last_index is reached */
222
    for (;;) {
223
204839777
        ff_dlog(NULL, "%2d: bits=%04"PRIx32" index=%u\n",
224
                pos, SHOW_UBITS(re, gb, 16), re_index);
225
        /* our own optimized GET_RL_VLC */
226
235133573
        index   = NEG_USR32(re_cache, TEX_VLC_BITS);
227
235133573
        vlc_len = ff_dv_rl_vlc[index].len;
228
235133573
        if (vlc_len < 0) {
229
17868057
            index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
230
17868057
                    ff_dv_rl_vlc[index].level;
231
17868057
            vlc_len = TEX_VLC_BITS - vlc_len;
232
        }
233
235133573
        level = ff_dv_rl_vlc[index].level;
234
235133573
        run   = ff_dv_rl_vlc[index].run;
235
236
        /* gotta check if we're still within gb boundaries */
237
235133573
        if (re_index + vlc_len > last_index) {
238
            /* should be < 16 bits otherwise a codeword could have been parsed */
239
8371918
            mb->partial_bit_count  = last_index - re_index;
240
8371918
            mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
241
8371918
            re_index               = last_index;
242
8371918
            break;
243
        }
244
226761655
        re_index += vlc_len;
245
246
        ff_dlog(NULL, "run=%d level=%d\n", run, level);
247
226761655
        pos += run;
248
226761655
        if (pos >= 64)
249
21921878
            break;
250
251
204839777
        level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
252
                dv_iweight_bits;
253
204839777
        block[scan_table[pos]] = level;
254
255
204839777
        UPDATE_CACHE(re, gb);
256
    }
257
30293796
    CLOSE_READER(re, gb);
258
30293796
    mb->pos = pos;
259
30293796
}
260
261
16614456
static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
262
{
263
16614456
    int bits_left = get_bits_left(gb);
264
51997335
    while (bits_left >= MIN_CACHE_BITS) {
265
35382879
        put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
266
35382879
        bits_left -= MIN_CACHE_BITS;
267
    }
268
16614456
    if (bits_left > 0)
269
16056772
        put_bits(pb, bits_left, get_bits(gb, bits_left));
270
16614456
}
271
272
static av_always_inline void put_block_8x4(int16_t *block, uint8_t *av_restrict p, int stride)
273
{
274
    int i, j;
275
276
    for (i = 0; i < 4; i++) {
277
        for (j = 0; j < 8; j++)
278
            p[j] = av_clip_uint8(block[j]);
279
        block += 8;
280
        p += stride;
281
    }
282
}
283
284
static void dv100_idct_put_last_row_field_chroma(DVVideoContext *s, uint8_t *data,
285
                                                 int stride, int16_t *blocks)
286
{
287
    s->idsp.idct(blocks + 0*64);
288
    s->idsp.idct(blocks + 1*64);
289
290
    put_block_8x4(blocks+0*64,       data,              stride<<1);
291
    put_block_8x4(blocks+0*64 + 4*8, data + 8,          stride<<1);
292
    put_block_8x4(blocks+1*64,       data + stride,     stride<<1);
293
    put_block_8x4(blocks+1*64 + 4*8, data + 8 + stride, stride<<1);
294
}
295
296
static void dv100_idct_put_last_row_field_luma(DVVideoContext *s, uint8_t *data,
297
                                               int stride, int16_t *blocks)
298
{
299
    s->idsp.idct(blocks + 0*64);
300
    s->idsp.idct(blocks + 1*64);
301
    s->idsp.idct(blocks + 2*64);
302
    s->idsp.idct(blocks + 3*64);
303
304
    put_block_8x4(blocks+0*64,       data,               stride<<1);
305
    put_block_8x4(blocks+0*64 + 4*8, data + 16,          stride<<1);
306
    put_block_8x4(blocks+1*64,       data + 8,           stride<<1);
307
    put_block_8x4(blocks+1*64 + 4*8, data + 24,          stride<<1);
308
    put_block_8x4(blocks+2*64,       data + stride,      stride<<1);
309
    put_block_8x4(blocks+2*64 + 4*8, data + 16 + stride, stride<<1);
310
    put_block_8x4(blocks+3*64,       data + 8  + stride, stride<<1);
311
    put_block_8x4(blocks+3*64 + 4*8, data + 24 + stride, stride<<1);
312
}
313
314
/* mb_x and mb_y are in units of 8 pixels */
315
611604
static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
316
{
317
611604
    DVVideoContext *s = avctx->priv_data;
318
611604
    DVwork_chunk *work_chunk = arg;
319
    int quant, dc, dct_mode, class1, j;
320
    int mb_index, mb_x, mb_y, last_index;
321
    int y_stride, linesize;
322
    int16_t *block, *block1;
323
    int c_offset;
324
    uint8_t *y_ptr;
325
    const uint8_t *buf_ptr;
326
    PutBitContext pb, vs_pb;
327
    GetBitContext gb;
328
    BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
329
611604
    LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
330
611604
    LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80     + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
331
611604
    LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
332
611604
    const int log2_blocksize = 3-s->avctx->lowres;
333
    int is_field_mode[5];
334
611604
    int vs_bit_buffer_damaged = 0;
335
611604
    int mb_bit_buffer_damaged[5] = {0};
336
611604
    int retried = 0;
337
    int sta;
338
339
    av_assert1((((int) mb_bit_buffer) & 7) == 0);
340
    av_assert1((((int) vs_bit_buffer) & 7) == 0);
341
342
611605
retry:
343
344
611605
    memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
345
346
    /* pass 1: read DC and AC coefficients in blocks */
347
611605
    buf_ptr = &s->buf[work_chunk->buf_offset * 80];
348
611605
    block1  = &sblock[0][0];
349
611605
    mb1     = mb_data;
350
611605
    init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
351
3669630
    for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
352
        /* skip header */
353
3058025
        quant    = buf_ptr[3] & 0x0f;
354
3058025
        if (avctx->error_concealment) {
355
3058025
            if ((buf_ptr[3] >> 4) == 0x0E)
356
                vs_bit_buffer_damaged = 1;
357
3058025
            if (!mb_index) {
358
611605
                sta = buf_ptr[3] >> 4;
359
2446420
            } else if (sta != (buf_ptr[3] >> 4))
360
                vs_bit_buffer_damaged = 1;
361
        }
362
3058025
        buf_ptr += 4;
363
3058025
        init_put_bits(&pb, mb_bit_buffer, 80);
364
3058025
        mb    = mb1;
365
3058025
        block = block1;
366
3058025
        is_field_mode[mb_index] = 0;
367
24986375
        for (j = 0; j < s->sys->bpm; j++) {
368
21928350
            last_index = s->sys->block_sizes[j];
369
21928350
            init_get_bits(&gb, buf_ptr, last_index);
370
371
            /* get the DC */
372
21928350
            dc       = get_sbits(&gb, 9);
373
21928350
            dct_mode = get_bits1(&gb);
374
21928350
            class1   = get_bits(&gb, 2);
375
21928350
            if (DV_PROFILE_IS_HD(s->sys)) {
376
14320800
                mb->idct_put     = s->idct_put[0];
377
14320800
                mb->scan_table   = s->dv_zigzag[0];
378
14320800
                mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
379
14320800
                                                   class1       * 16 * 64 +
380
14320800
                                                   quant             * 64];
381

14320800
                is_field_mode[mb_index] |= !j && dct_mode;
382
            } else {
383

7607550
                mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
384
7607550
                mb->scan_table   = s->dv_zigzag[dct_mode];
385
7607550
                mb->factor_table =
386
7607550
                    &s->idct_factor[(class1 == 3)               * 2 * 22 * 64 +
387
7607550
                                    dct_mode                        * 22 * 64 +
388
7607550
                                    (quant + ff_dv_quant_offset[class1]) * 64];
389
            }
390
21928350
            dc = dc * 4;
391
            /* convert to unsigned because 128 is not added in the
392
             * standard IDCT */
393
21928350
            dc                   += 1024;
394
21928350
            block[0]              = dc;
395
21928350
            buf_ptr              += last_index >> 3;
396
21928350
            mb->pos               = 0;
397
21928350
            mb->partial_bit_count = 0;
398
399
            ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
400
21928350
            dv_decode_ac(&gb, mb, block);
401
402
            /* write the remaining bits in a new buffer only if the
403
             * block is finished */
404
21928350
            if (mb->pos >= 64)
405
14552928
                bit_copy(&pb, &gb);
406

21928350
            if (mb->pos >= 64 && mb->pos < 127)
407
                vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
408
409
21928350
            block += 64;
410
21928350
            mb++;
411
        }
412
413
3058025
        if (mb_bit_buffer_damaged[mb_index] > 0)
414
1
            continue;
415
416
        /* pass 2: we can do it just after */
417
        ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
418
3058024
        block = block1;
419
3058024
        mb    = mb1;
420
3058024
        init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
421
3058024
        put_bits32(&pb, 0); // padding must be zeroed
422
3058024
        flush_put_bits(&pb);
423
19532649
        for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
424

17471121
            if (mb->pos < 64 && get_bits_left(&gb) > 0) {
425
4487907
                dv_decode_ac(&gb, mb, block);
426
                /* if still not finished, no need to parse other blocks */
427
4487907
                if (mb->pos < 64)
428
996496
                    break;
429
3491411
                if (mb->pos < 127)
430
2
                    vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
431
            }
432
        }
433
        /* all blocks are finished, so the extra bytes can be used at
434
         * the video segment level */
435
3058024
        if (j >= s->sys->bpm)
436
2061528
            bit_copy(&vs_pb, &gb);
437
    }
438
439
    /* we need a pass over the whole video segment */
440
    ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
441
611605
    block = &sblock[0][0];
442
611605
    mb    = mb_data;
443
611605
    init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
444
611605
    put_bits32(&vs_pb, 0); // padding must be zeroed
445
611605
    flush_put_bits(&vs_pb);
446
3669630
    for (mb_index = 0; mb_index < 5; mb_index++) {
447
24986375
        for (j = 0; j < s->sys->bpm; j++) {
448

21928350
            if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
449
                ff_dlog(avctx, "start %d:%d\n", mb_index, j);
450
3877539
                dv_decode_ac(&gb, mb, block);
451
            }
452
453

21928350
            if (mb->pos >= 64 && mb->pos < 127) {
454
2
                av_log(avctx, AV_LOG_ERROR,
455
2
                       "AC EOB marker is absent pos=%d\n", mb->pos);
456
2
                vs_bit_buffer_damaged = 1;
457
            }
458
21928350
            block += 64;
459
21928350
            mb++;
460
        }
461
    }
462

611605
    if (vs_bit_buffer_damaged && !retried) {
463
1
        av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
464
1
        retried = 1;
465
1
        goto retry;
466
    }
467
468
    /* compute idct and place blocks */
469
611604
    block = &sblock[0][0];
470
611604
    mb    = mb_data;
471
3669624
    for (mb_index = 0; mb_index < 5; mb_index++) {
472
3058020
        dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
473
474
        /* idct_put'ting luminance */
475
3058020
        if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P)                      ||
476

2677320
            (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
477

2670636
            (s->sys->height >= 720 && mb_y != 134)) {
478
2168304
            y_stride = (s->frame->linesize[0] <<
479
2168304
                        ((!is_field_mode[mb_index]) * log2_blocksize));
480
        } else {
481
889716
            y_stride = (2 << log2_blocksize);
482
        }
483
3058020
        y_ptr    = s->frame->data[0] +
484
3058020
                   ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
485

3058020
        if (mb_y == 134 && is_field_mode[mb_index]) {
486
            dv100_idct_put_last_row_field_luma(s, y_ptr, s->frame->linesize[0], block);
487
        } else {
488
3058020
            linesize = s->frame->linesize[0] << is_field_mode[mb_index];
489
3058020
            mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
490
3058020
            if (s->sys->video_stype == 4) { /* SD 422 */
491
586440
                mb[2].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 2 * 64);
492
            } else {
493
2471580
                mb[1].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 1 * 64);
494
2471580
                mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2 * 64);
495
2471580
                mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
496
            }
497
        }
498
3058020
        mb    += 4;
499
3058020
        block += 4 * 64;
500
501
        /* idct_put'ting chrominance */
502
6116040
        c_offset = (((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
503
3058020
                     (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
504
9174060
        for (j = 2; j; j--) {
505
6116040
            uint8_t *c_ptr = s->frame->data[j] + c_offset;
506

6116040
            if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
507
                uint64_t aligned_pixels[64 / 8];
508
13368
                uint8_t *pixels = (uint8_t *) aligned_pixels;
509
                uint8_t *c_ptr1, *ptr1;
510
                int x, y;
511
13368
                mb->idct_put(pixels, 8, block);
512
120312
                for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
513
106944
                    ptr1   = pixels + ((1 << (log2_blocksize))>>1);
514
106944
                    c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
515
534720
                    for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
516
427776
                        c_ptr[x]  = pixels[x];
517
427776
                        c_ptr1[x] = ptr1[x];
518
                    }
519
                }
520
13368
                block += 64;
521
13368
                mb++;
522
            } else {
523
6102672
                y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
524
6084312
                    s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
525

6102672
                if (mb_y == 134 && is_field_mode[mb_index]) {
526
                    dv100_idct_put_last_row_field_chroma(s, c_ptr, s->frame->linesize[j], block);
527
                    mb += 2;
528
                    block += 2*64;
529
                } else {
530
6102672
                    linesize = s->frame->linesize[j] << is_field_mode[mb_index];
531
6102672
                    (mb++)->idct_put(c_ptr, linesize, block);
532
6102672
                    block += 64;
533
6102672
                    if (s->sys->bpm == 8) {
534
3580200
                        (mb++)->idct_put(c_ptr + y_stride, linesize, block);
535
3580200
                        block += 64;
536
                    }
537
                }
538
            }
539
        }
540
    }
541
611604
    return 0;
542
}
543
544
/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
545
 * 144000 bytes for PAL - or twice those for 50Mbps) */
546
1016
static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
547
                                int *got_frame, AVPacket *avpkt)
548
{
549
1016
    uint8_t *buf = avpkt->data;
550
1016
    int buf_size = avpkt->size;
551
1016
    DVVideoContext *s = avctx->priv_data;
552
1016
    ThreadFrame frame = { .f = data };
553
    const uint8_t *vsc_pack;
554
    int apt, is16_9, ret;
555
    const AVDVProfile *sys;
556
557
1016
    sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
558

1016
    if (!sys || buf_size < sys->frame_size) {
559
        av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
560
        return -1; /* NOTE: we only accept several full frames */
561
    }
562
563
1016
    if (sys != s->sys) {
564
55
        ret = ff_dv_init_dynamic_tables(s, sys);
565
55
        if (ret < 0) {
566
            av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
567
            return ret;
568
        }
569
55
        dv_init_weight_tables(s, sys);
570
55
        s->sys = sys;
571
    }
572
573
1016
    s->frame            = frame.f;
574
1016
    frame.f->key_frame  = 1;
575
1016
    frame.f->pict_type  = AV_PICTURE_TYPE_I;
576
1016
    avctx->pix_fmt      = s->sys->pix_fmt;
577
1016
    avctx->framerate    = av_inv_q(s->sys->time_base);
578
579
1016
    ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
580
1016
    if (ret < 0)
581
        return ret;
582
583
    /* Determine the codec's sample_aspect ratio from the packet */
584
1016
    vsc_pack = buf + 80 * 5 + 48 + 5;
585
1016
    if (*vsc_pack == dv_video_control) {
586
1016
        apt    = buf[4] & 0x07;
587

1259
        is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
588
243
                 (!apt && (vsc_pack[2] & 0x07) == 0x07);
589
1016
        ff_set_sar(avctx, s->sys->sar[is16_9]);
590
    }
591
592
1016
    if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
593
        return ret;
594
595
    /* Determine the codec's field order from the packet */
596
1016
    if ( *vsc_pack == dv_video_control ) {
597
1016
        if (avctx->height == 720) {
598
204
            frame.f->interlaced_frame = 0;
599
204
            frame.f->top_field_first = 0;
600
812
        } else if (avctx->height == 1080) {
601
204
            frame.f->interlaced_frame = 1;
602
204
            frame.f->top_field_first = (vsc_pack[3] & 0x40) == 0x40;
603
        } else {
604
608
            frame.f->interlaced_frame = (vsc_pack[3] & 0x10) == 0x10;
605
608
            frame.f->top_field_first = !(vsc_pack[3] & 0x40);
606
        }
607
    }
608
609
1016
    s->buf = buf;
610
1016
    avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
611
                   dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
612
613
1016
    emms_c();
614
615
    /* return image */
616
1016
    *got_frame = 1;
617
618
1016
    return s->sys->frame_size;
619
}
620
621
AVCodec ff_dvvideo_decoder = {
622
    .name           = "dvvideo",
623
    .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
624
    .type           = AVMEDIA_TYPE_VIDEO,
625
    .id             = AV_CODEC_ID_DVVIDEO,
626
    .priv_data_size = sizeof(DVVideoContext),
627
    .init           = dvvideo_decode_init,
628
    .decode         = dvvideo_decode_frame,
629
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
630
    .max_lowres     = 3,
631
};