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 "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, int line_size, 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=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),
 226                 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     + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
 291     LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + FF_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 ((buf_ptr[3] >> 4) == 0x0E)
 315             vs_bit_buffer_damaged = 1;
 316         if (!mb_index) {
 317             sta = buf_ptr[3] >> 4;
 318         } else if (sta != (buf_ptr[3] >> 4))
 319             vs_bit_buffer_damaged = 1;
 320         buf_ptr += 4;
 321         init_put_bits(&pb, mb_bit_buffer, 80);
 322         mb    = mb1;
 323         block = block1;
 324         is_field_mode[mb_index] = 0;
 325         for (j = 0; j < s->sys->bpm; j++) {
 326             last_index = s->sys->block_sizes[j];
 327             init_get_bits(&gb, buf_ptr, last_index);
 328
 329             /* get the DC */
 330             dc       = get_sbits(&gb, 9);
 331             dct_mode = get_bits1(&gb);
 332             class1   = get_bits(&gb, 2);
 333             if (DV_PROFILE_IS_HD(s->sys)) {
 334                 mb->idct_put     = s->idct_put[0];
 335                 mb->scan_table   = s->dv_zigzag[0];
 336                 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
 337                                                    class1       * 16 * 64 +
 338                                                    quant             * 64];
 339                 is_field_mode[mb_index] |= !j && dct_mode;
 340             } else {
 341                 mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
 342                 mb->scan_table   = s->dv_zigzag[dct_mode];
 343                 mb->factor_table =
 344                     &s->idct_factor[(class1 == 3)               * 2 * 22 * 64 +
 345                                     dct_mode                        * 22 * 64 +
 346                                     (quant + ff_dv_quant_offset[class1]) * 64];
 347             }
 348             dc = dc << 2;
 349             /* convert to unsigned because 128 is not added in the
 350              * standard IDCT */
 351             dc                   += 1024;
 352             block[0]              = dc;
 353             buf_ptr              += last_index >> 3;
 354             mb->pos               = 0;
 355             mb->partial_bit_count = 0;
 356
 357             ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
 358             dv_decode_ac(&gb, mb, block);
 359
 360             /* write the remaining bits in a new buffer only if the
 361              * block is finished */
 362             if (mb->pos >= 64)
 363                 bit_copy(&pb, &gb);
 364             if (mb->pos >= 64 && mb->pos < 127)
 365                 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
 366
 367             block += 64;
 368             mb++;
 369         }
 370
 371         if (mb_bit_buffer_damaged[mb_index] > 0)
 372             continue;
 373
 374         /* pass 2: we can do it just after */
 375         ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
 376         block = block1;
 377         mb    = mb1;
 378         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
 379         put_bits32(&pb, 0); // padding must be zeroed
 380         flush_put_bits(&pb);
 381         for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
 382             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
 383                 dv_decode_ac(&gb, mb, block);
 384                 /* if still not finished, no need to parse other blocks */
 385                 if (mb->pos < 64)
 386                     break;
 387                 if (mb->pos < 127)
 388                     vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
 389             }
 390         }
 391         /* all blocks are finished, so the extra bytes can be used at
 392          * the video segment level */
 393         if (j >= s->sys->bpm)
 394             bit_copy(&vs_pb, &gb);
 395     }
 396
 397     /* we need a pass over the whole video segment */
 398     ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
 399     block = &sblock[0][0];
 400     mb    = mb_data;
 401     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
 402     put_bits32(&vs_pb, 0); // padding must be zeroed
 403     flush_put_bits(&vs_pb);
 404     for (mb_index = 0; mb_index < 5; mb_index++) {
 405         for (j = 0; j < s->sys->bpm; j++) {
 406             if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
 407                 ff_dlog(avctx, "start %d:%d\n", mb_index, j);
 408                 dv_decode_ac(&gb, mb, block);
 409             }
 410
 411             if (mb->pos >= 64 && mb->pos < 127) {
 412                 av_log(avctx, AV_LOG_ERROR,
 413                        "AC EOB marker is absent pos=%d\n", mb->pos);
 414                 vs_bit_buffer_damaged = 1;
 415             }
 416             block += 64;
 417             mb++;
 418         }
 419     }
 420     if (vs_bit_buffer_damaged && !retried) {
 421         av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
 422         retried = 1;
 423         goto retry;
 424     }
 425
 426     /* compute idct and place blocks */
 427     block = &sblock[0][0];
 428     mb    = mb_data;
 429     for (mb_index = 0; mb_index < 5; mb_index++) {
 430         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
 431
 432         /* idct_put'ting luminance */
 433         if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P)                      ||
 434             (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
 435             (s->sys->height >= 720 && mb_y != 134)) {
 436             y_stride = (s->frame->linesize[0] <<
 437                         ((!is_field_mode[mb_index]) * log2_blocksize));
 438         } else {
 439             y_stride = (2 << log2_blocksize);
 440         }
 441         y_ptr    = s->frame->data[0] +
 442                    ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
 443         linesize = s->frame->linesize[0] << is_field_mode[mb_index];
 444         mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
 445         if (s->sys->video_stype == 4) { /* SD 422 */
 446             mb[2].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 2 * 64);
 447         } else {
 448             mb[1].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 1 * 64);
 449             mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2 * 64);
 450             mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
 451         }
 452         mb    += 4;
 453         block += 4 * 64;
 454
 455         /* idct_put'ting chrominance */
 456         c_offset = (((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
 457                      (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
 458         for (j = 2; j; j--) {
 459             uint8_t *c_ptr = s->frame->data[j] + c_offset;
 460             if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 461                 uint64_t aligned_pixels[64 / 8];
 462                 uint8_t *pixels = (uint8_t *) aligned_pixels;
 463                 uint8_t *c_ptr1, *ptr1;
 464                 int x, y;
 465                 mb->idct_put(pixels, 8, block);
 466                 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
 467                     ptr1   = pixels + ((1 << (log2_blocksize))>>1);
 468                     c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
 469                     for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
 470                         c_ptr[x]  = pixels[x];
 471                         c_ptr1[x] = ptr1[x];
 472                     }
 473                 }
 474                 block += 64;
 475                 mb++;
 476             } else {
 477                 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
 478                            s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
 479                 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
 480                 (mb++)->idct_put(c_ptr, linesize, block);
 481                 block += 64;
 482                 if (s->sys->bpm == 8) {
 483                     (mb++)->idct_put(c_ptr + y_stride, linesize, block);
 484                     block += 64;
 485                 }
 486             }
 487         }
 488     }
 489     return 0;
 490 }
 491
 492 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
 493  * 144000 bytes for PAL - or twice those for 50Mbps) */
 494 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
 495                                 int *got_frame, AVPacket *avpkt)
 496 {
 497     uint8_t *buf = avpkt->data;
 498     int buf_size = avpkt->size;
 499     DVVideoContext *s = avctx->priv_data;
 500     const uint8_t *vsc_pack;
 501     int apt, is16_9, ret;
 502     const AVDVProfile *sys;
 503
 504     sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
 505     if (!sys || buf_size < sys->frame_size) {
 506         av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
 507         return -1; /* NOTE: we only accept several full frames */
 508     }
 509
 510     if (sys != s->sys) {
 511         ret = ff_dv_init_dynamic_tables(s, sys);
 512         if (ret < 0) {
 513             av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
 514             return ret;
 515         }
 516         dv_init_weight_tables(s, sys);
 517         s->sys = sys;
 518     }
 519
 520     s->frame            = data;
 521     s->frame->key_frame = 1;
 522     s->frame->pict_type = AV_PICTURE_TYPE_I;
 523     avctx->pix_fmt      = s->sys->pix_fmt;
 524     avctx->framerate    = av_inv_q(s->sys->time_base);
 525
 526     ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
 527     if (ret < 0)
 528         return ret;
 529
 530     /* Determine the codec's sample_aspect ratio from the packet */
 531     vsc_pack = buf + 80 * 5 + 48 + 5;
 532     if (*vsc_pack == dv_video_control) {
 533         apt    = buf[4] & 0x07;
 534         is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
 535                  (!apt && (vsc_pack[2] & 0x07) == 0x07);
 536         ff_set_sar(avctx, s->sys->sar[is16_9]);
 537     }
 538
 539     if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
 540         return ret;
 541     s->frame->interlaced_frame = 1;
 542     s->frame->top_field_first  = 0;
 543
 544     /* Determine the codec's field order from the packet */
 545     if ( *vsc_pack == dv_video_control ) {
 546         s->frame->top_field_first = !(vsc_pack[3] & 0x40);
 547     }
 548
 549     s->buf = buf;
 550     avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
 551                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
 552
 553     emms_c();
 554
 555     /* return image */
 556     *got_frame = 1;
 557
 558     return s->sys->frame_size;
 559 }
 560
 561 AVCodec ff_dvvideo_decoder = {
 562     .name           = "dvvideo",
 563     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
 564     .type           = AVMEDIA_TYPE_VIDEO,
 565     .id             = AV_CODEC_ID_DVVIDEO,
 566     .priv_data_size = sizeof(DVVideoContext),
 567     .init           = dvvideo_decode_init,
 568     .decode         = dvvideo_decode_frame,
 569     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
 570     .max_lowres     = 3,
 571 };