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 libavcodec/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, void *arg)
 511 {
 512     DVVideoContext *s = avctx->priv_data;
 513     DVwork_chunk *work_chunk = arg;
 514     int quant, dc, dct_mode, class1, j;
 515     int mb_index, mb_x, mb_y, last_index;
 516     int y_stride, linesize;
 517     DCTELEM *block, *block1;
 518     int c_offset;
 519     uint8_t *y_ptr;
 520     const uint8_t *buf_ptr;
 521     PutBitContext pb, vs_pb;
 522     GetBitContext gb;
 523     BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
 524     DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
 525     DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
 526     DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
 527     const int log2_blocksize = 3-s->avctx->lowres;
 528     int is_field_mode[5];
 529
 530     assert((((int)mb_bit_buffer) & 7) == 0);
 531     assert((((int)vs_bit_buffer) & 7) == 0);
 532
 533     memset(sblock, 0, sizeof(sblock));
 534
 535     /* pass 1 : read DC and AC coefficients in blocks */
 536     buf_ptr = &s->buf[work_chunk->buf_offset*80];
 537     block1  = &sblock[0][0];
 538     mb1     = mb_data;
 539     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
 540     for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
 541         /* skip header */
 542         quant = buf_ptr[3] & 0x0f;
 543         buf_ptr += 4;
 544         init_put_bits(&pb, mb_bit_buffer, 80);
 545         mb    = mb1;
 546         block = block1;
 547         is_field_mode[mb_index] = 0;
 548         for (j = 0; j < s->sys->bpm; j++) {
 549             last_index = s->sys->block_sizes[j];
 550             init_get_bits(&gb, buf_ptr, last_index);
 551
 552             /* get the dc */
 553             dc       = get_sbits(&gb, 9);
 554             dct_mode = get_bits1(&gb);
 555             class1   = get_bits(&gb, 2);
 556             if (DV_PROFILE_IS_HD(s->sys)) {
 557                 mb->idct_put     = s->idct_put[0];
 558                 mb->scan_table   = s->dv_zigzag[0];
 559                 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
 560                 is_field_mode[mb_index] |= !j && dct_mode;
 561             } else {
 562                 mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
 563                 mb->scan_table   = s->dv_zigzag[dct_mode];
 564                 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
 565                                                         (quant + dv_quant_offset[class1])*64];
 566             }
 567             dc = dc << 2;
 568             /* convert to unsigned because 128 is not added in the
 569                standard IDCT */
 570             dc += 1024;
 571             block[0] = dc;
 572             buf_ptr += last_index >> 3;
 573             mb->pos               = 0;
 574             mb->partial_bit_count = 0;
 575
 576 #ifdef VLC_DEBUG
 577             printf("MB block: %d, %d ", mb_index, j);
 578 #endif
 579             dv_decode_ac(&gb, mb, block);
 580
 581             /* write the remaining bits  in a new buffer only if the
 582                block is finished */
 583             if (mb->pos >= 64)
 584                 bit_copy(&pb, &gb);
 585
 586             block += 64;
 587             mb++;
 588         }
 589
 590         /* pass 2 : we can do it just after */
 591 #ifdef VLC_DEBUG
 592         printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
 593 #endif
 594         block = block1;
 595         mb    = mb1;
 596         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
 597         flush_put_bits(&pb);
 598         for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
 599             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
 600                 dv_decode_ac(&gb, mb, block);
 601                 /* if still not finished, no need to parse other blocks */
 602                 if (mb->pos < 64)
 603                     break;
 604             }
 605         }
 606         /* all blocks are finished, so the extra bytes can be used at
 607            the video segment level */
 608         if (j >= s->sys->bpm)
 609             bit_copy(&vs_pb, &gb);
 610     }
 611
 612     /* we need a pass other the whole video segment */
 613 #ifdef VLC_DEBUG
 614     printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
 615 #endif
 616     block = &sblock[0][0];
 617     mb    = mb_data;
 618     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
 619     flush_put_bits(&vs_pb);
 620     for (mb_index = 0; mb_index < 5; mb_index++) {
 621         for (j = 0; j < s->sys->bpm; j++) {
 622             if (mb->pos < 64) {
 623 #ifdef VLC_DEBUG
 624                 printf("start %d:%d\n", mb_index, j);
 625 #endif
 626                 dv_decode_ac(&gb, mb, block);
 627             }
 628             if (mb->pos >= 64 && mb->pos < 127)
 629                 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
 630             block += 64;
 631             mb++;
 632         }
 633     }
 634
 635     /* compute idct and place blocks */
 636     block = &sblock[0][0];
 637     mb    = mb_data;
 638     for (mb_index = 0; mb_index < 5; mb_index++) {
 639         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
 640
 641         /* idct_put'ting luminance */
 642         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
 643             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
 644             (s->sys->height >= 720 && mb_y != 134)) {
 645             y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
 646         } else {
 647             y_stride = (2 << log2_blocksize);
 648         }
 649         y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
 650         linesize = s->picture.linesize[0] << is_field_mode[mb_index];
 651         mb[0]    .idct_put(y_ptr                                   , linesize, block + 0*64);
 652         if (s->sys->video_stype == 4) { /* SD 422 */
 653             mb[2].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 2*64);
 654         } else {
 655             mb[1].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 1*64);
 656             mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2*64);
 657             mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
 658         }
 659         mb += 4;
 660         block += 4*64;
 661
 662         /* idct_put'ting chrominance */
 663         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
 664                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
 665         for (j = 2; j; j--) {
 666             uint8_t *c_ptr = s->picture.data[j] + c_offset;
 667             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 668                   uint64_t aligned_pixels[64/8];
 669                   uint8_t *pixels = (uint8_t*)aligned_pixels;
 670                   uint8_t *c_ptr1, *ptr1;
 671                   int x, y;
 672                   mb->idct_put(pixels, 8, block);
 673                   for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
 674                       ptr1   = pixels + (1 << (log2_blocksize - 1));
 675                       c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
 676                       for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
 677                           c_ptr[x]  = pixels[x];
 678                           c_ptr1[x] = ptr1[x];
 679                       }
 680                   }
 681                   block += 64; mb++;
 682             } else {
 683                   y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
 684                                              s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
 685                   linesize = s->picture.linesize[j] << is_field_mode[mb_index];
 686                   (mb++)->    idct_put(c_ptr           , linesize, block); block += 64;
 687                   if (s->sys->bpm == 8) {
 688                       (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
 689                   }
 690             }
 691         }
 692     }
 693     return 0;
 694 }
 695
 696 #if CONFIG_SMALL
 697 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
 698 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
 699 {
 700     int size;
 701     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 702         *vlc = dv_vlc_map[run][level].vlc | sign;
 703         size = dv_vlc_map[run][level].size;
 704     }
 705     else {
 706         if (level < DV_VLC_MAP_LEV_SIZE) {
 707             *vlc = dv_vlc_map[0][level].vlc | sign;
 708             size = dv_vlc_map[0][level].size;
 709         } else {
 710             *vlc = 0xfe00 | (level << 1) | sign;
 711             size = 16;
 712         }
 713         if (run) {
 714             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
 715                                   (0x1f80 | (run - 1))) << size;
 716             size +=  (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 717         }
 718     }
 719
 720     return size;
 721 }
 722
 723 static av_always_inline int dv_rl2vlc_size(int run, int level)
 724 {
 725     int size;
 726
 727     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 728         size = dv_vlc_map[run][level].size;
 729     }
 730     else {
 731         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
 732         if (run) {
 733             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 734         }
 735     }
 736     return size;
 737 }
 738 #else
 739 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
 740 {
 741     *vlc = dv_vlc_map[run][l].vlc | sign;
 742     return dv_vlc_map[run][l].size;
 743 }
 744
 745 static av_always_inline int dv_rl2vlc_size(int run, int l)
 746 {
 747     return dv_vlc_map[run][l].size;
 748 }
 749 #endif
 750
 751 typedef struct EncBlockInfo {
 752     int      area_q[4];
 753     int      bit_size[4];
 754     int      prev[5];
 755     int      cur_ac;
 756     int      cno;
 757     int      dct_mode;
 758     DCTELEM  mb[64];
 759     uint8_t  next[64];
 760     uint8_t  sign[64];
 761     uint8_t  partial_bit_count;
 762     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
 763 } EncBlockInfo;
 764
 765 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
 766                                                     PutBitContext* pb_pool,
 767                                                     PutBitContext* pb_end)
 768 {
 769     int prev, bits_left;
 770     PutBitContext* pb = pb_pool;
 771     int size = bi->partial_bit_count;
 772     uint32_t vlc = bi->partial_bit_buffer;
 773
 774     bi->partial_bit_count = bi->partial_bit_buffer = 0;
 775     for (;;){
 776        /* Find suitable storage space */
 777        for (; size > (bits_left = put_bits_left(pb)); pb++) {
 778           if (bits_left) {
 779               size -= bits_left;
 780               put_bits(pb, bits_left, vlc >> size);
 781               vlc = vlc & ((1 << size) - 1);
 782           }
 783           if (pb + 1 >= pb_end) {
 784               bi->partial_bit_count  = size;
 785               bi->partial_bit_buffer = vlc;
 786               return pb;
 787           }
 788        }
 789
 790        /* Store VLC */
 791        put_bits(pb, size, vlc);
 792
 793        if (bi->cur_ac >= 64)
 794            break;
 795
 796        /* Construct the next VLC */
 797        prev       = bi->cur_ac;
 798        bi->cur_ac = bi->next[prev];
 799        if (bi->cur_ac < 64){
 800            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
 801        } else {
 802            size = 4; vlc = 6; /* End Of Block stamp */
 803        }
 804     }
 805     return pb;
 806 }
 807
 808 //FIXME replace this by dsputil
 809 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
 810 static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
 811     DCTELEM *s;
 812     int score88  = 0;
 813     int score248 = 0;
 814     int i;
 815
 816     /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
 817     s = blk;
 818     for (i = 0; i < 7; i++) {
 819         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
 820                    SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
 821         s += 8;
 822     }
 823     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
 824     s = blk;
 825     for (i = 0; i < 6; i++) {
 826         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
 827                     SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
 828         s += 8;
 829     }
 830
 831     return (score88 - score248 > -10);
 832 }
 833
 834 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
 835 {
 836     const int *weight;
 837     const uint8_t* zigzag_scan;
 838     DECLARE_ALIGNED_16(DCTELEM, blk[64]);
 839     int i, area;
 840     /* We offer two different methods for class number assignment: the
 841        method suggested in SMPTE 314M Table 22, and an improved
 842        method. The SMPTE method is very conservative; it assigns class
 843        3 (i.e. severe quantization) to any block where the largest AC
 844        component is greater than 36. FFmpeg's DV encoder tracks AC bit
 845        consumption precisely, so there is no need to bias most blocks
 846        towards strongly lossy compression. Instead, we assign class 2
 847        to most blocks, and use class 3 only when strictly necessary
 848        (for blocks whose largest AC component exceeds 255). */
 849
 850 #if 0 /* SMPTE spec method */
 851     static const int classes[] = {12, 24, 36, 0xffff};
 852 #else /* improved FFmpeg method */
 853     static const int classes[] = {-1, -1, 255, 0xffff};
 854 #endif
 855     int max  = classes[0];
 856     int prev = 0;
 857
 858     assert((((int)blk) & 15) == 0);
 859
 860     bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
 861     bi->partial_bit_count = 0;
 862     bi->partial_bit_buffer = 0;
 863     bi->cur_ac = 0;
 864     if (data) {
 865         s->get_pixels(blk, data, linesize);
 866         bi->dct_mode = (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) &&
 867                        dv_guess_dct_mode(blk);
 868         s->fdct[bi->dct_mode](blk);
 869     } else {
 870         /* We rely on the fact that encoding all zeros leads to an immediate EOB,
 871            which is precisely what the spec calls for in the "dummy" blocks. */
 872         memset(blk, 0, sizeof(blk));
 873         bi->dct_mode = 0;
 874     }
 875     bi->mb[0] = blk[0];
 876
 877     zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
 878     weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
 879
 880     for (area = 0; area < 4; area++) {
 881        bi->prev[area]     = prev;
 882        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 883        for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
 884           int level = blk[zigzag_scan[i]];
 885
 886           if (level + 15 > 30U) {
 887               bi->sign[i] = (level >> 31) & 1;
 888               /* weigh it and and shift down into range, adding for rounding */
 889               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
 890                  AND the 2x doubling of the weights */
 891               level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
 892               bi->mb[i] = level;
 893               if (level > max)
 894                   max = level;
 895               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
 896               bi->next[prev]= i;
 897               prev = i;
 898           }
 899        }
 900     }
 901     bi->next[prev]= i;
 902     for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
 903
 904     bi->cno += bias;
 905
 906     if (bi->cno >= 3) {
 907         bi->cno = 3;
 908         prev    = 0;
 909         i       = bi->next[prev];
 910         for (area = 0; area < 4; area++) {
 911             bi->prev[area]     = prev;
 912             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 913             for (; i < mb_area_start[area+1]; i = bi->next[i]) {
 914                 bi->mb[i] >>= 1;
 915
 916                 if (bi->mb[i]) {
 917                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
 918                     bi->next[prev]= i;
 919                     prev = i;
 920                 }
 921             }
 922         }
 923         bi->next[prev]= i;
 924     }
 925
 926     return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
 927 }
 928
 929 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
 930 {
 931     int size[5];
 932     int i, j, k, a, prev, a2;
 933     EncBlockInfo* b;
 934
 935     size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
 936     do {
 937        b = blks;
 938        for (i = 0; i < 5; i++) {
 939           if (!qnos[i])
 940               continue;
 941
 942           qnos[i]--;
 943           size[i] = 0;
 944           for (j = 0; j < 6; j++, b++) {
 945              for (a = 0; a < 4; a++) {
 946                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
 947                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
 948                     b->area_q[a]++;
 949                     prev = b->prev[a];
 950                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
 951                     for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
 952                        b->mb[k] >>= 1;
 953                        if (b->mb[k]) {
 954                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 955                            prev = k;
 956                        } else {
 957                            if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
 958                                 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
 959                                     b->prev[a2] = prev;
 960                                 assert(a2 < 4);
 961                                 assert(b->mb[b->next[k]]);
 962                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
 963                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
 964                                 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
 965                                 b->prev[a2] = prev;
 966                            }
 967                            b->next[prev] = b->next[k];
 968                        }
 969                     }
 970                     b->prev[a+1]= prev;
 971                 }
 972                 size[i] += b->bit_size[a];
 973              }
 974           }
 975           if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
 976                 return;
 977        }
 978     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
 979
 980
 981     for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
 982         b = blks;
 983         size[0] = 5 * 6 * 4; //EOB
 984         for (j = 0; j < 6 *5; j++, b++) {
 985             prev = b->prev[0];
 986             for (k = b->next[prev]; k < 64; k = b->next[k]) {
 987                 if (b->mb[k] < a && b->mb[k] > -a){
 988                     b->next[prev] = b->next[k];
 989                 }else{
 990                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 991                     prev = k;
 992                 }
 993             }
 994         }
 995     }
 996 }
 997
 998 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
 999 {
1000     DVVideoContext *s = avctx->priv_data;
1001     DVwork_chunk *work_chunk = arg;
1002     int mb_index, i, j;
1003     int mb_x, mb_y, c_offset, linesize, y_stride;
1004     uint8_t*  y_ptr;
1005     uint8_t*  dif;
1006     uint8_t   scratch[64];
1007     EncBlockInfo  enc_blks[5*DV_MAX_BPM];
1008     PutBitContext pbs[5*DV_MAX_BPM];
1009     PutBitContext* pb;
1010     EncBlockInfo* enc_blk;
1011     int       vs_bit_size = 0;
1012     int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
1013     int*      qnosp = &qnos[0];
1014
1015     dif = &s->buf[work_chunk->buf_offset*80];
1016     enc_blk = &enc_blks[0];
1017     for (mb_index = 0; mb_index < 5; mb_index++) {
1018         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
1019
1020         /* initializing luminance blocks */
1021         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
1022             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
1023             (s->sys->height >= 720 && mb_y != 134)) {
1024             y_stride = s->picture.linesize[0] << 3;
1025         } else {
1026             y_stride = 16;
1027         }
1028         y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
1029         linesize = s->picture.linesize[0];
1030
1031         if (s->sys->video_stype == 4) { /* SD 422 */
1032             vs_bit_size +=
1033             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
1034             dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
1035             dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
1036             dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
1037         } else {
1038             vs_bit_size +=
1039             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
1040             dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
1041             dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
1042             dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
1043         }
1044         enc_blk += 4;
1045
1046         /* initializing chrominance blocks */
1047         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
1048                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
1049         for (j = 2; j; j--) {
1050             uint8_t *c_ptr = s->picture.data[j] + c_offset;
1051             linesize = s->picture.linesize[j];
1052             y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
1053             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
1054                 uint8_t* d;
1055                 uint8_t* b = scratch;
1056                 for (i = 0; i < 8; i++) {
1057                     d = c_ptr + (linesize << 3);
1058                     b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
1059                     b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
1060                     c_ptr += linesize;
1061                     b += 8;
1062                 }
1063                 c_ptr = scratch;
1064                 linesize = 8;
1065             }
1066
1067             vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
1068             if (s->sys->bpm == 8) {
1069                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1070             }
1071         }
1072     }
1073
1074     if (vs_total_ac_bits < vs_bit_size)
1075         dv_guess_qnos(&enc_blks[0], qnosp);
1076
1077     /* DIF encoding process */
1078     for (j=0; j<5*s->sys->bpm;) {
1079         int start_mb = j;
1080
1081         dif[3] = *qnosp++;
1082         dif += 4;
1083
1084         /* First pass over individual cells only */
1085         for (i=0; i<s->sys->bpm; i++, j++) {
1086             int sz = s->sys->block_sizes[i]>>3;
1087
1088             init_put_bits(&pbs[j], dif, sz);
1089             put_bits(&pbs[j], 9, (uint16_t)(((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2));
1090             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1091             put_bits(&pbs[j], 2, enc_blks[j].cno);
1092
1093             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1094             dif += sz;
1095         }
1096
1097         /* Second pass over each MB space */
1098         pb = &pbs[start_mb];
1099         for (i=0; i<s->sys->bpm; i++) {
1100             if (enc_blks[start_mb+i].partial_bit_count)
1101                 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1102         }
1103     }
1104
1105     /* Third and final pass over the whole video segment space */
1106     pb = &pbs[0];
1107     for (j=0; j<5*s->sys->bpm; j++) {
1108        if (enc_blks[j].partial_bit_count)
1109            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1110        if (enc_blks[j].partial_bit_count)
1111             av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
1112     }
1113
1114     for (j=0; j<5*s->sys->bpm; j++)
1115        flush_put_bits(&pbs[j]);
1116
1117     return 0;
1118 }
1119
1120 #if CONFIG_DVVIDEO_DECODER
1121 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1122    144000 bytes for PAL - or twice those for 50Mbps) */
1123 static int dvvideo_decode_frame(AVCodecContext *avctx,
1124                                  void *data, int *data_size,
1125                                  const uint8_t *buf, int buf_size)
1126 {
1127     DVVideoContext *s = avctx->priv_data;
1128
1129     s->sys = dv_frame_profile(buf);
1130     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1131         return -1; /* NOTE: we only accept several full frames */
1132
1133     if (s->picture.data[0])
1134         avctx->release_buffer(avctx, &s->picture);
1135
1136     s->picture.reference = 0;
1137     s->picture.key_frame = 1;
1138     s->picture.pict_type = FF_I_TYPE;
1139     avctx->pix_fmt   = s->sys->pix_fmt;
1140     avctx->time_base = s->sys->time_base;
1141     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1142     if (avctx->get_buffer(avctx, &s->picture) < 0) {
1143         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1144         return -1;
1145     }
1146     s->picture.interlaced_frame = 1;
1147     s->picture.top_field_first  = 0;
1148
1149     s->buf = buf;
1150     avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1151                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1152
1153     emms_c();
1154
1155     /* return image */
1156     *data_size = sizeof(AVFrame);
1157     *(AVFrame*)data = s->picture;
1158
1159     return s->sys->frame_size;
1160 }
1161 #endif /* CONFIG_DVVIDEO_DECODER */
1162
1163
1164 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1165                                 uint8_t* buf)
1166 {
1167     /*
1168      * Here's what SMPTE314M says about these two:
1169      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1170      *             as track application IDs (APTn = 001, AP1n =
1171      *             001, AP2n = 001, AP3n = 001), if the source signal
1172      *             comes from a digital VCR. If the signal source is
1173      *             unknown, all bits for these data shall be set to 1.
1174      *    (page 12) STYPE: STYPE defines a signal type of video signal
1175      *                     00000b = 4:1:1 compression
1176      *                     00100b = 4:2:2 compression
1177      *                     XXXXXX = Reserved
1178      * Now, I've got two problems with these statements:
1179      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1180      *      It seems that for PAL as defined in IEC 61834 we have to set
1181      *      APT to 000 and for SMPTE314M to 001.
1182      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1183      *      compression scheme (if any).
1184      */
1185     int apt   = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1186
1187     uint8_t aspect = 0;
1188     if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1189         aspect = 0x02;
1190
1191     buf[0] = (uint8_t)pack_id;
1192     switch (pack_id) {
1193     case dv_header525: /* I can't imagine why these two weren't defined as real */
1194     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1195           buf[1] = 0xf8 |        /* reserved -- always 1 */
1196                    (apt & 0x07); /* APT: Track application ID */
1197           buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1198                    (0x0f << 3) | /* reserved -- always 1 */
1199                    (apt & 0x07); /* AP1: Audio application ID */
1200           buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1201                    (0x0f << 3) | /* reserved -- always 1 */
1202                    (apt & 0x07); /* AP2: Video application ID */
1203           buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1204                    (0x0f << 3) | /* reserved -- always 1 */
1205                    (apt & 0x07); /* AP3: Subcode application ID */
1206           break;
1207     case dv_video_source:
1208           buf[1] = 0xff;      /* reserved -- always 1 */
1209           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1210                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1211                    (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1212                    0xf;       /* reserved -- always 1 */
1213           buf[3] = (3 << 6) | /* reserved -- always 1 */
1214                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1215                    c->sys->video_stype; /* signal type video compression */
1216           buf[4] = 0xff;      /* VISC: 0xff -- no information */
1217           break;
1218     case dv_video_control:
1219           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1220                    0x3f;      /* reserved -- always 1 */
1221           buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
1222                    aspect;
1223           buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1224                    (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1225                    (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1226                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1227                    0xc;       /* reserved -- always b1100 */
1228           buf[4] = 0xff;      /* reserved -- always 1 */
1229           break;
1230     default:
1231           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1232     }
1233     return 5;
1234 }
1235
1236 #if CONFIG_DVVIDEO_ENCODER
1237 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1238 {
1239     int chan, i, j, k;
1240
1241     for (chan = 0; chan < c->sys->n_difchan; chan++) {
1242         for (i = 0; i < c->sys->difseg_size; i++) {
1243             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1244
1245             /* DV header: 1DIF */
1246             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1247             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1248             buf += 72; /* unused bytes */
1249
1250             /* DV subcode: 2DIFs */
1251             for (j = 0; j < 2; j++) {
1252                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1253                 for (k = 0; k < 6; k++)
1254                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1255                 buf += 29; /* unused bytes */
1256             }
1257
1258             /* DV VAUX: 3DIFS */
1259             for (j = 0; j < 3; j++) {
1260                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1261                 buf += dv_write_pack(dv_video_source,  c, buf);
1262                 buf += dv_write_pack(dv_video_control, c, buf);
1263                 buf += 7*5;
1264                 buf += dv_write_pack(dv_video_source,  c, buf);
1265                 buf += dv_write_pack(dv_video_control, c, buf);
1266                 buf += 4*5 + 2; /* unused bytes */
1267             }
1268
1269             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1270             for (j = 0; j < 135; j++) {
1271                 if (j%15 == 0) {
1272                     memset(buf, 0xff, 80);
1273                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1274                     buf += 77; /* audio control & shuffled PCM audio */
1275                 }
1276                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1277                 buf += 77; /* 1 video macroblock: 1 bytes control
1278                               4 * 14 bytes Y 8x8 data
1279                               10 bytes Cr 8x8 data
1280                               10 bytes Cb 8x8 data */
1281             }
1282         }
1283     }
1284 }
1285
1286
1287 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1288                                 void *data)
1289 {
1290     DVVideoContext *s = c->priv_data;
1291
1292     s->sys = dv_codec_profile(c);
1293     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1294         return -1;
1295
1296     c->pix_fmt           = s->sys->pix_fmt;
1297     s->picture           = *((AVFrame *)data);
1298     s->picture.key_frame = 1;
1299     s->picture.pict_type = FF_I_TYPE;
1300
1301     s->buf = buf;
1302     c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1303                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1304
1305     emms_c();
1306
1307     dv_format_frame(s, buf);
1308
1309     return s->sys->frame_size;
1310 }
1311 #endif
1312
1313 static int dvvideo_close(AVCodecContext *c)
1314 {
1315     DVVideoContext *s = c->priv_data;
1316
1317     if (s->picture.data[0])
1318         c->release_buffer(c, &s->picture);
1319
1320     return 0;
1321 }
1322
1323
1324 #if CONFIG_DVVIDEO_ENCODER
1325 AVCodec dvvideo_encoder = {
1326     "dvvideo",
1327     CODEC_TYPE_VIDEO,
1328     CODEC_ID_DVVIDEO,
1329     sizeof(DVVideoContext),
1330     dvvideo_init,
1331     dvvideo_encode_frame,
1332     .pix_fmts  = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1333     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1334 };
1335 #endif // CONFIG_DVVIDEO_ENCODER
1336
1337 #if CONFIG_DVVIDEO_DECODER
1338 AVCodec dvvideo_decoder = {
1339     "dvvideo",
1340     CODEC_TYPE_VIDEO,
1341     CODEC_ID_DVVIDEO,
1342     sizeof(DVVideoContext),
1343     dvvideo_init,
1344     NULL,
1345     dvvideo_close,
1346     dvvideo_decode_frame,
1347     CODEC_CAP_DR1,
1348     NULL,
1349     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1350 };
1351 #endif