libavcodec/dv.c

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