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 "idctdsp.h"
  49 #include "internal.h"
  50 #include "put_bits.h"
  51 #include "simple_idct.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     IDCTDSPContext idsp;
 180     int i;
 181
 182     memset(&idsp,0, sizeof(idsp));
 183     ff_idctdsp_init(&idsp, avctx);
 184
 185     for (i = 0; i < 64; i++)
 186         s->dv_zigzag[0][i] = idsp.idct_permutation[ff_zigzag_direct[i]];
 187
 188     if (avctx->lowres){
 189         for (i = 0; i < 64; i++){
 190             int j = ff_dv_zigzag248_direct[i];
 191             s->dv_zigzag[1][i] = idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
 192         }
 193     }else
 194         memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
 195
 196     s->idct_put[0] = idsp.idct_put;
 197     s->idct_put[1] = ff_simple_idct248_put;
 198
 199     return ff_dvvideo_init(avctx);
 200 }
 201
 202 /* decode AC coefficients */
 203 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
 204 {
 205     int last_index = gb->size_in_bits;
 206     const uint8_t  *scan_table   = mb->scan_table;
 207     const uint32_t *factor_table = mb->factor_table;
 208     int pos                      = mb->pos;
 209     int partial_bit_count        = mb->partial_bit_count;
 210     int level, run, vlc_len, index;
 211
 212     OPEN_READER_NOSIZE(re, gb);
 213     UPDATE_CACHE(re, gb);
 214
 215     /* if we must parse a partial VLC, we do it here */
 216     if (partial_bit_count > 0) {
 217         re_cache              = re_cache >> partial_bit_count |
 218                                 mb->partial_bit_buffer;
 219         re_index             -= partial_bit_count;
 220         mb->partial_bit_count = 0;
 221     }
 222
 223     /* get the AC coefficients until last_index is reached */
 224     for (;;) {
 225         ff_dlog(NULL, "%2d: bits=%04"PRIx32" index=%u\n",
 226                 pos, SHOW_UBITS(re, gb, 16), re_index);
 227         /* our own optimized GET_RL_VLC */
 228         index   = NEG_USR32(re_cache, TEX_VLC_BITS);
 229         vlc_len = ff_dv_rl_vlc[index].len;
 230         if (vlc_len < 0) {
 231             index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
 232                     ff_dv_rl_vlc[index].level;
 233             vlc_len = TEX_VLC_BITS - vlc_len;
 234         }
 235         level = ff_dv_rl_vlc[index].level;
 236         run   = ff_dv_rl_vlc[index].run;
 237
 238         /* gotta check if we're still within gb boundaries */
 239         if (re_index + vlc_len > last_index) {
 240             /* should be < 16 bits otherwise a codeword could have been parsed */
 241             mb->partial_bit_count  = last_index - re_index;
 242             mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
 243             re_index               = last_index;
 244             break;
 245         }
 246         re_index += vlc_len;
 247
 248         ff_dlog(NULL, "run=%d level=%d\n", run, level);
 249         pos += run;
 250         if (pos >= 64)
 251             break;
 252
 253         level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
 254                 dv_iweight_bits;
 255         block[scan_table[pos]] = level;
 256
 257         UPDATE_CACHE(re, gb);
 258     }
 259     CLOSE_READER(re, gb);
 260     mb->pos = pos;
 261 }
 262
 263 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
 264 {
 265     int bits_left = get_bits_left(gb);
 266     while (bits_left >= MIN_CACHE_BITS) {
 267         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
 268         bits_left -= MIN_CACHE_BITS;
 269     }
 270     if (bits_left > 0)
 271         put_bits(pb, bits_left, get_bits(gb, bits_left));
 272 }
 273
 274 /* mb_x and mb_y are in units of 8 pixels */
 275 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
 276 {
 277     DVVideoContext *s = avctx->priv_data;
 278     DVwork_chunk *work_chunk = arg;
 279     int quant, dc, dct_mode, class1, j;
 280     int mb_index, mb_x, mb_y, last_index;
 281     int y_stride, linesize;
 282     int16_t *block, *block1;
 283     int c_offset;
 284     uint8_t *y_ptr;
 285     const uint8_t *buf_ptr;
 286     PutBitContext pb, vs_pb;
 287     GetBitContext gb;
 288     BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
 289     LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
 290     LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80     + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
 291     LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
 292     const int log2_blocksize = 3-s->avctx->lowres;
 293     int is_field_mode[5];
 294     int vs_bit_buffer_damaged = 0;
 295     int mb_bit_buffer_damaged[5] = {0};
 296     int retried = 0;
 297     int sta;
 298
 299     av_assert1((((int) mb_bit_buffer) & 7) == 0);
 300     av_assert1((((int) vs_bit_buffer) & 7) == 0);
 301
 302 retry:
 303
 304     memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
 305
 306     /* pass 1: read DC and AC coefficients in blocks */
 307     buf_ptr = &s->buf[work_chunk->buf_offset * 80];
 308     block1  = &sblock[0][0];
 309     mb1     = mb_data;
 310     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
 311     for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
 312         /* skip header */
 313         quant    = buf_ptr[3] & 0x0f;
 314         if (avctx->error_concealment) {
 315             if ((buf_ptr[3] >> 4) == 0x0E)
 316                 vs_bit_buffer_damaged = 1;
 317             if (!mb_index) {
 318                 sta = buf_ptr[3] >> 4;
 319             } else if (sta != (buf_ptr[3] >> 4))
 320                 vs_bit_buffer_damaged = 1;
 321         }
 322         buf_ptr += 4;
 323         init_put_bits(&pb, mb_bit_buffer, 80);
 324         mb    = mb1;
 325         block = block1;
 326         is_field_mode[mb_index] = 0;
 327         for (j = 0; j < s->sys->bpm; j++) {
 328             last_index = s->sys->block_sizes[j];
 329             init_get_bits(&gb, buf_ptr, last_index);
 330
 331             /* get the DC */
 332             dc       = get_sbits(&gb, 9);
 333             dct_mode = get_bits1(&gb);
 334             class1   = get_bits(&gb, 2);
 335             if (DV_PROFILE_IS_HD(s->sys)) {
 336                 mb->idct_put     = s->idct_put[0];
 337                 mb->scan_table   = s->dv_zigzag[0];
 338                 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
 339                                                    class1       * 16 * 64 +
 340                                                    quant             * 64];
 341                 is_field_mode[mb_index] |= !j && dct_mode;
 342             } else {
 343                 mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
 344                 mb->scan_table   = s->dv_zigzag[dct_mode];
 345                 mb->factor_table =
 346                     &s->idct_factor[(class1 == 3)               * 2 * 22 * 64 +
 347                                     dct_mode                        * 22 * 64 +
 348                                     (quant + ff_dv_quant_offset[class1]) * 64];
 349             }
 350             dc = dc * 4;
 351             /* convert to unsigned because 128 is not added in the
 352              * standard IDCT */
 353             dc                   += 1024;
 354             block[0]              = dc;
 355             buf_ptr              += last_index >> 3;
 356             mb->pos               = 0;
 357             mb->partial_bit_count = 0;
 358
 359             ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
 360             dv_decode_ac(&gb, mb, block);
 361
 362             /* write the remaining bits in a new buffer only if the
 363              * block is finished */
 364             if (mb->pos >= 64)
 365                 bit_copy(&pb, &gb);
 366             if (mb->pos >= 64 && mb->pos < 127)
 367                 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
 368
 369             block += 64;
 370             mb++;
 371         }
 372
 373         if (mb_bit_buffer_damaged[mb_index] > 0)
 374             continue;
 375
 376         /* pass 2: we can do it just after */
 377         ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
 378         block = block1;
 379         mb    = mb1;
 380         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
 381         put_bits32(&pb, 0); // padding must be zeroed
 382         flush_put_bits(&pb);
 383         for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
 384             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
 385                 dv_decode_ac(&gb, mb, block);
 386                 /* if still not finished, no need to parse other blocks */
 387                 if (mb->pos < 64)
 388                     break;
 389                 if (mb->pos < 127)
 390                     vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
 391             }
 392         }
 393         /* all blocks are finished, so the extra bytes can be used at
 394          * the video segment level */
 395         if (j >= s->sys->bpm)
 396             bit_copy(&vs_pb, &gb);
 397     }
 398
 399     /* we need a pass over the whole video segment */
 400     ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
 401     block = &sblock[0][0];
 402     mb    = mb_data;
 403     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
 404     put_bits32(&vs_pb, 0); // padding must be zeroed
 405     flush_put_bits(&vs_pb);
 406     for (mb_index = 0; mb_index < 5; mb_index++) {
 407         for (j = 0; j < s->sys->bpm; j++) {
 408             if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
 409                 ff_dlog(avctx, "start %d:%d\n", mb_index, j);
 410                 dv_decode_ac(&gb, mb, block);
 411             }
 412
 413             if (mb->pos >= 64 && mb->pos < 127) {
 414                 av_log(avctx, AV_LOG_ERROR,
 415                        "AC EOB marker is absent pos=%d\n", mb->pos);
 416                 vs_bit_buffer_damaged = 1;
 417             }
 418             block += 64;
 419             mb++;
 420         }
 421     }
 422     if (vs_bit_buffer_damaged && !retried) {
 423         av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
 424         retried = 1;
 425         goto retry;
 426     }
 427
 428     /* compute idct and place blocks */
 429     block = &sblock[0][0];
 430     mb    = mb_data;
 431     for (mb_index = 0; mb_index < 5; mb_index++) {
 432         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
 433
 434         /* idct_put'ting luminance */
 435         if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P)                      ||
 436             (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
 437             (s->sys->height >= 720 && mb_y != 134)) {
 438             y_stride = (s->frame->linesize[0] <<
 439                         ((!is_field_mode[mb_index]) * log2_blocksize));
 440         } else {
 441             y_stride = (2 << log2_blocksize);
 442         }
 443         y_ptr    = s->frame->data[0] +
 444                    ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
 445         linesize = s->frame->linesize[0] << is_field_mode[mb_index];
 446         mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
 447         if (s->sys->video_stype == 4) { /* SD 422 */
 448             mb[2].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 2 * 64);
 449         } else {
 450             mb[1].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 1 * 64);
 451             mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2 * 64);
 452             mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
 453         }
 454         mb    += 4;
 455         block += 4 * 64;
 456
 457         /* idct_put'ting chrominance */
 458         c_offset = (((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
 459                      (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
 460         for (j = 2; j; j--) {
 461             uint8_t *c_ptr = s->frame->data[j] + c_offset;
 462             if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 463                 uint64_t aligned_pixels[64 / 8];
 464                 uint8_t *pixels = (uint8_t *) aligned_pixels;
 465                 uint8_t *c_ptr1, *ptr1;
 466                 int x, y;
 467                 mb->idct_put(pixels, 8, block);
 468                 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
 469                     ptr1   = pixels + ((1 << (log2_blocksize))>>1);
 470                     c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
 471                     for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
 472                         c_ptr[x]  = pixels[x];
 473                         c_ptr1[x] = ptr1[x];
 474                     }
 475                 }
 476                 block += 64;
 477                 mb++;
 478             } else {
 479                 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
 480                            s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
 481                 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
 482                 (mb++)->idct_put(c_ptr, linesize, block);
 483                 block += 64;
 484                 if (s->sys->bpm == 8) {
 485                     (mb++)->idct_put(c_ptr + y_stride, linesize, block);
 486                     block += 64;
 487                 }
 488             }
 489         }
 490     }
 491     return 0;
 492 }
 493
 494 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
 495  * 144000 bytes for PAL - or twice those for 50Mbps) */
 496 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
 497                                 int *got_frame, AVPacket *avpkt)
 498 {
 499     uint8_t *buf = avpkt->data;
 500     int buf_size = avpkt->size;
 501     DVVideoContext *s = avctx->priv_data;
 502     AVFrame *frame = data;
 503     const uint8_t *vsc_pack;
 504     int apt, is16_9, ret;
 505     const AVDVProfile *sys;
 506
 507     sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
 508     if (!sys || buf_size < sys->frame_size) {
 509         av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
 510         return -1; /* NOTE: we only accept several full frames */
 511     }
 512
 513     if (sys != s->sys) {
 514         ret = ff_dv_init_dynamic_tables(s, sys);
 515         if (ret < 0) {
 516             av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
 517             return ret;
 518         }
 519         dv_init_weight_tables(s, sys);
 520         s->sys = sys;
 521     }
 522
 523     s->frame            = frame;
 524     frame->key_frame    = 1;
 525     frame->pict_type    = AV_PICTURE_TYPE_I;
 526     avctx->pix_fmt      = s->sys->pix_fmt;
 527     avctx->framerate    = av_inv_q(s->sys->time_base);
 528
 529     ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
 530     if (ret < 0)
 531         return ret;
 532
 533     /* Determine the codec's sample_aspect ratio from the packet */
 534     vsc_pack = buf + 80 * 5 + 48 + 5;
 535     if (*vsc_pack == dv_video_control) {
 536         apt    = buf[4] & 0x07;
 537         is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
 538                  (!apt && (vsc_pack[2] & 0x07) == 0x07);
 539         ff_set_sar(avctx, s->sys->sar[is16_9]);
 540     }
 541
 542     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 543         return ret;
 544     frame->interlaced_frame = 1;
 545     frame->top_field_first  = 0;
 546
 547     /* Determine the codec's field order from the packet */
 548     if ( *vsc_pack == dv_video_control ) {
 549         frame->top_field_first = !(vsc_pack[3] & 0x40);
 550     }
 551
 552     s->buf = buf;
 553     avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
 554                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
 555
 556     emms_c();
 557
 558     /* return image */
 559     *got_frame = 1;
 560
 561     return s->sys->frame_size;
 562 }
 563
 564 AVCodec ff_dvvideo_decoder = {
 565     .name           = "dvvideo",
 566     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
 567     .type           = AVMEDIA_TYPE_VIDEO,
 568     .id             = AV_CODEC_ID_DVVIDEO,
 569     .priv_data_size = sizeof(DVVideoContext),
 570     .init           = dvvideo_decode_init,
 571     .decode         = dvvideo_decode_frame,
 572     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS,
 573     .max_lowres     = 3,
 574 };