git.sesse.net Git - ffmpeg/blob - libavcodec/dv.c

   1 /*
   2  * DV decoder
   3  * Copyright (c) 2002 Fabrice Bellard
   4  * Copyright (c) 2004 Roman Shaposhnik
   5  *
   6  * DV encoder
   7  * Copyright (c) 2003 Roman Shaposhnik
   8  *
   9  * 50 Mbps (DVCPRO50) support
  10  * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
  11  *
  12  * 100 Mbps (DVCPRO HD) support
  13  * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
  14  * Final code by Roman Shaposhnik
  15  *
  16  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
  17  * of DV technical info.
  18  *
  19  * This file is part of Libav.
  20  *
  21  * Libav is free software; you can redistribute it and/or
  22  * modify it under the terms of the GNU Lesser General Public
  23  * License as published by the Free Software Foundation; either
  24  * version 2.1 of the License, or (at your option) any later version.
  25  *
  26  * Libav is distributed in the hope that it will be useful,
  27  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  28  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  29  * Lesser General Public License for more details.
  30  *
  31  * You should have received a copy of the GNU Lesser General Public
  32  * License along with Libav; if not, write to the Free Software
  33  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  34  */
  35
  36 /**
  37  * @file
  38  * DV codec.
  39  */
  40
  41 #include "libavutil/pixdesc.h"
  42 #include "avcodec.h"
  43 #include "dsputil.h"
  44 #include "get_bits.h"
  45 #include "put_bits.h"
  46 #include "simple_idct.h"
  47 #include "dvdata.h"
  48 #include "dv_tablegen.h"
  49
  50 //#undef NDEBUG
  51 //#include <assert.h>
  52
  53 typedef struct DVVideoContext {
  54     const DVprofile *sys;
  55     AVFrame          picture;
  56     AVCodecContext  *avctx;
  57     uint8_t         *buf;
  58
  59     uint8_t  dv_zigzag[2][64];
  60
  61     void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
  62     void (*fdct[2])(DCTELEM *block);
  63     void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
  64     me_cmp_func ildct_cmp;
  65 } DVVideoContext;
  66
  67 #define TEX_VLC_BITS 9
  68
  69 /* XXX: also include quantization */
  70 static RL_VLC_ELEM dv_rl_vlc[1184];
  71
  72 static inline int dv_work_pool_size(const DVprofile *d)
  73 {
  74     int size = d->n_difchan*d->difseg_size*27;
  75     if (DV_PROFILE_IS_1080i50(d))
  76         size -= 3*27;
  77     if (DV_PROFILE_IS_720p50(d))
  78         size -= 4*27;
  79     return size;
  80 }
  81
  82 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
  83                                           uint16_t *tbl)
  84 {
  85     static const uint8_t off[] = { 2, 6, 8, 0, 4 };
  86     static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
  87     static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
  88     static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
  89
  90     static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
  91     static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
  92
  93     static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
  94                                        0, 1, 2, 2, 1, 0,
  95                                        0, 1, 2, 2, 1, 0,
  96                                        0, 1, 2, 2, 1, 0,
  97                                        0, 1, 2};
  98     static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
  99                                        0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
 100                                        0, 1, 2, 3, 4, 5};
 101
 102     static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
 103                                        { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
 104                                        {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
 105                                        {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
 106                                        {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
 107                                        {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
 108                                        {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
 109                                        {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
 110                                        {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
 111                                        {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
 112                                        {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
 113                                        {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
 114                                        {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
 115
 116     int i, k, m;
 117     int x, y, blk;
 118
 119     for (m=0; m<5; m++) {
 120          switch (d->width) {
 121          case 1440:
 122               blk = (chan*11+seq)*27+slot;
 123
 124               if (chan == 0 && seq == 11) {
 125                   x = m*27+slot;
 126                   if (x<90) {
 127                       y = 0;
 128                   } else {
 129                       x = (x - 90)*2;
 130                       y = 67;
 131                   }
 132               } else {
 133                   i = (4*chan + blk + off[m])%11;
 134                   k = (blk/11)%27;
 135
 136                   x = shuf1[m] + (chan&1)*9 + k%9;
 137                   y = (i*3+k/9)*2 + (chan>>1) + 1;
 138               }
 139               tbl[m] = (x<<1)|(y<<9);
 140               break;
 141          case 1280:
 142               blk = (chan*10+seq)*27+slot;
 143
 144               i = (4*chan + (seq/5) + 2*blk + off[m])%10;
 145               k = (blk/5)%27;
 146
 147               x = shuf1[m]+(chan&1)*9 + k%9;
 148               y = (i*3+k/9)*2 + (chan>>1) + 4;
 149
 150               if (x >= 80) {
 151                   x = remap[y][0]+((x-80)<<(y>59));
 152                   y = remap[y][1];
 153               }
 154               tbl[m] = (x<<1)|(y<<9);
 155               break;
 156        case 960:
 157               blk = (chan*10+seq)*27+slot;
 158
 159               i = (4*chan + (seq/5) + 2*blk + off[m])%10;
 160               k = (blk/5)%27 + (i&1)*3;
 161
 162               x = shuf2[m] + k%6 + 6*(chan&1);
 163               y = l_start[i] + k/6 + 45*(chan>>1);
 164               tbl[m] = (x<<1)|(y<<9);
 165               break;
 166         case 720:
 167               switch (d->pix_fmt) {
 168               case PIX_FMT_YUV422P:
 169                    x = shuf3[m] + slot/3;
 170                    y = serpent1[slot] +
 171                        ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
 172                    tbl[m] = (x<<1)|(y<<8);
 173                    break;
 174               case PIX_FMT_YUV420P:
 175                    x = shuf3[m] + slot/3;
 176                    y = serpent1[slot] +
 177                        ((seq + off[m]) % d->difseg_size)*3;
 178                    tbl[m] = (x<<1)|(y<<9);
 179                    break;
 180               case PIX_FMT_YUV411P:
 181                    i = (seq + off[m]) % d->difseg_size;
 182                    k = slot + ((m==1||m==2)?3:0);
 183
 184                    x = l_start_shuffled[m] + k/6;
 185                    y = serpent2[k] + i*6;
 186                    if (x>21)
 187                        y = y*2 - i*6;
 188                    tbl[m] = (x<<2)|(y<<8);
 189                    break;
 190               }
 191         default:
 192               break;
 193         }
 194     }
 195 }
 196
 197 static int dv_init_dynamic_tables(const DVprofile *d)
 198 {
 199     int j,i,c,s,p;
 200     uint32_t *factor1, *factor2;
 201     const int *iweight1, *iweight2;
 202
 203     if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
 204         p = i = 0;
 205         for (c=0; c<d->n_difchan; c++) {
 206             for (s=0; s<d->difseg_size; s++) {
 207                 p += 6;
 208                 for (j=0; j<27; j++) {
 209                     p += !(j%3);
 210                     if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
 211                         !(DV_PROFILE_IS_720p50(d) && s > 9)) {
 212                           dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
 213                           d->work_chunks[i++].buf_offset = p;
 214                     }
 215                     p += 5;
 216                 }
 217             }
 218         }
 219     }
 220
 221     if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
 222         factor1 = &d->idct_factor[0];
 223         factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
 224         if (d->height == 720) {
 225             iweight1 = &dv_iweight_720_y[0];
 226             iweight2 = &dv_iweight_720_c[0];
 227         } else {
 228             iweight1 = &dv_iweight_1080_y[0];
 229             iweight2 = &dv_iweight_1080_c[0];
 230         }
 231         if (DV_PROFILE_IS_HD(d)) {
 232             for (c = 0; c < 4; c++) {
 233                 for (s = 0; s < 16; s++) {
 234                     for (i = 0; i < 64; i++) {
 235                         *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
 236                         *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
 237                     }
 238                 }
 239             }
 240         } else {
 241             iweight1 = &dv_iweight_88[0];
 242             for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
 243                 for (s = 0; s < 22; s++) {
 244                     for (i = c = 0; c < 4; c++) {
 245                         for (; i < dv_quant_areas[c]; i++) {
 246                             *factor1   = iweight1[i] << (dv_quant_shifts[s][c] + 1);
 247                             *factor2++ = (*factor1++) << 1;
 248                         }
 249                     }
 250                 }
 251             }
 252         }
 253     }
 254
 255     return 0;
 256 }
 257
 258 static av_cold int dvvideo_init(AVCodecContext *avctx)
 259 {
 260     DVVideoContext *s = avctx->priv_data;
 261     DSPContext dsp;
 262     static int done = 0;
 263     int i, j;
 264
 265     if (!done) {
 266         VLC dv_vlc;
 267         uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
 268         uint8_t  new_dv_vlc_len[NB_DV_VLC*2];
 269         uint8_t  new_dv_vlc_run[NB_DV_VLC*2];
 270         int16_t  new_dv_vlc_level[NB_DV_VLC*2];
 271
 272         done = 1;
 273
 274         /* it's faster to include sign bit in a generic VLC parsing scheme */
 275         for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
 276             new_dv_vlc_bits[j]  = dv_vlc_bits[i];
 277             new_dv_vlc_len[j]   = dv_vlc_len[i];
 278             new_dv_vlc_run[j]   = dv_vlc_run[i];
 279             new_dv_vlc_level[j] = dv_vlc_level[i];
 280
 281             if (dv_vlc_level[i]) {
 282                 new_dv_vlc_bits[j] <<= 1;
 283                 new_dv_vlc_len[j]++;
 284
 285                 j++;
 286                 new_dv_vlc_bits[j]  = (dv_vlc_bits[i] << 1) | 1;
 287                 new_dv_vlc_len[j]   =  dv_vlc_len[i] + 1;
 288                 new_dv_vlc_run[j]   =  dv_vlc_run[i];
 289                 new_dv_vlc_level[j] = -dv_vlc_level[i];
 290             }
 291         }
 292
 293         /* NOTE: as a trick, we use the fact the no codes are unused
 294            to accelerate the parsing of partial codes */
 295         init_vlc(&dv_vlc, TEX_VLC_BITS, j,
 296                  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
 297         assert(dv_vlc.table_size == 1184);
 298
 299         for (i = 0; i < dv_vlc.table_size; i++){
 300             int code = dv_vlc.table[i][0];
 301             int len  = dv_vlc.table[i][1];
 302             int level, run;
 303
 304             if (len < 0){ //more bits needed
 305                 run   = 0;
 306                 level = code;
 307             } else {
 308                 run   = new_dv_vlc_run  [code] + 1;
 309                 level = new_dv_vlc_level[code];
 310             }
 311             dv_rl_vlc[i].len   = len;
 312             dv_rl_vlc[i].level = level;
 313             dv_rl_vlc[i].run   = run;
 314         }
 315         free_vlc(&dv_vlc);
 316
 317         dv_vlc_map_tableinit();
 318     }
 319
 320     /* Generic DSP setup */
 321     dsputil_init(&dsp, avctx);
 322     ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
 323     s->get_pixels = dsp.get_pixels;
 324     s->ildct_cmp = dsp.ildct_cmp[5];
 325
 326     /* 88DCT setup */
 327     s->fdct[0]     = dsp.fdct;
 328     s->idct_put[0] = dsp.idct_put;
 329     for (i = 0; i < 64; i++)
 330        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
 331
 332     /* 248DCT setup */
 333     s->fdct[1]     = dsp.fdct248;
 334     s->idct_put[1] = ff_simple_idct248_put;  // FIXME: need to add it to DSP
 335     if (avctx->lowres){
 336         for (i = 0; i < 64; i++){
 337             int j = ff_zigzag248_direct[i];
 338             s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
 339         }
 340     }else
 341         memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
 342
 343     avctx->coded_frame = &s->picture;
 344     s->avctx = avctx;
 345     avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
 346
 347     return 0;
 348 }
 349
 350 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
 351 {
 352     if (!avpriv_dv_codec_profile(avctx)) {
 353         av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",
 354                avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
 355         return -1;
 356     }
 357
 358     return dvvideo_init(avctx);
 359 }
 360
 361 typedef struct BlockInfo {
 362     const uint32_t *factor_table;
 363     const uint8_t *scan_table;
 364     uint8_t pos; /* position in block */
 365     void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
 366     uint8_t partial_bit_count;
 367     uint32_t partial_bit_buffer;
 368     int shift_offset;
 369 } BlockInfo;
 370
 371 /* bit budget for AC only in 5 MBs */
 372 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
 373 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
 374
 375 static inline int put_bits_left(PutBitContext* s)
 376 {
 377     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
 378 }
 379
 380 /* decode AC coefficients */
 381 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
 382 {
 383     int last_index = gb->size_in_bits;
 384     const uint8_t  *scan_table   = mb->scan_table;
 385     const uint32_t *factor_table = mb->factor_table;
 386     int pos               = mb->pos;
 387     int partial_bit_count = mb->partial_bit_count;
 388     int level, run, vlc_len, index;
 389
 390     OPEN_READER(re, gb);
 391     UPDATE_CACHE(re, gb);
 392
 393     /* if we must parse a partial VLC, we do it here */
 394     if (partial_bit_count > 0) {
 395         re_cache = re_cache >> partial_bit_count | mb->partial_bit_buffer;
 396         re_index -= partial_bit_count;
 397         mb->partial_bit_count = 0;
 398     }
 399
 400     /* get the AC coefficients until last_index is reached */
 401     for (;;) {
 402         av_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),
 403                 re_index);
 404         /* our own optimized GET_RL_VLC */
 405         index   = NEG_USR32(re_cache, TEX_VLC_BITS);
 406         vlc_len = dv_rl_vlc[index].len;
 407         if (vlc_len < 0) {
 408             index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
 409             vlc_len = TEX_VLC_BITS - vlc_len;
 410         }
 411         level = dv_rl_vlc[index].level;
 412         run   = dv_rl_vlc[index].run;
 413
 414         /* gotta check if we're still within gb boundaries */
 415         if (re_index + vlc_len > last_index) {
 416             /* should be < 16 bits otherwise a codeword could have been parsed */
 417             mb->partial_bit_count = last_index - re_index;
 418             mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
 419             re_index = last_index;
 420             break;
 421         }
 422         re_index += vlc_len;
 423
 424         av_dlog(NULL, "run=%d level=%d\n", run, level);
 425         pos += run;
 426         if (pos >= 64)
 427             break;
 428
 429         level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
 430         block[scan_table[pos]] = level;
 431
 432         UPDATE_CACHE(re, gb);
 433     }
 434     CLOSE_READER(re, gb);
 435     mb->pos = pos;
 436 }
 437
 438 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
 439 {
 440     int bits_left = get_bits_left(gb);
 441     while (bits_left >= MIN_CACHE_BITS) {
 442         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
 443         bits_left -= MIN_CACHE_BITS;
 444     }
 445     if (bits_left > 0) {
 446         put_bits(pb, bits_left, get_bits(gb, bits_left));
 447     }
 448 }
 449
 450 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
 451 {
 452      *mb_x = work_chunk->mb_coordinates[m] & 0xff;
 453      *mb_y = work_chunk->mb_coordinates[m] >> 8;
 454
 455      /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
 456      if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
 457          *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
 458      }
 459 }
 460
 461 /* mb_x and mb_y are in units of 8 pixels */
 462 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
 463 {
 464     DVVideoContext *s = avctx->priv_data;
 465     DVwork_chunk *work_chunk = arg;
 466     int quant, dc, dct_mode, class1, j;
 467     int mb_index, mb_x, mb_y, last_index;
 468     int y_stride, linesize;
 469     DCTELEM *block, *block1;
 470     int c_offset;
 471     uint8_t *y_ptr;
 472     const uint8_t *buf_ptr;
 473     PutBitContext pb, vs_pb;
 474     GetBitContext gb;
 475     BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
 476     LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]);
 477     LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [  80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
 478     LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5*80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
 479     const int log2_blocksize = 3-s->avctx->lowres;
 480     int is_field_mode[5];
 481
 482     assert((((int)mb_bit_buffer) & 7) == 0);
 483     assert((((int)vs_bit_buffer) & 7) == 0);
 484
 485     memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock));
 486
 487     /* pass 1: read DC and AC coefficients in blocks */
 488     buf_ptr = &s->buf[work_chunk->buf_offset*80];
 489     block1  = &sblock[0][0];
 490     mb1     = mb_data;
 491     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
 492     for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
 493         /* skip header */
 494         quant = buf_ptr[3] & 0x0f;
 495         buf_ptr += 4;
 496         init_put_bits(&pb, mb_bit_buffer, 80);
 497         mb    = mb1;
 498         block = block1;
 499         is_field_mode[mb_index] = 0;
 500         for (j = 0; j < s->sys->bpm; j++) {
 501             last_index = s->sys->block_sizes[j];
 502             init_get_bits(&gb, buf_ptr, last_index);
 503
 504             /* get the DC */
 505             dc       = get_sbits(&gb, 9);
 506             dct_mode = get_bits1(&gb);
 507             class1   = get_bits(&gb, 2);
 508             if (DV_PROFILE_IS_HD(s->sys)) {
 509                 mb->idct_put     = s->idct_put[0];
 510                 mb->scan_table   = s->dv_zigzag[0];
 511                 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
 512                 is_field_mode[mb_index] |= !j && dct_mode;
 513             } else {
 514                 mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
 515                 mb->scan_table   = s->dv_zigzag[dct_mode];
 516                 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
 517                                                         (quant + dv_quant_offset[class1])*64];
 518             }
 519             dc = dc << 2;
 520             /* convert to unsigned because 128 is not added in the
 521                standard IDCT */
 522             dc += 1024;
 523             block[0] = dc;
 524             buf_ptr += last_index >> 3;
 525             mb->pos               = 0;
 526             mb->partial_bit_count = 0;
 527
 528             av_dlog(avctx, "MB block: %d, %d ", mb_index, j);
 529             dv_decode_ac(&gb, mb, block);
 530
 531             /* write the remaining bits in a new buffer only if the
 532                block is finished */
 533             if (mb->pos >= 64)
 534                 bit_copy(&pb, &gb);
 535
 536             block += 64;
 537             mb++;
 538         }
 539
 540         /* pass 2: we can do it just after */
 541         av_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
 542         block = block1;
 543         mb    = mb1;
 544         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
 545         put_bits32(&pb, 0); // padding must be zeroed
 546         flush_put_bits(&pb);
 547         for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
 548             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
 549                 dv_decode_ac(&gb, mb, block);
 550                 /* if still not finished, no need to parse other blocks */
 551                 if (mb->pos < 64)
 552                     break;
 553             }
 554         }
 555         /* all blocks are finished, so the extra bytes can be used at
 556            the video segment level */
 557         if (j >= s->sys->bpm)
 558             bit_copy(&vs_pb, &gb);
 559     }
 560
 561     /* we need a pass over the whole video segment */
 562     av_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
 563     block = &sblock[0][0];
 564     mb    = mb_data;
 565     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
 566     put_bits32(&vs_pb, 0); // padding must be zeroed
 567     flush_put_bits(&vs_pb);
 568     for (mb_index = 0; mb_index < 5; mb_index++) {
 569         for (j = 0; j < s->sys->bpm; j++) {
 570             if (mb->pos < 64) {
 571                 av_dlog(avctx, "start %d:%d\n", mb_index, j);
 572                 dv_decode_ac(&gb, mb, block);
 573             }
 574             if (mb->pos >= 64 && mb->pos < 127)
 575                 av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
 576             block += 64;
 577             mb++;
 578         }
 579     }
 580
 581     /* compute idct and place blocks */
 582     block = &sblock[0][0];
 583     mb    = mb_data;
 584     for (mb_index = 0; mb_index < 5; mb_index++) {
 585         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
 586
 587         /* idct_put'ting luminance */
 588         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
 589             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
 590             (s->sys->height >= 720 && mb_y != 134)) {
 591             y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
 592         } else {
 593             y_stride = (2 << log2_blocksize);
 594         }
 595         y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
 596         linesize = s->picture.linesize[0] << is_field_mode[mb_index];
 597         mb[0]    .idct_put(y_ptr                                   , linesize, block + 0*64);
 598         if (s->sys->video_stype == 4) { /* SD 422 */
 599             mb[2].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 2*64);
 600         } else {
 601             mb[1].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 1*64);
 602             mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2*64);
 603             mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
 604         }
 605         mb += 4;
 606         block += 4*64;
 607
 608         /* idct_put'ting chrominance */
 609         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
 610                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
 611         for (j = 2; j; j--) {
 612             uint8_t *c_ptr = s->picture.data[j] + c_offset;
 613             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 614                   uint64_t aligned_pixels[64/8];
 615                   uint8_t *pixels = (uint8_t*)aligned_pixels;
 616                   uint8_t *c_ptr1, *ptr1;
 617                   int x, y;
 618                   mb->idct_put(pixels, 8, block);
 619                   for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
 620                       ptr1   = pixels + (1 << (log2_blocksize - 1));
 621                       c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
 622                       for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
 623                           c_ptr[x]  = pixels[x];
 624                           c_ptr1[x] = ptr1[x];
 625                       }
 626                   }
 627                   block += 64; mb++;
 628             } else {
 629                   y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
 630                                              s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
 631                   linesize = s->picture.linesize[j] << is_field_mode[mb_index];
 632                   (mb++)->    idct_put(c_ptr           , linesize, block); block += 64;
 633                   if (s->sys->bpm == 8) {
 634                       (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
 635                   }
 636             }
 637         }
 638     }
 639     return 0;
 640 }
 641
 642 #if CONFIG_SMALL
 643 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
 644 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
 645 {
 646     int size;
 647     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 648         *vlc = dv_vlc_map[run][level].vlc | sign;
 649         size = dv_vlc_map[run][level].size;
 650     }
 651     else {
 652         if (level < DV_VLC_MAP_LEV_SIZE) {
 653             *vlc = dv_vlc_map[0][level].vlc | sign;
 654             size = dv_vlc_map[0][level].size;
 655         } else {
 656             *vlc = 0xfe00 | (level << 1) | sign;
 657             size = 16;
 658         }
 659         if (run) {
 660             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
 661                                   (0x1f80 | (run - 1))) << size;
 662             size +=  (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 663         }
 664     }
 665
 666     return size;
 667 }
 668
 669 static av_always_inline int dv_rl2vlc_size(int run, int level)
 670 {
 671     int size;
 672
 673     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 674         size = dv_vlc_map[run][level].size;
 675     }
 676     else {
 677         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
 678         if (run) {
 679             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 680         }
 681     }
 682     return size;
 683 }
 684 #else
 685 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
 686 {
 687     *vlc = dv_vlc_map[run][l].vlc | sign;
 688     return dv_vlc_map[run][l].size;
 689 }
 690
 691 static av_always_inline int dv_rl2vlc_size(int run, int l)
 692 {
 693     return dv_vlc_map[run][l].size;
 694 }
 695 #endif
 696
 697 typedef struct EncBlockInfo {
 698     int      area_q[4];
 699     int      bit_size[4];
 700     int      prev[5];
 701     int      cur_ac;
 702     int      cno;
 703     int      dct_mode;
 704     DCTELEM  mb[64];
 705     uint8_t  next[64];
 706     uint8_t  sign[64];
 707     uint8_t  partial_bit_count;
 708     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
 709 } EncBlockInfo;
 710
 711 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
 712                                                     PutBitContext* pb_pool,
 713                                                     PutBitContext* pb_end)
 714 {
 715     int prev, bits_left;
 716     PutBitContext* pb = pb_pool;
 717     int size = bi->partial_bit_count;
 718     uint32_t vlc = bi->partial_bit_buffer;
 719
 720     bi->partial_bit_count = bi->partial_bit_buffer = 0;
 721     for (;;){
 722        /* Find suitable storage space */
 723        for (; size > (bits_left = put_bits_left(pb)); pb++) {
 724           if (bits_left) {
 725               size -= bits_left;
 726               put_bits(pb, bits_left, vlc >> size);
 727               vlc = vlc & ((1 << size) - 1);
 728           }
 729           if (pb + 1 >= pb_end) {
 730               bi->partial_bit_count  = size;
 731               bi->partial_bit_buffer = vlc;
 732               return pb;
 733           }
 734        }
 735
 736        /* Store VLC */
 737        put_bits(pb, size, vlc);
 738
 739        if (bi->cur_ac >= 64)
 740            break;
 741
 742        /* Construct the next VLC */
 743        prev       = bi->cur_ac;
 744        bi->cur_ac = bi->next[prev];
 745        if (bi->cur_ac < 64){
 746            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
 747        } else {
 748            size = 4; vlc = 6; /* End Of Block stamp */
 749        }
 750     }
 751     return pb;
 752 }
 753
 754 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
 755     if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
 756         int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
 757         if (ps > 0) {
 758             int is = s->ildct_cmp(NULL, data           , NULL, linesize<<1, 4) +
 759                      s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
 760             return ps > is;
 761         }
 762     }
 763
 764     return 0;
 765 }
 766
 767 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
 768 {
 769     const int *weight;
 770     const uint8_t* zigzag_scan;
 771     LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
 772     int i, area;
 773     /* We offer two different methods for class number assignment: the
 774        method suggested in SMPTE 314M Table 22, and an improved
 775        method. The SMPTE method is very conservative; it assigns class
 776        3 (i.e. severe quantization) to any block where the largest AC
 777        component is greater than 36. Libav's DV encoder tracks AC bit
 778        consumption precisely, so there is no need to bias most blocks
 779        towards strongly lossy compression. Instead, we assign class 2
 780        to most blocks, and use class 3 only when strictly necessary
 781        (for blocks whose largest AC component exceeds 255). */
 782
 783 #if 0 /* SMPTE spec method */
 784     static const int classes[] = {12, 24, 36, 0xffff};
 785 #else /* improved Libav method */
 786     static const int classes[] = {-1, -1, 255, 0xffff};
 787 #endif
 788     int max  = classes[0];
 789     int prev = 0;
 790
 791     assert((((int)blk) & 15) == 0);
 792
 793     bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
 794     bi->partial_bit_count = 0;
 795     bi->partial_bit_buffer = 0;
 796     bi->cur_ac = 0;
 797     if (data) {
 798         bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
 799         s->get_pixels(blk, data, linesize);
 800         s->fdct[bi->dct_mode](blk);
 801     } else {
 802         /* We rely on the fact that encoding all zeros leads to an immediate EOB,
 803            which is precisely what the spec calls for in the "dummy" blocks. */
 804         memset(blk, 0, 64*sizeof(*blk));
 805         bi->dct_mode = 0;
 806     }
 807     bi->mb[0] = blk[0];
 808
 809     zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
 810     weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
 811
 812     for (area = 0; area < 4; area++) {
 813        bi->prev[area]     = prev;
 814        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 815        for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
 816           int level = blk[zigzag_scan[i]];
 817
 818           if (level + 15 > 30U) {
 819               bi->sign[i] = (level >> 31) & 1;
 820               /* weight it and and shift down into range, adding for rounding */
 821               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
 822                  AND the 2x doubling of the weights */
 823               level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
 824               bi->mb[i] = level;
 825               if (level > max)
 826                   max = level;
 827               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
 828               bi->next[prev]= i;
 829               prev = i;
 830           }
 831        }
 832     }
 833     bi->next[prev]= i;
 834     for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
 835
 836     bi->cno += bias;
 837
 838     if (bi->cno >= 3) {
 839         bi->cno = 3;
 840         prev    = 0;
 841         i       = bi->next[prev];
 842         for (area = 0; area < 4; area++) {
 843             bi->prev[area]     = prev;
 844             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 845             for (; i < mb_area_start[area+1]; i = bi->next[i]) {
 846                 bi->mb[i] >>= 1;
 847
 848                 if (bi->mb[i]) {
 849                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
 850                     bi->next[prev]= i;
 851                     prev = i;
 852                 }
 853             }
 854         }
 855         bi->next[prev]= i;
 856     }
 857
 858     return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
 859 }
 860
 861 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
 862 {
 863     int size[5];
 864     int i, j, k, a, prev, a2;
 865     EncBlockInfo* b;
 866
 867     size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
 868     do {
 869        b = blks;
 870        for (i = 0; i < 5; i++) {
 871           if (!qnos[i])
 872               continue;
 873
 874           qnos[i]--;
 875           size[i] = 0;
 876           for (j = 0; j < 6; j++, b++) {
 877              for (a = 0; a < 4; a++) {
 878                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
 879                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
 880                     b->area_q[a]++;
 881                     prev = b->prev[a];
 882                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
 883                     for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
 884                        b->mb[k] >>= 1;
 885                        if (b->mb[k]) {
 886                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 887                            prev = k;
 888                        } else {
 889                            if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
 890                                 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
 891                                     b->prev[a2] = prev;
 892                                 assert(a2 < 4);
 893                                 assert(b->mb[b->next[k]]);
 894                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
 895                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
 896                                 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
 897                                 b->prev[a2] = prev;
 898                            }
 899                            b->next[prev] = b->next[k];
 900                        }
 901                     }
 902                     b->prev[a+1]= prev;
 903                 }
 904                 size[i] += b->bit_size[a];
 905              }
 906           }
 907           if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
 908                 return;
 909        }
 910     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
 911
 912
 913     for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
 914         b = blks;
 915         size[0] = 5 * 6 * 4; //EOB
 916         for (j = 0; j < 6 *5; j++, b++) {
 917             prev = b->prev[0];
 918             for (k = b->next[prev]; k < 64; k = b->next[k]) {
 919                 if (b->mb[k] < a && b->mb[k] > -a){
 920                     b->next[prev] = b->next[k];
 921                 }else{
 922                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 923                     prev = k;
 924                 }
 925             }
 926         }
 927     }
 928 }
 929
 930 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
 931 {
 932     DVVideoContext *s = avctx->priv_data;
 933     DVwork_chunk *work_chunk = arg;
 934     int mb_index, i, j;
 935     int mb_x, mb_y, c_offset, linesize, y_stride;
 936     uint8_t*  y_ptr;
 937     uint8_t*  dif;
 938     LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
 939     EncBlockInfo  enc_blks[5*DV_MAX_BPM];
 940     PutBitContext pbs[5*DV_MAX_BPM];
 941     PutBitContext* pb;
 942     EncBlockInfo* enc_blk;
 943     int       vs_bit_size = 0;
 944     int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
 945     int*      qnosp = &qnos[0];
 946
 947     dif = &s->buf[work_chunk->buf_offset*80];
 948     enc_blk = &enc_blks[0];
 949     for (mb_index = 0; mb_index < 5; mb_index++) {
 950         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
 951
 952         /* initializing luminance blocks */
 953         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
 954             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
 955             (s->sys->height >= 720 && mb_y != 134)) {
 956             y_stride = s->picture.linesize[0] << 3;
 957         } else {
 958             y_stride = 16;
 959         }
 960         y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
 961         linesize = s->picture.linesize[0];
 962
 963         if (s->sys->video_stype == 4) { /* SD 422 */
 964             vs_bit_size +=
 965             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
 966             dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
 967             dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
 968             dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
 969         } else {
 970             vs_bit_size +=
 971             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
 972             dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
 973             dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
 974             dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
 975         }
 976         enc_blk += 4;
 977
 978         /* initializing chrominance blocks */
 979         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
 980                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
 981         for (j = 2; j; j--) {
 982             uint8_t *c_ptr = s->picture.data[j] + c_offset;
 983             linesize = s->picture.linesize[j];
 984             y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
 985             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 986                 uint8_t* d;
 987                 uint8_t* b = scratch;
 988                 for (i = 0; i < 8; i++) {
 989                     d = c_ptr + (linesize << 3);
 990                     b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
 991                     b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
 992                     c_ptr += linesize;
 993                     b += 8;
 994                 }
 995                 c_ptr = scratch;
 996                 linesize = 8;
 997             }
 998
 999             vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
1000             if (s->sys->bpm == 8) {
1001                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1002             }
1003         }
1004     }
1005
1006     if (vs_total_ac_bits < vs_bit_size)
1007         dv_guess_qnos(&enc_blks[0], qnosp);
1008
1009     /* DIF encoding process */
1010     for (j=0; j<5*s->sys->bpm;) {
1011         int start_mb = j;
1012
1013         dif[3] = *qnosp++;
1014         dif += 4;
1015
1016         /* First pass over individual cells only */
1017         for (i=0; i<s->sys->bpm; i++, j++) {
1018             int sz = s->sys->block_sizes[i]>>3;
1019
1020             init_put_bits(&pbs[j], dif, sz);
1021             put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1022             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1023             put_bits(&pbs[j], 2, enc_blks[j].cno);
1024
1025             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1026             dif += sz;
1027         }
1028
1029         /* Second pass over each MB space */
1030         pb = &pbs[start_mb];
1031         for (i=0; i<s->sys->bpm; i++) {
1032             if (enc_blks[start_mb+i].partial_bit_count)
1033                 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1034         }
1035     }
1036
1037     /* Third and final pass over the whole video segment space */
1038     pb = &pbs[0];
1039     for (j=0; j<5*s->sys->bpm; j++) {
1040        if (enc_blks[j].partial_bit_count)
1041            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1042        if (enc_blks[j].partial_bit_count)
1043             av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1044     }
1045
1046     for (j=0; j<5*s->sys->bpm; j++) {
1047        int pos;
1048        int size = pbs[j].size_in_bits >> 3;
1049        flush_put_bits(&pbs[j]);
1050        pos = put_bits_count(&pbs[j]) >> 3;
1051        if (pos > size) {
1052            av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1053            return -1;
1054        }
1055        memset(pbs[j].buf + pos, 0xff, size - pos);
1056     }
1057
1058     return 0;
1059 }
1060
1061 #if CONFIG_DVVIDEO_DECODER
1062 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1063    144000 bytes for PAL - or twice those for 50Mbps) */
1064 static int dvvideo_decode_frame(AVCodecContext *avctx,
1065                                  void *data, int *data_size,
1066                                  AVPacket *avpkt)
1067 {
1068     const uint8_t *buf = avpkt->data;
1069     int buf_size = avpkt->size;
1070     DVVideoContext *s = avctx->priv_data;
1071     const uint8_t* vsc_pack;
1072     int apt, is16_9;
1073
1074     s->sys = avpriv_dv_frame_profile(s->sys, buf, buf_size);
1075     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1076         av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1077         return -1; /* NOTE: we only accept several full frames */
1078     }
1079
1080     if (s->picture.data[0])
1081         avctx->release_buffer(avctx, &s->picture);
1082
1083     s->picture.reference = 0;
1084     s->picture.key_frame = 1;
1085     s->picture.pict_type = AV_PICTURE_TYPE_I;
1086     avctx->pix_fmt   = s->sys->pix_fmt;
1087     avctx->time_base = s->sys->time_base;
1088     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1089     if (avctx->get_buffer(avctx, &s->picture) < 0) {
1090         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1091         return -1;
1092     }
1093     s->picture.interlaced_frame = 1;
1094     s->picture.top_field_first  = 0;
1095
1096     s->buf = buf;
1097     avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1098                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1099
1100     emms_c();
1101
1102     /* return image */
1103     *data_size = sizeof(AVFrame);
1104     *(AVFrame*)data = s->picture;
1105
1106     /* Determine the codec's sample_aspect ratio from the packet */
1107     vsc_pack = buf + 80*5 + 48 + 5;
1108     if ( *vsc_pack == dv_video_control ) {
1109         apt = buf[4] & 0x07;
1110         is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07)));
1111         avctx->sample_aspect_ratio = s->sys->sar[is16_9];
1112     }
1113
1114     return s->sys->frame_size;
1115 }
1116 #endif /* CONFIG_DVVIDEO_DECODER */
1117
1118
1119 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1120                                 uint8_t* buf)
1121 {
1122     /*
1123      * Here's what SMPTE314M says about these two:
1124      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1125      *             as track application IDs (APTn = 001, AP1n =
1126      *             001, AP2n = 001, AP3n = 001), if the source signal
1127      *             comes from a digital VCR. If the signal source is
1128      *             unknown, all bits for these data shall be set to 1.
1129      *    (page 12) STYPE: STYPE defines a signal type of video signal
1130      *                     00000b = 4:1:1 compression
1131      *                     00100b = 4:2:2 compression
1132      *                     XXXXXX = Reserved
1133      * Now, I've got two problems with these statements:
1134      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1135      *      It seems that for PAL as defined in IEC 61834 we have to set
1136      *      APT to 000 and for SMPTE314M to 001.
1137      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1138      *      compression scheme (if any).
1139      */
1140     int apt   = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1141
1142     uint8_t aspect = 0;
1143     if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1144         aspect = 0x02;
1145
1146     buf[0] = (uint8_t)pack_id;
1147     switch (pack_id) {
1148     case dv_header525: /* I can't imagine why these two weren't defined as real */
1149     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1150           buf[1] = 0xf8 |        /* reserved -- always 1 */
1151                    (apt & 0x07); /* APT: Track application ID */
1152           buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1153                    (0x0f << 3) | /* reserved -- always 1 */
1154                    (apt & 0x07); /* AP1: Audio application ID */
1155           buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1156                    (0x0f << 3) | /* reserved -- always 1 */
1157                    (apt & 0x07); /* AP2: Video application ID */
1158           buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1159                    (0x0f << 3) | /* reserved -- always 1 */
1160                    (apt & 0x07); /* AP3: Subcode application ID */
1161           break;
1162     case dv_video_source:
1163           buf[1] = 0xff;      /* reserved -- always 1 */
1164           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1165                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1166                    (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1167                    0xf;       /* reserved -- always 1 */
1168           buf[3] = (3 << 6) | /* reserved -- always 1 */
1169                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1170                    c->sys->video_stype; /* signal type video compression */
1171           buf[4] = 0xff;      /* VISC: 0xff -- no information */
1172           break;
1173     case dv_video_control:
1174           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1175                    0x3f;      /* reserved -- always 1 */
1176           buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
1177                    aspect;
1178           buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1179                    (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1180                    (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1181                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1182                    0xc;       /* reserved -- always b1100 */
1183           buf[4] = 0xff;      /* reserved -- always 1 */
1184           break;
1185     default:
1186           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1187     }
1188     return 5;
1189 }
1190
1191 #if CONFIG_DVVIDEO_ENCODER
1192 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1193 {
1194     int chan, i, j, k;
1195
1196     for (chan = 0; chan < c->sys->n_difchan; chan++) {
1197         for (i = 0; i < c->sys->difseg_size; i++) {
1198             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1199
1200             /* DV header: 1DIF */
1201             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1202             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1203             buf += 72; /* unused bytes */
1204
1205             /* DV subcode: 2DIFs */
1206             for (j = 0; j < 2; j++) {
1207                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1208                 for (k = 0; k < 6; k++)
1209                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1210                 buf += 29; /* unused bytes */
1211             }
1212
1213             /* DV VAUX: 3DIFS */
1214             for (j = 0; j < 3; j++) {
1215                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1216                 buf += dv_write_pack(dv_video_source,  c, buf);
1217                 buf += dv_write_pack(dv_video_control, c, buf);
1218                 buf += 7*5;
1219                 buf += dv_write_pack(dv_video_source,  c, buf);
1220                 buf += dv_write_pack(dv_video_control, c, buf);
1221                 buf += 4*5 + 2; /* unused bytes */
1222             }
1223
1224             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1225             for (j = 0; j < 135; j++) {
1226                 if (j%15 == 0) {
1227                     memset(buf, 0xff, 80);
1228                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1229                     buf += 77; /* audio control & shuffled PCM audio */
1230                 }
1231                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1232                 buf += 77; /* 1 video macroblock: 1 bytes control
1233                               4 * 14 bytes Y 8x8 data
1234                               10 bytes Cr 8x8 data
1235                               10 bytes Cb 8x8 data */
1236             }
1237         }
1238     }
1239 }
1240
1241
1242 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1243                                 void *data)
1244 {
1245     DVVideoContext *s = c->priv_data;
1246
1247     s->sys = avpriv_dv_codec_profile(c);
1248     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1249         return -1;
1250
1251     c->pix_fmt           = s->sys->pix_fmt;
1252     s->picture           = *((AVFrame *)data);
1253     s->picture.key_frame = 1;
1254     s->picture.pict_type = AV_PICTURE_TYPE_I;
1255
1256     s->buf = buf;
1257     c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1258                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1259
1260     emms_c();
1261
1262     dv_format_frame(s, buf);
1263
1264     return s->sys->frame_size;
1265 }
1266 #endif
1267
1268 static int dvvideo_close(AVCodecContext *c)
1269 {
1270     DVVideoContext *s = c->priv_data;
1271
1272     if (s->picture.data[0])
1273         c->release_buffer(c, &s->picture);
1274
1275     return 0;
1276 }
1277
1278
1279 #if CONFIG_DVVIDEO_ENCODER
1280 AVCodec ff_dvvideo_encoder = {
1281     .name           = "dvvideo",
1282     .type           = AVMEDIA_TYPE_VIDEO,
1283     .id             = CODEC_ID_DVVIDEO,
1284     .priv_data_size = sizeof(DVVideoContext),
1285     .init           = dvvideo_init_encoder,
1286     .encode         = dvvideo_encode_frame,
1287     .capabilities = CODEC_CAP_SLICE_THREADS,
1288     .pix_fmts  = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1289     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1290 };
1291 #endif // CONFIG_DVVIDEO_ENCODER
1292
1293 #if CONFIG_DVVIDEO_DECODER
1294 AVCodec ff_dvvideo_decoder = {
1295     .name           = "dvvideo",
1296     .type           = AVMEDIA_TYPE_VIDEO,
1297     .id             = CODEC_ID_DVVIDEO,
1298     .priv_data_size = sizeof(DVVideoContext),
1299     .init           = dvvideo_init,
1300     .close          = dvvideo_close,
1301     .decode         = dvvideo_decode_frame,
1302     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
1303     .max_lowres = 3,
1304     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1305 };
1306 #endif