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