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     const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;
 276
 277     for (i = 0; i < 4; i++) {
 278         for (j = 0; j < 8; j++)
 279             p[j] = cm[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 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
 317 {
 318     DVVideoContext *s = avctx->priv_data;
 319     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     LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
 331     LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80     + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
 332     LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
 333     const int log2_blocksize = 3-s->avctx->lowres;
 334     int is_field_mode[5];
 335     int vs_bit_buffer_damaged = 0;
 336     int mb_bit_buffer_damaged[5] = {0};
 337     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 retry:
 344
 345     memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
 346
 347     /* pass 1: read DC and AC coefficients in blocks */
 348     buf_ptr = &s->buf[work_chunk->buf_offset * 80];
 349     block1  = &sblock[0][0];
 350     mb1     = mb_data;
 351     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
 352     for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
 353         /* skip header */
 354         quant    = buf_ptr[3] & 0x0f;
 355         if (avctx->error_concealment) {
 356             if ((buf_ptr[3] >> 4) == 0x0E)
 357                 vs_bit_buffer_damaged = 1;
 358             if (!mb_index) {
 359                 sta = buf_ptr[3] >> 4;
 360             } else if (sta != (buf_ptr[3] >> 4))
 361                 vs_bit_buffer_damaged = 1;
 362         }
 363         buf_ptr += 4;
 364         init_put_bits(&pb, mb_bit_buffer, 80);
 365         mb    = mb1;
 366         block = block1;
 367         is_field_mode[mb_index] = 0;
 368         for (j = 0; j < s->sys->bpm; j++) {
 369             last_index = s->sys->block_sizes[j];
 370             init_get_bits(&gb, buf_ptr, last_index);
 371
 372             /* get the DC */
 373             dc       = get_sbits(&gb, 9);
 374             dct_mode = get_bits1(&gb);
 375             class1   = get_bits(&gb, 2);
 376             if (DV_PROFILE_IS_HD(s->sys)) {
 377                 mb->idct_put     = s->idct_put[0];
 378                 mb->scan_table   = s->dv_zigzag[0];
 379                 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
 380                                                    class1       * 16 * 64 +
 381                                                    quant             * 64];
 382                 is_field_mode[mb_index] |= !j && dct_mode;
 383             } else {
 384                 mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
 385                 mb->scan_table   = s->dv_zigzag[dct_mode];
 386                 mb->factor_table =
 387                     &s->idct_factor[(class1 == 3)               * 2 * 22 * 64 +
 388                                     dct_mode                        * 22 * 64 +
 389                                     (quant + ff_dv_quant_offset[class1]) * 64];
 390             }
 391             dc = dc * 4;
 392             /* convert to unsigned because 128 is not added in the
 393              * standard IDCT */
 394             dc                   += 1024;
 395             block[0]              = dc;
 396             buf_ptr              += last_index >> 3;
 397             mb->pos               = 0;
 398             mb->partial_bit_count = 0;
 399
 400             ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
 401             dv_decode_ac(&gb, mb, block);
 402
 403             /* write the remaining bits in a new buffer only if the
 404              * block is finished */
 405             if (mb->pos >= 64)
 406                 bit_copy(&pb, &gb);
 407             if (mb->pos >= 64 && mb->pos < 127)
 408                 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
 409
 410             block += 64;
 411             mb++;
 412         }
 413
 414         if (mb_bit_buffer_damaged[mb_index] > 0)
 415             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         block = block1;
 420         mb    = mb1;
 421         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
 422         put_bits32(&pb, 0); // padding must be zeroed
 423         flush_put_bits(&pb);
 424         for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
 425             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
 426                 dv_decode_ac(&gb, mb, block);
 427                 /* if still not finished, no need to parse other blocks */
 428                 if (mb->pos < 64)
 429                     break;
 430                 if (mb->pos < 127)
 431                     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         if (j >= s->sys->bpm)
 437             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     block = &sblock[0][0];
 443     mb    = mb_data;
 444     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
 445     put_bits32(&vs_pb, 0); // padding must be zeroed
 446     flush_put_bits(&vs_pb);
 447     for (mb_index = 0; mb_index < 5; mb_index++) {
 448         for (j = 0; j < s->sys->bpm; j++) {
 449             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                 dv_decode_ac(&gb, mb, block);
 452             }
 453
 454             if (mb->pos >= 64 && mb->pos < 127) {
 455                 av_log(avctx, AV_LOG_ERROR,
 456                        "AC EOB marker is absent pos=%d\n", mb->pos);
 457                 vs_bit_buffer_damaged = 1;
 458             }
 459             block += 64;
 460             mb++;
 461         }
 462     }
 463     if (vs_bit_buffer_damaged && !retried) {
 464         av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
 465         retried = 1;
 466         goto retry;
 467     }
 468
 469     /* compute idct and place blocks */
 470     block = &sblock[0][0];
 471     mb    = mb_data;
 472     for (mb_index = 0; mb_index < 5; mb_index++) {
 473         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
 474
 475         /* idct_put'ting luminance */
 476         if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P)                      ||
 477             (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
 478             (s->sys->height >= 720 && mb_y != 134)) {
 479             y_stride = (s->frame->linesize[0] <<
 480                         ((!is_field_mode[mb_index]) * log2_blocksize));
 481         } else {
 482             y_stride = (2 << log2_blocksize);
 483         }
 484         y_ptr    = s->frame->data[0] +
 485                    ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
 486         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             linesize = s->frame->linesize[0] << is_field_mode[mb_index];
 490             mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
 491             if (s->sys->video_stype == 4) { /* SD 422 */
 492                 mb[2].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 2 * 64);
 493             } else {
 494                 mb[1].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 1 * 64);
 495                 mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2 * 64);
 496                 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
 497             }
 498         }
 499         mb    += 4;
 500         block += 4 * 64;
 501
 502         /* idct_put'ting chrominance */
 503         c_offset = (((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
 504                      (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
 505         for (j = 2; j; j--) {
 506             uint8_t *c_ptr = s->frame->data[j] + c_offset;
 507             if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 508                 uint64_t aligned_pixels[64 / 8];
 509                 uint8_t *pixels = (uint8_t *) aligned_pixels;
 510                 uint8_t *c_ptr1, *ptr1;
 511                 int x, y;
 512                 mb->idct_put(pixels, 8, block);
 513                 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
 514                     ptr1   = pixels + ((1 << (log2_blocksize))>>1);
 515                     c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
 516                     for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
 517                         c_ptr[x]  = pixels[x];
 518                         c_ptr1[x] = ptr1[x];
 519                     }
 520                 }
 521                 block += 64;
 522                 mb++;
 523             } else {
 524                 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
 525                     s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
 526                 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                     linesize = s->frame->linesize[j] << is_field_mode[mb_index];
 532                     (mb++)->idct_put(c_ptr, linesize, block);
 533                     block += 64;
 534                     if (s->sys->bpm == 8) {
 535                         (mb++)->idct_put(c_ptr + y_stride, linesize, block);
 536                         block += 64;
 537                     }
 538                 }
 539             }
 540         }
 541     }
 542     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 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
 548                                 int *got_frame, AVPacket *avpkt)
 549 {
 550     uint8_t *buf = avpkt->data;
 551     int buf_size = avpkt->size;
 552     DVVideoContext *s = avctx->priv_data;
 553     ThreadFrame frame = { .f = data };
 554     const uint8_t *vsc_pack;
 555     int apt, is16_9, ret;
 556     const AVDVProfile *sys;
 557
 558     sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
 559     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     if (sys != s->sys) {
 565         ret = ff_dv_init_dynamic_tables(s, sys);
 566         if (ret < 0) {
 567             av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
 568             return ret;
 569         }
 570         dv_init_weight_tables(s, sys);
 571         s->sys = sys;
 572     }
 573
 574     s->frame            = frame.f;
 575     frame.f->key_frame  = 1;
 576     frame.f->pict_type  = AV_PICTURE_TYPE_I;
 577     avctx->pix_fmt      = s->sys->pix_fmt;
 578     avctx->framerate    = av_inv_q(s->sys->time_base);
 579
 580     ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
 581     if (ret < 0)
 582         return ret;
 583
 584     /* Determine the codec's sample_aspect ratio from the packet */
 585     vsc_pack = buf + 80 * 5 + 48 + 5;
 586     if (*vsc_pack == dv_video_control) {
 587         apt    = buf[4] & 0x07;
 588         is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
 589                  (!apt && (vsc_pack[2] & 0x07) == 0x07);
 590         ff_set_sar(avctx, s->sys->sar[is16_9]);
 591     }
 592
 593     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     if ( *vsc_pack == dv_video_control ) {
 598         if (avctx->height == 720) {
 599             frame.f->interlaced_frame = 0;
 600             frame.f->top_field_first = 0;
 601         } else if (avctx->height == 1080) {
 602             frame.f->interlaced_frame = 1;
 603             frame.f->top_field_first = (vsc_pack[3] & 0x40) == 0x40;
 604         } else {
 605             frame.f->interlaced_frame = (vsc_pack[3] & 0x10) == 0x10;
 606             frame.f->top_field_first = !(vsc_pack[3] & 0x40);
 607         }
 608     }
 609
 610     s->buf = buf;
 611     avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
 612                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
 613
 614     emms_c();
 615
 616     /* return image */
 617     *got_frame = 1;
 618
 619     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 };