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