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/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 static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
 132 {
 133     int j, i, c, s;
 134     uint32_t *factor1 = &ctx->idct_factor[0],
 135              *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
 136
 137     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         if (d->height == 720) {
 147             iweight1 = &dv_iweight_720_y[0];
 148             iweight2 = &dv_iweight_720_c[0];
 149         } else {
 150             iweight1 = &dv_iweight_1080_y[0];
 151             iweight2 = &dv_iweight_1080_c[0];
 152         }
 153         for (c = 0; c < 4; c++) {
 154             for (s = 0; s < 16; s++) {
 155                 for (i = 0; i < 64; i++) {
 156                     *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
 157                     *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         const uint16_t *iweight1 = &dv_iweight_88[0];
 164         for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
 165             for (s = 0; s < 22; s++) {
 166                 for (i = c = 0; c < 4; c++) {
 167                     for (; i < dv_quant_areas[c]; i++) {
 168                         *factor1   = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
 169                         *factor2++ = (*factor1++) << 1;
 170                     }
 171                 }
 172             }
 173         }
 174     }
 175 }
 176
 177 static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
 178 {
 179     DVVideoContext *s = avctx->priv_data;
 180     int i;
 181
 182     ff_idctdsp_init(&s->idsp, avctx);
 183
 184     for (i = 0; i < 64; i++)
 185         s->dv_zigzag[0][i] = s->idsp.idct_permutation[ff_zigzag_direct[i]];
 186
 187     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         memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
 194
 195     s->idct_put[0] = s->idsp.idct_put;
 196     s->idct_put[1] = ff_simple_idct248_put;
 197
 198     return ff_dvvideo_init(avctx);
 199 }
 200
 201 /* decode AC coefficients */
 202 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
 203 {
 204     int last_index = gb->size_in_bits;
 205     const uint8_t  *scan_table   = mb->scan_table;
 206     const uint32_t *factor_table = mb->factor_table;
 207     int pos                      = mb->pos;
 208     int partial_bit_count        = mb->partial_bit_count;
 209     int level, run, vlc_len, index;
 210
 211     OPEN_READER_NOSIZE(re, gb);
 212     UPDATE_CACHE(re, gb);
 213
 214     /* if we must parse a partial VLC, we do it here */
 215     if (partial_bit_count > 0) {
 216         re_cache              = re_cache >> partial_bit_count |
 217                                 mb->partial_bit_buffer;
 218         re_index             -= partial_bit_count;
 219         mb->partial_bit_count = 0;
 220     }
 221
 222     /* get the AC coefficients until last_index is reached */
 223     for (;;) {
 224         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         index   = NEG_USR32(re_cache, TEX_VLC_BITS);
 228         vlc_len = ff_dv_rl_vlc[index].len;
 229         if (vlc_len < 0) {
 230             index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
 231                     ff_dv_rl_vlc[index].level;
 232             vlc_len = TEX_VLC_BITS - vlc_len;
 233         }
 234         level = ff_dv_rl_vlc[index].level;
 235         run   = ff_dv_rl_vlc[index].run;
 236
 237         /* gotta check if we're still within gb boundaries */
 238         if (re_index + vlc_len > last_index) {
 239             /* should be < 16 bits otherwise a codeword could have been parsed */
 240             mb->partial_bit_count  = last_index - re_index;
 241             mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
 242             re_index               = last_index;
 243             break;
 244         }
 245         re_index += vlc_len;
 246
 247         ff_dlog(NULL, "run=%d level=%d\n", run, level);
 248         pos += run;
 249         if (pos >= 64)
 250             break;
 251
 252         level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
 253                 dv_iweight_bits;
 254         block[scan_table[pos]] = level;
 255
 256         UPDATE_CACHE(re, gb);
 257     }
 258     CLOSE_READER(re, gb);
 259     mb->pos = pos;
 260 }
 261
 262 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
 263 {
 264     int bits_left = get_bits_left(gb);
 265     while (bits_left >= MIN_CACHE_BITS) {
 266         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
 267         bits_left -= MIN_CACHE_BITS;
 268     }
 269     if (bits_left > 0)
 270         put_bits(pb, bits_left, get_bits(gb, bits_left));
 271 }
 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 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 const 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 };