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 //FIXME replace this by dsputil
 808 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
 809 static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
 810     DCTELEM *s;
 811     int score88  = 0;
 812     int score248 = 0;
 813     int i;
 814
 815     /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
 816     s = blk;
 817     for (i = 0; i < 7; i++) {
 818         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
 819                    SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
 820         s += 8;
 821     }
 822     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
 823     s = blk;
 824     for (i = 0; i < 6; i++) {
 825         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
 826                     SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
 827         s += 8;
 828     }
 829
 830     return (score88 - score248 > -10);
 831 }
 832
 833 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
 834 {
 835     const int *weight;
 836     const uint8_t* zigzag_scan;
 837     DECLARE_ALIGNED_16(DCTELEM, blk[64]);
 838     int i, area;
 839     /* We offer two different methods for class number assignment: the
 840        method suggested in SMPTE 314M Table 22, and an improved
 841        method. The SMPTE method is very conservative; it assigns class
 842        3 (i.e. severe quantization) to any block where the largest AC
 843        component is greater than 36. FFmpeg's DV encoder tracks AC bit
 844        consumption precisely, so there is no need to bias most blocks
 845        towards strongly lossy compression. Instead, we assign class 2
 846        to most blocks, and use class 3 only when strictly necessary
 847        (for blocks whose largest AC component exceeds 255). */
 848
 849 #if 0 /* SMPTE spec method */
 850     static const int classes[] = {12, 24, 36, 0xffff};
 851 #else /* improved FFmpeg method */
 852     static const int classes[] = {-1, -1, 255, 0xffff};
 853 #endif
 854     int max  = classes[0];
 855     int prev = 0;
 856
 857     assert((((int)blk) & 15) == 0);
 858
 859     bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
 860     bi->partial_bit_count = 0;
 861     bi->partial_bit_buffer = 0;
 862     bi->cur_ac = 0;
 863     if (data) {
 864         s->get_pixels(blk, data, linesize);
 865         bi->dct_mode = (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) &&
 866                        dv_guess_dct_mode(blk);
 867         s->fdct[bi->dct_mode](blk);
 868     } else {
 869         /* We rely on the fact that encoding all zeros leads to an immediate EOB,
 870            which is precisely what the spec calls for in the "dummy" blocks. */
 871         memset(blk, 0, sizeof(blk));
 872         bi->dct_mode = 0;
 873     }
 874     bi->mb[0] = blk[0];
 875
 876     zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
 877     weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
 878
 879     for (area = 0; area < 4; area++) {
 880        bi->prev[area]     = prev;
 881        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 882        for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
 883           int level = blk[zigzag_scan[i]];
 884
 885           if (level + 15 > 30U) {
 886               bi->sign[i] = (level >> 31) & 1;
 887               /* weigh it and and shift down into range, adding for rounding */
 888               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
 889                  AND the 2x doubling of the weights */
 890               level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
 891               bi->mb[i] = level;
 892               if (level > max)
 893                   max = level;
 894               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
 895               bi->next[prev]= i;
 896               prev = i;
 897           }
 898        }
 899     }
 900     bi->next[prev]= i;
 901     for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
 902
 903     bi->cno += bias;
 904
 905     if (bi->cno >= 3) {
 906         bi->cno = 3;
 907         prev    = 0;
 908         i       = bi->next[prev];
 909         for (area = 0; area < 4; area++) {
 910             bi->prev[area]     = prev;
 911             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 912             for (; i < mb_area_start[area+1]; i = bi->next[i]) {
 913                 bi->mb[i] >>= 1;
 914
 915                 if (bi->mb[i]) {
 916                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
 917                     bi->next[prev]= i;
 918                     prev = i;
 919                 }
 920             }
 921         }
 922         bi->next[prev]= i;
 923     }
 924
 925     return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
 926 }
 927
 928 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
 929 {
 930     int size[5];
 931     int i, j, k, a, prev, a2;
 932     EncBlockInfo* b;
 933
 934     size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
 935     do {
 936        b = blks;
 937        for (i = 0; i < 5; i++) {
 938           if (!qnos[i])
 939               continue;
 940
 941           qnos[i]--;
 942           size[i] = 0;
 943           for (j = 0; j < 6; j++, b++) {
 944              for (a = 0; a < 4; a++) {
 945                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
 946                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
 947                     b->area_q[a]++;
 948                     prev = b->prev[a];
 949                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
 950                     for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
 951                        b->mb[k] >>= 1;
 952                        if (b->mb[k]) {
 953                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 954                            prev = k;
 955                        } else {
 956                            if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
 957                                 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
 958                                     b->prev[a2] = prev;
 959                                 assert(a2 < 4);
 960                                 assert(b->mb[b->next[k]]);
 961                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
 962                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
 963                                 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
 964                                 b->prev[a2] = prev;
 965                            }
 966                            b->next[prev] = b->next[k];
 967                        }
 968                     }
 969                     b->prev[a+1]= prev;
 970                 }
 971                 size[i] += b->bit_size[a];
 972              }
 973           }
 974           if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
 975                 return;
 976        }
 977     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
 978
 979
 980     for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
 981         b = blks;
 982         size[0] = 5 * 6 * 4; //EOB
 983         for (j = 0; j < 6 *5; j++, b++) {
 984             prev = b->prev[0];
 985             for (k = b->next[prev]; k < 64; k = b->next[k]) {
 986                 if (b->mb[k] < a && b->mb[k] > -a){
 987                     b->next[prev] = b->next[k];
 988                 }else{
 989                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 990                     prev = k;
 991                 }
 992             }
 993         }
 994     }
 995 }
 996
 997 static int dv_encode_video_segment(AVCodecContext *avctx, DVwork_chunk *work_chunk)
 998 {
 999     DVVideoContext *s = avctx->priv_data;
1000     int mb_index, i, j;
1001     int mb_x, mb_y, c_offset, linesize, y_stride;
1002     uint8_t*  y_ptr;
1003     uint8_t*  dif;
1004     uint8_t   scratch[64];
1005     EncBlockInfo  enc_blks[5*DV_MAX_BPM];
1006     PutBitContext pbs[5*DV_MAX_BPM];
1007     PutBitContext* pb;
1008     EncBlockInfo* enc_blk;
1009     int       vs_bit_size = 0;
1010     int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
1011     int*      qnosp = &qnos[0];
1012
1013     dif = &s->buf[work_chunk->buf_offset*80];
1014     enc_blk = &enc_blks[0];
1015     for (mb_index = 0; mb_index < 5; mb_index++) {
1016         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
1017
1018         /* initializing luminance blocks */
1019         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
1020             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
1021             (s->sys->height >= 720 && mb_y != 134)) {
1022             y_stride = s->picture.linesize[0] << 3;
1023         } else {
1024             y_stride = 16;
1025         }
1026         y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
1027         linesize = s->picture.linesize[0];
1028
1029         if (s->sys->video_stype == 4) { /* SD 422 */
1030             vs_bit_size +=
1031             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
1032             dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
1033             dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
1034             dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
1035         } else {
1036             vs_bit_size +=
1037             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
1038             dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
1039             dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
1040             dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
1041         }
1042         enc_blk += 4;
1043
1044         /* initializing chrominance blocks */
1045         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
1046                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
1047         for (j = 2; j; j--) {
1048             uint8_t *c_ptr = s->picture.data[j] + c_offset;
1049             linesize = s->picture.linesize[j];
1050             y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
1051             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
1052                 uint8_t* d;
1053                 uint8_t* b = scratch;
1054                 for (i = 0; i < 8; i++) {
1055                     d = c_ptr + (linesize << 3);
1056                     b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
1057                     b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
1058                     c_ptr += linesize;
1059                     b += 8;
1060                 }
1061                 c_ptr = scratch;
1062                 linesize = 8;
1063             }
1064
1065             vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
1066             if (s->sys->bpm == 8) {
1067                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1068             }
1069         }
1070     }
1071
1072     if (vs_total_ac_bits < vs_bit_size)
1073         dv_guess_qnos(&enc_blks[0], qnosp);
1074
1075     /* DIF encoding process */
1076     for (j=0; j<5*s->sys->bpm;) {
1077         int start_mb = j;
1078
1079         dif[3] = *qnosp++;
1080         dif += 4;
1081
1082         /* First pass over individual cells only */
1083         for (i=0; i<s->sys->bpm; i++, j++) {
1084             int sz = s->sys->block_sizes[i]>>3;
1085
1086             init_put_bits(&pbs[j], dif, sz);
1087             put_bits(&pbs[j], 9, (uint16_t)(((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2));
1088             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1089             put_bits(&pbs[j], 2, enc_blks[j].cno);
1090
1091             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1092             dif += sz;
1093         }
1094
1095         /* Second pass over each MB space */
1096         pb = &pbs[start_mb];
1097         for (i=0; i<s->sys->bpm; i++) {
1098             if (enc_blks[start_mb+i].partial_bit_count)
1099                 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1100         }
1101     }
1102
1103     /* Third and final pass over the whole video segment space */
1104     pb = &pbs[0];
1105     for (j=0; j<5*s->sys->bpm; j++) {
1106        if (enc_blks[j].partial_bit_count)
1107            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1108        if (enc_blks[j].partial_bit_count)
1109             av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
1110     }
1111
1112     for (j=0; j<5*s->sys->bpm; j++)
1113        flush_put_bits(&pbs[j]);
1114
1115     return 0;
1116 }
1117
1118 #if CONFIG_DVVIDEO_DECODER
1119 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1120    144000 bytes for PAL - or twice those for 50Mbps) */
1121 static int dvvideo_decode_frame(AVCodecContext *avctx,
1122                                  void *data, int *data_size,
1123                                  const uint8_t *buf, int buf_size)
1124 {
1125     DVVideoContext *s = avctx->priv_data;
1126
1127     s->sys = dv_frame_profile(buf);
1128     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1129         return -1; /* NOTE: we only accept several full frames */
1130
1131     if (s->picture.data[0])
1132         avctx->release_buffer(avctx, &s->picture);
1133
1134     s->picture.reference = 0;
1135     s->picture.key_frame = 1;
1136     s->picture.pict_type = FF_I_TYPE;
1137     avctx->pix_fmt   = s->sys->pix_fmt;
1138     avctx->time_base = s->sys->time_base;
1139     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1140     if (avctx->get_buffer(avctx, &s->picture) < 0) {
1141         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1142         return -1;
1143     }
1144     s->picture.interlaced_frame = 1;
1145     s->picture.top_field_first  = 0;
1146
1147     s->buf = buf;
1148     avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1149                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1150
1151     emms_c();
1152
1153     /* return image */
1154     *data_size = sizeof(AVFrame);
1155     *(AVFrame*)data = s->picture;
1156
1157     return s->sys->frame_size;
1158 }
1159 #endif /* CONFIG_DVVIDEO_DECODER */
1160
1161
1162 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1163                                 uint8_t* buf)
1164 {
1165     /*
1166      * Here's what SMPTE314M says about these two:
1167      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1168      *             as track application IDs (APTn = 001, AP1n =
1169      *             001, AP2n = 001, AP3n = 001), if the source signal
1170      *             comes from a digital VCR. If the signal source is
1171      *             unknown, all bits for these data shall be set to 1.
1172      *    (page 12) STYPE: STYPE defines a signal type of video signal
1173      *                     00000b = 4:1:1 compression
1174      *                     00100b = 4:2:2 compression
1175      *                     XXXXXX = Reserved
1176      * Now, I've got two problems with these statements:
1177      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1178      *      It seems that for PAL as defined in IEC 61834 we have to set
1179      *      APT to 000 and for SMPTE314M to 001.
1180      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1181      *      compression scheme (if any).
1182      */
1183     int apt   = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1184     int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0);
1185
1186     uint8_t aspect = 0;
1187     if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */
1188         aspect = 0x02;
1189
1190     buf[0] = (uint8_t)pack_id;
1191     switch (pack_id) {
1192     case dv_header525: /* I can't imagine why these two weren't defined as real */
1193     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1194           buf[1] = 0xf8 |        /* reserved -- always 1 */
1195                    (apt & 0x07); /* APT: Track application ID */
1196           buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1197                    (0x0f << 3) | /* reserved -- always 1 */
1198                    (apt & 0x07); /* AP1: Audio application ID */
1199           buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1200                    (0x0f << 3) | /* reserved -- always 1 */
1201                    (apt & 0x07); /* AP2: Video application ID */
1202           buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1203                    (0x0f << 3) | /* reserved -- always 1 */
1204                    (apt & 0x07); /* AP3: Subcode application ID */
1205           break;
1206     case dv_video_source:
1207           buf[1] = 0xff;      /* reserved -- always 1 */
1208           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1209                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1210                    (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1211                    0xf;       /* reserved -- always 1 */
1212           buf[3] = (3 << 6) | /* reserved -- always 1 */
1213                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1214                    stype;               /* signal type video compression */
1215           buf[4] = 0xff;      /* VISC: 0xff -- no information */
1216           break;
1217     case dv_video_control:
1218           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1219                    0x3f;      /* reserved -- always 1 */
1220           buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
1221                    aspect;
1222           buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1223                    (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1224                    (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1225                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1226                    0xc;       /* reserved -- always b1100 */
1227           buf[4] = 0xff;      /* reserved -- always 1 */
1228           break;
1229     default:
1230           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1231     }
1232     return 5;
1233 }
1234
1235 #if CONFIG_DVVIDEO_ENCODER
1236 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1237 {
1238     int chan, i, j, k;
1239
1240     for (chan = 0; chan < c->sys->n_difchan; chan++) {
1241         for (i = 0; i < c->sys->difseg_size; i++) {
1242             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1243
1244             /* DV header: 1DIF */
1245             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1246             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1247             buf += 72; /* unused bytes */
1248
1249             /* DV subcode: 2DIFs */
1250             for (j = 0; j < 2; j++) {
1251                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1252                 for (k = 0; k < 6; k++)
1253                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1254                 buf += 29; /* unused bytes */
1255             }
1256
1257             /* DV VAUX: 3DIFS */
1258             for (j = 0; j < 3; j++) {
1259                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1260                 buf += dv_write_pack(dv_video_source,  c, buf);
1261                 buf += dv_write_pack(dv_video_control, c, buf);
1262                 buf += 7*5;
1263                 buf += dv_write_pack(dv_video_source,  c, buf);
1264                 buf += dv_write_pack(dv_video_control, c, buf);
1265                 buf += 4*5 + 2; /* unused bytes */
1266             }
1267
1268             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1269             for (j = 0; j < 135; j++) {
1270                 if (j%15 == 0) {
1271                     memset(buf, 0xff, 80);
1272                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1273                     buf += 77; /* audio control & shuffled PCM audio */
1274                 }
1275                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1276                 buf += 77; /* 1 video macroblock: 1 bytes control
1277                               4 * 14 bytes Y 8x8 data
1278                               10 bytes Cr 8x8 data
1279                               10 bytes Cb 8x8 data */
1280             }
1281         }
1282     }
1283 }
1284
1285
1286 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1287                                 void *data)
1288 {
1289     DVVideoContext *s = c->priv_data;
1290
1291     s->sys = dv_codec_profile(c);
1292     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1293         return -1;
1294
1295     c->pix_fmt           = s->sys->pix_fmt;
1296     s->picture           = *((AVFrame *)data);
1297     s->picture.key_frame = 1;
1298     s->picture.pict_type = FF_I_TYPE;
1299
1300     s->buf = buf;
1301     c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1302                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1303
1304     emms_c();
1305
1306     dv_format_frame(s, buf);
1307
1308     return s->sys->frame_size;
1309 }
1310 #endif
1311
1312 static int dvvideo_close(AVCodecContext *c)
1313 {
1314     DVVideoContext *s = c->priv_data;
1315
1316     if (s->picture.data[0])
1317         c->release_buffer(c, &s->picture);
1318
1319     return 0;
1320 }
1321
1322
1323 #if CONFIG_DVVIDEO_ENCODER
1324 AVCodec dvvideo_encoder = {
1325     "dvvideo",
1326     CODEC_TYPE_VIDEO,
1327     CODEC_ID_DVVIDEO,
1328     sizeof(DVVideoContext),
1329     dvvideo_init,
1330     dvvideo_encode_frame,
1331     .pix_fmts  = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1332     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1333 };
1334 #endif // CONFIG_DVVIDEO_ENCODER
1335
1336 #if CONFIG_DVVIDEO_DECODER
1337 AVCodec dvvideo_decoder = {
1338     "dvvideo",
1339     CODEC_TYPE_VIDEO,
1340     CODEC_ID_DVVIDEO,
1341     sizeof(DVVideoContext),
1342     dvvideo_init,
1343     NULL,
1344     dvvideo_close,
1345     dvvideo_decode_frame,
1346     CODEC_CAP_DR1,
1347     NULL,
1348     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1349 };
1350 #endif