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

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

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

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

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

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

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

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

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

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

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

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

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

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

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