git.sesse.net Git - ffmpeg/blob - libavcodec/dvdec.c

   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 static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
 131 {
 132     int j, i, c, s;
 133     uint32_t *factor1 = &ctx->idct_factor[0],
 134              *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
 135
 136     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         if (d->height == 720) {
 146             iweight1 = &dv_iweight_720_y[0];
 147             iweight2 = &dv_iweight_720_c[0];
 148         } else {
 149             iweight1 = &dv_iweight_1080_y[0];
 150             iweight2 = &dv_iweight_1080_c[0];
 151         }
 152         for (c = 0; c < 4; c++) {
 153             for (s = 0; s < 16; s++) {
 154                 for (i = 0; i < 64; i++) {
 155                     *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
 156                     *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         const uint16_t *iweight1 = &dv_iweight_88[0];
 163         for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
 164             for (s = 0; s < 22; s++) {
 165                 for (i = c = 0; c < 4; c++) {
 166                     for (; i < dv_quant_areas[c]; i++) {
 167                         *factor1   = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
 168                         *factor2++ = (*factor1++) << 1;
 169                     }
 170                 }
 171             }
 172         }
 173     }
 174 }
 175
 176 static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
 177 {
 178     DVVideoContext *s = avctx->priv_data;
 179     int i;
 180
 181     ff_idctdsp_init(&s->idsp, avctx);
 182
 183     for (i = 0; i < 64; i++)
 184         s->dv_zigzag[0][i] = s->idsp.idct_permutation[ff_zigzag_direct[i]];
 185
 186     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         memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
 193
 194     s->idct_put[0] = s->idsp.idct_put;
 195     s->idct_put[1] = ff_simple_idct248_put;
 196
 197     return ff_dvvideo_init(avctx);
 198 }
 199
 200 /* decode AC coefficients */
 201 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
 202 {
 203     int last_index = gb->size_in_bits;
 204     const uint8_t  *scan_table   = mb->scan_table;
 205     const uint32_t *factor_table = mb->factor_table;
 206     int pos                      = mb->pos;
 207     int partial_bit_count        = mb->partial_bit_count;
 208     int level, run, vlc_len, index;
 209
 210     OPEN_READER_NOSIZE(re, gb);
 211     UPDATE_CACHE(re, gb);
 212
 213     /* if we must parse a partial VLC, we do it here */
 214     if (partial_bit_count > 0) {
 215         re_cache              = re_cache >> partial_bit_count |
 216                                 mb->partial_bit_buffer;
 217         re_index             -= partial_bit_count;
 218         mb->partial_bit_count = 0;
 219     }
 220
 221     /* get the AC coefficients until last_index is reached */
 222     for (;;) {
 223         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         index   = NEG_USR32(re_cache, TEX_VLC_BITS);
 227         vlc_len = ff_dv_rl_vlc[index].len;
 228         if (vlc_len < 0) {
 229             index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
 230                     ff_dv_rl_vlc[index].level;
 231             vlc_len = TEX_VLC_BITS - vlc_len;
 232         }
 233         level = ff_dv_rl_vlc[index].level;
 234         run   = ff_dv_rl_vlc[index].run;
 235
 236         /* gotta check if we're still within gb boundaries */
 237         if (re_index + vlc_len > last_index) {
 238             /* should be < 16 bits otherwise a codeword could have been parsed */
 239             mb->partial_bit_count  = last_index - re_index;
 240             mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
 241             re_index               = last_index;
 242             break;
 243         }
 244         re_index += vlc_len;
 245
 246         ff_dlog(NULL, "run=%d level=%d\n", run, level);
 247         pos += run;
 248         if (pos >= 64)
 249             break;
 250
 251         level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
 252                 dv_iweight_bits;
 253         block[scan_table[pos]] = level;
 254
 255         UPDATE_CACHE(re, gb);
 256     }
 257     CLOSE_READER(re, gb);
 258     mb->pos = pos;
 259 }
 260
 261 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
 262 {
 263     int bits_left = get_bits_left(gb);
 264     while (bits_left >= MIN_CACHE_BITS) {
 265         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
 266         bits_left -= MIN_CACHE_BITS;
 267     }
 268     if (bits_left > 0)
 269         put_bits(pb, bits_left, get_bits(gb, bits_left));
 270 }
 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 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
 316 {
 317     DVVideoContext *s = avctx->priv_data;
 318     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     LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
 330     LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80     + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
 331     LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
 332     const int log2_blocksize = 3-s->avctx->lowres;
 333     int is_field_mode[5];
 334     int vs_bit_buffer_damaged = 0;
 335     int mb_bit_buffer_damaged[5] = {0};
 336     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 retry:
 343
 344     memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
 345
 346     /* pass 1: read DC and AC coefficients in blocks */
 347     buf_ptr = &s->buf[work_chunk->buf_offset * 80];
 348     block1  = &sblock[0][0];
 349     mb1     = mb_data;
 350     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
 351     for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
 352         /* skip header */
 353         quant    = buf_ptr[3] & 0x0f;
 354         if (avctx->error_concealment) {
 355             if ((buf_ptr[3] >> 4) == 0x0E)
 356                 vs_bit_buffer_damaged = 1;
 357             if (!mb_index) {
 358                 sta = buf_ptr[3] >> 4;
 359             } else if (sta != (buf_ptr[3] >> 4))
 360                 vs_bit_buffer_damaged = 1;
 361         }
 362         buf_ptr += 4;
 363         init_put_bits(&pb, mb_bit_buffer, 80);
 364         mb    = mb1;
 365         block = block1;
 366         is_field_mode[mb_index] = 0;
 367         for (j = 0; j < s->sys->bpm; j++) {
 368             last_index = s->sys->block_sizes[j];
 369             init_get_bits(&gb, buf_ptr, last_index);
 370
 371             /* get the DC */
 372             dc       = get_sbits(&gb, 9);
 373             dct_mode = get_bits1(&gb);
 374             class1   = get_bits(&gb, 2);
 375             if (DV_PROFILE_IS_HD(s->sys)) {
 376                 mb->idct_put     = s->idct_put[0];
 377                 mb->scan_table   = s->dv_zigzag[0];
 378                 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
 379                                                    class1       * 16 * 64 +
 380                                                    quant             * 64];
 381                 is_field_mode[mb_index] |= !j && dct_mode;
 382             } else {
 383                 mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
 384                 mb->scan_table   = s->dv_zigzag[dct_mode];
 385                 mb->factor_table =
 386                     &s->idct_factor[(class1 == 3)               * 2 * 22 * 64 +
 387                                     dct_mode                        * 22 * 64 +
 388                                     (quant + ff_dv_quant_offset[class1]) * 64];
 389             }
 390             dc = dc * 4;
 391             /* convert to unsigned because 128 is not added in the
 392              * standard IDCT */
 393             dc                   += 1024;
 394             block[0]              = dc;
 395             buf_ptr              += last_index >> 3;
 396             mb->pos               = 0;
 397             mb->partial_bit_count = 0;
 398
 399             ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
 400             dv_decode_ac(&gb, mb, block);
 401
 402             /* write the remaining bits in a new buffer only if the
 403              * block is finished */
 404             if (mb->pos >= 64)
 405                 bit_copy(&pb, &gb);
 406             if (mb->pos >= 64 && mb->pos < 127)
 407                 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
 408
 409             block += 64;
 410             mb++;
 411         }
 412
 413         if (mb_bit_buffer_damaged[mb_index] > 0)
 414             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         block = block1;
 419         mb    = mb1;
 420         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
 421         put_bits32(&pb, 0); // padding must be zeroed
 422         flush_put_bits(&pb);
 423         for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
 424             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
 425                 dv_decode_ac(&gb, mb, block);
 426                 /* if still not finished, no need to parse other blocks */
 427                 if (mb->pos < 64)
 428                     break;
 429                 if (mb->pos < 127)
 430                     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         if (j >= s->sys->bpm)
 436             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     block = &sblock[0][0];
 442     mb    = mb_data;
 443     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
 444     put_bits32(&vs_pb, 0); // padding must be zeroed
 445     flush_put_bits(&vs_pb);
 446     for (mb_index = 0; mb_index < 5; mb_index++) {
 447         for (j = 0; j < s->sys->bpm; j++) {
 448             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                 dv_decode_ac(&gb, mb, block);
 451             }
 452
 453             if (mb->pos >= 64 && mb->pos < 127) {
 454                 av_log(avctx, AV_LOG_ERROR,
 455                        "AC EOB marker is absent pos=%d\n", mb->pos);
 456                 vs_bit_buffer_damaged = 1;
 457             }
 458             block += 64;
 459             mb++;
 460         }
 461     }
 462     if (vs_bit_buffer_damaged && !retried) {
 463         av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
 464         retried = 1;
 465         goto retry;
 466     }
 467
 468     /* compute idct and place blocks */
 469     block = &sblock[0][0];
 470     mb    = mb_data;
 471     for (mb_index = 0; mb_index < 5; mb_index++) {
 472         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
 473
 474         /* idct_put'ting luminance */
 475         if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P)                      ||
 476             (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
 477             (s->sys->height >= 720 && mb_y != 134)) {
 478             y_stride = (s->frame->linesize[0] <<
 479                         ((!is_field_mode[mb_index]) * log2_blocksize));
 480         } else {
 481             y_stride = (2 << log2_blocksize);
 482         }
 483         y_ptr    = s->frame->data[0] +
 484                    ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
 485         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             linesize = s->frame->linesize[0] << is_field_mode[mb_index];
 489             mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
 490             if (s->sys->video_stype == 4) { /* SD 422 */
 491                 mb[2].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 2 * 64);
 492             } else {
 493                 mb[1].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 1 * 64);
 494                 mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2 * 64);
 495                 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
 496             }
 497         }
 498         mb    += 4;
 499         block += 4 * 64;
 500
 501         /* idct_put'ting chrominance */
 502         c_offset = (((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
 503                      (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
 504         for (j = 2; j; j--) {
 505             uint8_t *c_ptr = s->frame->data[j] + c_offset;
 506             if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 507                 uint64_t aligned_pixels[64 / 8];
 508                 uint8_t *pixels = (uint8_t *) aligned_pixels;
 509                 uint8_t *c_ptr1, *ptr1;
 510                 int x, y;
 511                 mb->idct_put(pixels, 8, block);
 512                 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
 513                     ptr1   = pixels + ((1 << (log2_blocksize))>>1);
 514                     c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
 515                     for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
 516                         c_ptr[x]  = pixels[x];
 517                         c_ptr1[x] = ptr1[x];
 518                     }
 519                 }
 520                 block += 64;
 521                 mb++;
 522             } else {
 523                 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
 524                     s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
 525                 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                     linesize = s->frame->linesize[j] << is_field_mode[mb_index];
 531                     (mb++)->idct_put(c_ptr, linesize, block);
 532                     block += 64;
 533                     if (s->sys->bpm == 8) {
 534                         (mb++)->idct_put(c_ptr + y_stride, linesize, block);
 535                         block += 64;
 536                     }
 537                 }
 538             }
 539         }
 540     }
 541     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 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
 547                                 int *got_frame, AVPacket *avpkt)
 548 {
 549     uint8_t *buf = avpkt->data;
 550     int buf_size = avpkt->size;
 551     DVVideoContext *s = avctx->priv_data;
 552     ThreadFrame frame = { .f = data };
 553     const uint8_t *vsc_pack;
 554     int apt, is16_9, ret;
 555     const AVDVProfile *sys;
 556
 557     sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
 558     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     if (sys != s->sys) {
 564         ret = ff_dv_init_dynamic_tables(s, sys);
 565         if (ret < 0) {
 566             av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
 567             return ret;
 568         }
 569         dv_init_weight_tables(s, sys);
 570         s->sys = sys;
 571     }
 572
 573     s->frame            = frame.f;
 574     frame.f->key_frame  = 1;
 575     frame.f->pict_type  = AV_PICTURE_TYPE_I;
 576     avctx->pix_fmt      = s->sys->pix_fmt;
 577     avctx->framerate    = av_inv_q(s->sys->time_base);
 578
 579     ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
 580     if (ret < 0)
 581         return ret;
 582
 583     /* Determine the codec's sample_aspect ratio from the packet */
 584     vsc_pack = buf + 80 * 5 + 48 + 5;
 585     if (*vsc_pack == dv_video_control) {
 586         apt    = buf[4] & 0x07;
 587         is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
 588                  (!apt && (vsc_pack[2] & 0x07) == 0x07);
 589         ff_set_sar(avctx, s->sys->sar[is16_9]);
 590     }
 591
 592     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     if ( *vsc_pack == dv_video_control ) {
 597         if (avctx->height == 720) {
 598             frame.f->interlaced_frame = 0;
 599             frame.f->top_field_first = 0;
 600         } else if (avctx->height == 1080) {
 601             frame.f->interlaced_frame = 1;
 602             frame.f->top_field_first = (vsc_pack[3] & 0x40) == 0x40;
 603         } else {
 604             frame.f->interlaced_frame = (vsc_pack[3] & 0x10) == 0x10;
 605             frame.f->top_field_first = !(vsc_pack[3] & 0x40);
 606         }
 607     }
 608
 609     s->buf = buf;
 610     avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
 611                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
 612
 613     emms_c();
 614
 615     /* return image */
 616     *got_frame = 1;
 617
 618     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 };