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;
1002     uint8_t*  y_ptr;
1003     uint8_t*  data;
1004     uint8_t*  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];
1013
1014     dif = &s->buf[work_chunk->buf_offset*80];
1015     enc_blk = &enc_blks[0];
1016     pb = &pbs[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         y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
1020         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
1021                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
1022         qnos[mb_index] = 15; /* No quantization */
1023         ptr = dif + mb_index*80 + 4;
1024         for (j = 0; j < 6; j++) {
1025             if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
1026                 if (j == 0 || j == 2) {
1027                     /* Y0 Y1 */
1028                     data     = y_ptr + ((j >> 1) * 8);
1029                     linesize = s->picture.linesize[0];
1030                 } else if (j > 3) {
1031                     /* Cr Cb */
1032                     data     = s->picture.data[6 - j] + c_offset;
1033                     linesize = s->picture.linesize[6 - j];
1034                 } else {
1035                     /* j=1 and j=3 are "dummy" blocks, used for AC data only */
1036                     data     = NULL;
1037                     linesize = 0;
1038                 }
1039             } else { /* 4:1:1 or 4:2:0 */
1040                 if (j < 4) {  /* Four Y blocks */
1041                     /* NOTE: at end of line, the macroblock is handled as 420 */
1042                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
1043                         data = y_ptr + (j * 8);
1044                     } else {
1045                         data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
1046                     }
1047                     linesize = s->picture.linesize[0];
1048                 } else {      /* Cr and Cb blocks */
1049                     /* don't ask Fabrice why they inverted Cb and Cr ! */
1050                     data     = s->picture.data    [6 - j] + c_offset;
1051                     linesize = s->picture.linesize[6 - j];
1052            if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
1053                 uint8_t* d;
1054                 uint8_t* b = scratch;
1055                 for (i = 0; i < 8; i++) {
1056                    d = data + 8 * linesize;
1057                    b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
1058                    b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
1059                    data += linesize;
1060                    b += 8;
1061                 }
1062                data = scratch;
1063                linesize = 8;
1064            }
1065                 }
1066             }
1067
1068             vs_bit_size += dv_init_enc_block(enc_blk, data, linesize, s, j>>2);
1069
1070             init_put_bits(pb, ptr, s->sys->block_sizes[j]/8);
1071             put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
1072             put_bits(pb, 1, enc_blk->dct_mode);
1073             put_bits(pb, 2, enc_blk->cno);
1074
1075             ++enc_blk;
1076             ++pb;
1077             ptr += s->sys->block_sizes[j]/8;
1078         }
1079     }
1080
1081     if (vs_total_ac_bits < vs_bit_size)
1082         dv_guess_qnos(&enc_blks[0], &qnos[0]);
1083
1084     for (i = 0; i < 5; i++) {
1085        dif[i*80 + 3] = qnos[i];
1086     }
1087
1088     /* First pass over individual cells only */
1089     for (j = 0; j < 5 * s->sys->bpm; j++)
1090        dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1091
1092     /* Second pass over each MB space */
1093     for (j=0; j<5*s->sys->bpm; j+=s->sys->bpm) {
1094         pb = &pbs[j];
1095         for (i=0; i<s->sys->bpm; i++) {
1096             if (enc_blks[i+j].partial_bit_count)
1097                 pb = dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+s->sys->bpm]);
1098         }
1099     }
1100
1101     /* Third and final pass over the whole video segment space */
1102     pb = &pbs[0];
1103     for (j=0; j<5*s->sys->bpm; j++) {
1104        if (enc_blks[j].partial_bit_count)
1105            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1106        if (enc_blks[j].partial_bit_count)
1107             av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
1108     }
1109
1110     for (j=0; j<5*s->sys->bpm; j++)
1111        flush_put_bits(&pbs[j]);
1112
1113     return 0;
1114 }
1115
1116 #if CONFIG_DVVIDEO_DECODER
1117 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1118    144000 bytes for PAL - or twice those for 50Mbps) */
1119 static int dvvideo_decode_frame(AVCodecContext *avctx,
1120                                  void *data, int *data_size,
1121                                  const uint8_t *buf, int buf_size)
1122 {
1123     DVVideoContext *s = avctx->priv_data;
1124
1125     s->sys = dv_frame_profile(buf);
1126     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1127         return -1; /* NOTE: we only accept several full frames */
1128
1129     if (s->picture.data[0])
1130         avctx->release_buffer(avctx, &s->picture);
1131
1132     s->picture.reference = 0;
1133     s->picture.key_frame = 1;
1134     s->picture.pict_type = FF_I_TYPE;
1135     avctx->pix_fmt   = s->sys->pix_fmt;
1136     avctx->time_base = s->sys->time_base;
1137     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1138     if (avctx->get_buffer(avctx, &s->picture) < 0) {
1139         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1140         return -1;
1141     }
1142     s->picture.interlaced_frame = 1;
1143     s->picture.top_field_first  = 0;
1144
1145     s->buf = buf;
1146     avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1147                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1148
1149     emms_c();
1150
1151     /* return image */
1152     *data_size = sizeof(AVFrame);
1153     *(AVFrame*)data = s->picture;
1154
1155     return s->sys->frame_size;
1156 }
1157 #endif /* CONFIG_DVVIDEO_DECODER */
1158
1159
1160 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1161                                 uint8_t* buf)
1162 {
1163     /*
1164      * Here's what SMPTE314M says about these two:
1165      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1166      *             as track application IDs (APTn = 001, AP1n =
1167      *             001, AP2n = 001, AP3n = 001), if the source signal
1168      *             comes from a digital VCR. If the signal source is
1169      *             unknown, all bits for these data shall be set to 1.
1170      *    (page 12) STYPE: STYPE defines a signal type of video signal
1171      *                     00000b = 4:1:1 compression
1172      *                     00100b = 4:2:2 compression
1173      *                     XXXXXX = Reserved
1174      * Now, I've got two problems with these statements:
1175      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1176      *      It seems that for PAL as defined in IEC 61834 we have to set
1177      *      APT to 000 and for SMPTE314M to 001.
1178      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1179      *      compression scheme (if any).
1180      */
1181     int apt   = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1182     int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0);
1183
1184     uint8_t aspect = 0;
1185     if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */
1186         aspect = 0x02;
1187
1188     buf[0] = (uint8_t)pack_id;
1189     switch (pack_id) {
1190     case dv_header525: /* I can't imagine why these two weren't defined as real */
1191     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1192           buf[1] = 0xf8 |        /* reserved -- always 1 */
1193                    (apt & 0x07); /* APT: Track application ID */
1194           buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1195                    (0x0f << 3) | /* reserved -- always 1 */
1196                    (apt & 0x07); /* AP1: Audio application ID */
1197           buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1198                    (0x0f << 3) | /* reserved -- always 1 */
1199                    (apt & 0x07); /* AP2: Video application ID */
1200           buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1201                    (0x0f << 3) | /* reserved -- always 1 */
1202                    (apt & 0x07); /* AP3: Subcode application ID */
1203           break;
1204     case dv_video_source:
1205           buf[1] = 0xff;      /* reserved -- always 1 */
1206           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1207                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1208                    (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1209                    0xf;       /* reserved -- always 1 */
1210           buf[3] = (3 << 6) | /* reserved -- always 1 */
1211                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1212                    stype;               /* signal type video compression */
1213           buf[4] = 0xff;      /* VISC: 0xff -- no information */
1214           break;
1215     case dv_video_control:
1216           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1217                    0x3f;      /* reserved -- always 1 */
1218           buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
1219                    aspect;
1220           buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1221                    (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1222                    (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1223                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1224                    0xc;       /* reserved -- always b1100 */
1225           buf[4] = 0xff;      /* reserved -- always 1 */
1226           break;
1227     default:
1228           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1229     }
1230     return 5;
1231 }
1232
1233 #if CONFIG_DVVIDEO_ENCODER
1234 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1235 {
1236     int chan, i, j, k;
1237
1238     for (chan = 0; chan < c->sys->n_difchan; chan++) {
1239         for (i = 0; i < c->sys->difseg_size; i++) {
1240             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1241
1242             /* DV header: 1DIF */
1243             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1244             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1245             buf += 72; /* unused bytes */
1246
1247             /* DV subcode: 2DIFs */
1248             for (j = 0; j < 2; j++) {
1249                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1250                 for (k = 0; k < 6; k++)
1251                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1252                 buf += 29; /* unused bytes */
1253             }
1254
1255             /* DV VAUX: 3DIFS */
1256             for (j = 0; j < 3; j++) {
1257                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1258                 buf += dv_write_pack(dv_video_source,  c, buf);
1259                 buf += dv_write_pack(dv_video_control, c, buf);
1260                 buf += 7*5;
1261                 buf += dv_write_pack(dv_video_source,  c, buf);
1262                 buf += dv_write_pack(dv_video_control, c, buf);
1263                 buf += 4*5 + 2; /* unused bytes */
1264             }
1265
1266             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1267             for (j = 0; j < 135; j++) {
1268                 if (j%15 == 0) {
1269                     memset(buf, 0xff, 80);
1270                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1271                     buf += 77; /* audio control & shuffled PCM audio */
1272                 }
1273                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1274                 buf += 77; /* 1 video macroblock: 1 bytes control
1275                               4 * 14 bytes Y 8x8 data
1276                               10 bytes Cr 8x8 data
1277                               10 bytes Cb 8x8 data */
1278             }
1279         }
1280     }
1281 }
1282
1283
1284 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1285                                 void *data)
1286 {
1287     DVVideoContext *s = c->priv_data;
1288
1289     s->sys = dv_codec_profile(c);
1290     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1291         return -1;
1292
1293     c->pix_fmt           = s->sys->pix_fmt;
1294     s->picture           = *((AVFrame *)data);
1295     s->picture.key_frame = 1;
1296     s->picture.pict_type = FF_I_TYPE;
1297
1298     s->buf = buf;
1299     c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1300                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1301
1302     emms_c();
1303
1304     dv_format_frame(s, buf);
1305
1306     return s->sys->frame_size;
1307 }
1308 #endif
1309
1310 static int dvvideo_close(AVCodecContext *c)
1311 {
1312     DVVideoContext *s = c->priv_data;
1313
1314     if (s->picture.data[0])
1315         c->release_buffer(c, &s->picture);
1316
1317     return 0;
1318 }
1319
1320
1321 #if CONFIG_DVVIDEO_ENCODER
1322 AVCodec dvvideo_encoder = {
1323     "dvvideo",
1324     CODEC_TYPE_VIDEO,
1325     CODEC_ID_DVVIDEO,
1326     sizeof(DVVideoContext),
1327     dvvideo_init,
1328     dvvideo_encode_frame,
1329     .pix_fmts  = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1330     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1331 };
1332 #endif // CONFIG_DVVIDEO_ENCODER
1333
1334 #if CONFIG_DVVIDEO_DECODER
1335 AVCodec dvvideo_decoder = {
1336     "dvvideo",
1337     CODEC_TYPE_VIDEO,
1338     CODEC_ID_DVVIDEO,
1339     sizeof(DVVideoContext),
1340     dvvideo_init,
1341     NULL,
1342     dvvideo_close,
1343     dvvideo_decode_frame,
1344     CODEC_CAP_DR1,
1345     NULL,
1346     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1347 };
1348 #endif