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