git.sesse.net Git - ffmpeg/blob - 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 Libav.
  20  *
  21  * Libav 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  * Libav 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 Libav; 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
  38  * DV codec.
  39  */
  40
  41 #include "libavutil/internal.h"
  42 #include "libavutil/pixdesc.h"
  43 #include "avcodec.h"
  44 #include "dsputil.h"
  45 #include "get_bits.h"
  46 #include "internal.h"
  47 #include "put_bits.h"
  48 #include "simple_idct.h"
  49 #include "dvdata.h"
  50 #include "dv_tablegen.h"
  51
  52 /* XXX: also include quantization */
  53 RL_VLC_ELEM ff_dv_rl_vlc[1184];
  54
  55 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
  56                                           uint16_t *tbl)
  57 {
  58     static const uint8_t off[] = { 2, 6, 8, 0, 4 };
  59     static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
  60     static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
  61     static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
  62
  63     static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
  64     static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
  65
  66     static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
  67                                        0, 1, 2, 2, 1, 0,
  68                                        0, 1, 2, 2, 1, 0,
  69                                        0, 1, 2, 2, 1, 0,
  70                                        0, 1, 2};
  71     static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
  72                                        0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
  73                                        0, 1, 2, 3, 4, 5};
  74
  75     static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
  76                                        { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
  77                                        {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
  78                                        {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
  79                                        {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
  80                                        {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
  81                                        {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
  82                                        {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
  83                                        {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
  84                                        {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
  85                                        {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
  86                                        {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
  87                                        {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
  88
  89     int i, k, m;
  90     int x, y, blk;
  91
  92     for (m=0; m<5; m++) {
  93          switch (d->width) {
  94          case 1440:
  95               blk = (chan*11+seq)*27+slot;
  96
  97               if (chan == 0 && seq == 11) {
  98                   x = m*27+slot;
  99                   if (x<90) {
 100                       y = 0;
 101                   } else {
 102                       x = (x - 90)*2;
 103                       y = 67;
 104                   }
 105               } else {
 106                   i = (4*chan + blk + off[m])%11;
 107                   k = (blk/11)%27;
 108
 109                   x = shuf1[m] + (chan&1)*9 + k%9;
 110                   y = (i*3+k/9)*2 + (chan>>1) + 1;
 111               }
 112               tbl[m] = (x<<1)|(y<<9);
 113               break;
 114          case 1280:
 115               blk = (chan*10+seq)*27+slot;
 116
 117               i = (4*chan + (seq/5) + 2*blk + off[m])%10;
 118               k = (blk/5)%27;
 119
 120               x = shuf1[m]+(chan&1)*9 + k%9;
 121               y = (i*3+k/9)*2 + (chan>>1) + 4;
 122
 123               if (x >= 80) {
 124                   x = remap[y][0]+((x-80)<<(y>59));
 125                   y = remap[y][1];
 126               }
 127               tbl[m] = (x<<1)|(y<<9);
 128               break;
 129        case 960:
 130               blk = (chan*10+seq)*27+slot;
 131
 132               i = (4*chan + (seq/5) + 2*blk + off[m])%10;
 133               k = (blk/5)%27 + (i&1)*3;
 134
 135               x = shuf2[m] + k%6 + 6*(chan&1);
 136               y = l_start[i] + k/6 + 45*(chan>>1);
 137               tbl[m] = (x<<1)|(y<<9);
 138               break;
 139         case 720:
 140               switch (d->pix_fmt) {
 141               case AV_PIX_FMT_YUV422P:
 142                    x = shuf3[m] + slot/3;
 143                    y = serpent1[slot] +
 144                        ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
 145                    tbl[m] = (x<<1)|(y<<8);
 146                    break;
 147               case AV_PIX_FMT_YUV420P:
 148                    x = shuf3[m] + slot/3;
 149                    y = serpent1[slot] +
 150                        ((seq + off[m]) % d->difseg_size)*3;
 151                    tbl[m] = (x<<1)|(y<<9);
 152                    break;
 153               case AV_PIX_FMT_YUV411P:
 154                    i = (seq + off[m]) % d->difseg_size;
 155                    k = slot + ((m==1||m==2)?3:0);
 156
 157                    x = l_start_shuffled[m] + k/6;
 158                    y = serpent2[k] + i*6;
 159                    if (x>21)
 160                        y = y*2 - i*6;
 161                    tbl[m] = (x<<2)|(y<<8);
 162                    break;
 163               }
 164         default:
 165               break;
 166         }
 167     }
 168 }
 169
 170 /* quantization quanta by QNO for DV100 */
 171 static const uint8_t dv100_qstep[16] = {
 172     1, /* QNO = 0 and 1 both have no quantization */
 173     1,
 174     2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
 175 };
 176
 177 static const uint8_t dv_quant_areas[4]  = { 6, 21, 43, 64 };
 178
 179 int ff_dv_init_dynamic_tables(const DVprofile *d)
 180 {
 181     int j,i,c,s,p;
 182     uint32_t *factor1, *factor2;
 183     const int *iweight1, *iweight2;
 184
 185     if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
 186         p = i = 0;
 187         for (c=0; c<d->n_difchan; c++) {
 188             for (s=0; s<d->difseg_size; s++) {
 189                 p += 6;
 190                 for (j=0; j<27; j++) {
 191                     p += !(j%3);
 192                     if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
 193                         !(DV_PROFILE_IS_720p50(d) && s > 9)) {
 194                           dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
 195                           d->work_chunks[i++].buf_offset = p;
 196                     }
 197                     p += 5;
 198                 }
 199             }
 200         }
 201     }
 202
 203     if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
 204         factor1 = &d->idct_factor[0];
 205         factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
 206         if (d->height == 720) {
 207             iweight1 = &ff_dv_iweight_720_y[0];
 208             iweight2 = &ff_dv_iweight_720_c[0];
 209         } else {
 210             iweight1 = &ff_dv_iweight_1080_y[0];
 211             iweight2 = &ff_dv_iweight_1080_c[0];
 212         }
 213         if (DV_PROFILE_IS_HD(d)) {
 214             for (c = 0; c < 4; c++) {
 215                 for (s = 0; s < 16; s++) {
 216                     for (i = 0; i < 64; i++) {
 217                         *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
 218                         *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
 219                     }
 220                 }
 221             }
 222         } else {
 223             iweight1 = &ff_dv_iweight_88[0];
 224             for (j = 0; j < 2; j++, iweight1 = &ff_dv_iweight_248[0]) {
 225                 for (s = 0; s < 22; s++) {
 226                     for (i = c = 0; c < 4; c++) {
 227                         for (; i < dv_quant_areas[c]; i++) {
 228                             *factor1   = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
 229                             *factor2++ = (*factor1++) << 1;
 230                         }
 231                     }
 232                 }
 233             }
 234         }
 235     }
 236
 237     return 0;
 238 }
 239
 240 av_cold int ff_dvvideo_init(AVCodecContext *avctx)
 241 {
 242     DVVideoContext *s = avctx->priv_data;
 243     DSPContext dsp;
 244     static int done = 0;
 245     int i, j;
 246
 247     if (!done) {
 248         VLC dv_vlc;
 249         uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
 250         uint8_t  new_dv_vlc_len[NB_DV_VLC*2];
 251         uint8_t  new_dv_vlc_run[NB_DV_VLC*2];
 252         int16_t  new_dv_vlc_level[NB_DV_VLC*2];
 253
 254         done = 1;
 255
 256         /* it's faster to include sign bit in a generic VLC parsing scheme */
 257         for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
 258             new_dv_vlc_bits[j]  = dv_vlc_bits[i];
 259             new_dv_vlc_len[j]   = dv_vlc_len[i];
 260             new_dv_vlc_run[j]   = dv_vlc_run[i];
 261             new_dv_vlc_level[j] = dv_vlc_level[i];
 262
 263             if (dv_vlc_level[i]) {
 264                 new_dv_vlc_bits[j] <<= 1;
 265                 new_dv_vlc_len[j]++;
 266
 267                 j++;
 268                 new_dv_vlc_bits[j]  = (dv_vlc_bits[i] << 1) | 1;
 269                 new_dv_vlc_len[j]   =  dv_vlc_len[i] + 1;
 270                 new_dv_vlc_run[j]   =  dv_vlc_run[i];
 271                 new_dv_vlc_level[j] = -dv_vlc_level[i];
 272             }
 273         }
 274
 275         /* NOTE: as a trick, we use the fact the no codes are unused
 276            to accelerate the parsing of partial codes */
 277         init_vlc(&dv_vlc, TEX_VLC_BITS, j,
 278                  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
 279         assert(dv_vlc.table_size == 1184);
 280
 281         for (i = 0; i < dv_vlc.table_size; i++){
 282             int code = dv_vlc.table[i][0];
 283             int len  = dv_vlc.table[i][1];
 284             int level, run;
 285
 286             if (len < 0){ //more bits needed
 287                 run   = 0;
 288                 level = code;
 289             } else {
 290                 run   = new_dv_vlc_run  [code] + 1;
 291                 level = new_dv_vlc_level[code];
 292             }
 293             ff_dv_rl_vlc[i].len   = len;
 294             ff_dv_rl_vlc[i].level = level;
 295             ff_dv_rl_vlc[i].run   = run;
 296         }
 297         ff_free_vlc(&dv_vlc);
 298     }
 299
 300     /* Generic DSP setup */
 301     ff_dsputil_init(&dsp, avctx);
 302     ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
 303     s->get_pixels = dsp.get_pixels;
 304     s->ildct_cmp = dsp.ildct_cmp[5];
 305
 306     /* 88DCT setup */
 307     s->fdct[0]     = dsp.fdct;
 308     s->idct_put[0] = dsp.idct_put;
 309     for (i = 0; i < 64; i++)
 310        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
 311
 312     /* 248DCT setup */
 313     s->fdct[1]     = dsp.fdct248;
 314     s->idct_put[1] = ff_simple_idct248_put;  // FIXME: need to add it to DSP
 315     memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
 316
 317     avctx->coded_frame = &s->picture;
 318     s->avctx = avctx;
 319     avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
 320
 321     return 0;
 322 }
 323
 324 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
 325 {
 326     if (!avpriv_dv_codec_profile(avctx)) {
 327         av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
 328                "Valid DV profiles are:\n",
 329                avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
 330         ff_dv_print_profiles(avctx, AV_LOG_ERROR);
 331         return AVERROR(EINVAL);
 332     }
 333
 334     dv_vlc_map_tableinit();
 335
 336     return ff_dvvideo_init(avctx);
 337 }
 338
 339 /* bit budget for AC only in 5 MBs */
 340 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
 341 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
 342
 343 static inline int put_bits_left(PutBitContext* s)
 344 {
 345     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
 346 }
 347
 348 #if CONFIG_SMALL
 349 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
 350 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
 351 {
 352     int size;
 353     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 354         *vlc = dv_vlc_map[run][level].vlc | sign;
 355         size = dv_vlc_map[run][level].size;
 356     }
 357     else {
 358         if (level < DV_VLC_MAP_LEV_SIZE) {
 359             *vlc = dv_vlc_map[0][level].vlc | sign;
 360             size = dv_vlc_map[0][level].size;
 361         } else {
 362             *vlc = 0xfe00 | (level << 1) | sign;
 363             size = 16;
 364         }
 365         if (run) {
 366             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
 367                                   (0x1f80 | (run - 1))) << size;
 368             size +=  (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 369         }
 370     }
 371
 372     return size;
 373 }
 374
 375 static av_always_inline int dv_rl2vlc_size(int run, int level)
 376 {
 377     int size;
 378
 379     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 380         size = dv_vlc_map[run][level].size;
 381     }
 382     else {
 383         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
 384         if (run) {
 385             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 386         }
 387     }
 388     return size;
 389 }
 390 #else
 391 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
 392 {
 393     *vlc = dv_vlc_map[run][l].vlc | sign;
 394     return dv_vlc_map[run][l].size;
 395 }
 396
 397 static av_always_inline int dv_rl2vlc_size(int run, int l)
 398 {
 399     return dv_vlc_map[run][l].size;
 400 }
 401 #endif
 402
 403 typedef struct EncBlockInfo {
 404     int      area_q[4];
 405     int      bit_size[4];
 406     int      prev[5];
 407     int      cur_ac;
 408     int      cno;
 409     int      dct_mode;
 410     int16_t  mb[64];
 411     uint8_t  next[64];
 412     uint8_t  sign[64];
 413     uint8_t  partial_bit_count;
 414     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
 415 } EncBlockInfo;
 416
 417 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
 418                                                     PutBitContext* pb_pool,
 419                                                     PutBitContext* pb_end)
 420 {
 421     int prev, bits_left;
 422     PutBitContext* pb = pb_pool;
 423     int size = bi->partial_bit_count;
 424     uint32_t vlc = bi->partial_bit_buffer;
 425
 426     bi->partial_bit_count = bi->partial_bit_buffer = 0;
 427     for (;;){
 428        /* Find suitable storage space */
 429        for (; size > (bits_left = put_bits_left(pb)); pb++) {
 430           if (bits_left) {
 431               size -= bits_left;
 432               put_bits(pb, bits_left, vlc >> size);
 433               vlc = vlc & ((1 << size) - 1);
 434           }
 435           if (pb + 1 >= pb_end) {
 436               bi->partial_bit_count  = size;
 437               bi->partial_bit_buffer = vlc;
 438               return pb;
 439           }
 440        }
 441
 442        /* Store VLC */
 443        put_bits(pb, size, vlc);
 444
 445        if (bi->cur_ac >= 64)
 446            break;
 447
 448        /* Construct the next VLC */
 449        prev       = bi->cur_ac;
 450        bi->cur_ac = bi->next[prev];
 451        if (bi->cur_ac < 64){
 452            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
 453        } else {
 454            size = 4; vlc = 6; /* End Of Block stamp */
 455        }
 456     }
 457     return pb;
 458 }
 459
 460 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
 461     if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
 462         int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
 463         if (ps > 0) {
 464             int is = s->ildct_cmp(NULL, data           , NULL, linesize<<1, 4) +
 465                      s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
 466             return ps > is;
 467         }
 468     }
 469
 470     return 0;
 471 }
 472
 473 static const int dv_weight_bits = 18;
 474 static const int dv_weight_88[64] = {
 475  131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
 476  237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
 477  224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
 478  212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
 479  206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
 480  200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
 481  174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
 482  170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
 483 };
 484 static const int dv_weight_248[64] = {
 485  131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
 486  224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
 487  211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
 488  242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
 489  200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
 490  229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
 491  175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
 492  195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
 493 };
 494
 495 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
 496 {
 497     const int *weight;
 498     const uint8_t* zigzag_scan;
 499     LOCAL_ALIGNED_16(int16_t, blk, [64]);
 500     int i, area;
 501     /* We offer two different methods for class number assignment: the
 502        method suggested in SMPTE 314M Table 22, and an improved
 503        method. The SMPTE method is very conservative; it assigns class
 504        3 (i.e. severe quantization) to any block where the largest AC
 505        component is greater than 36. Libav's DV encoder tracks AC bit
 506        consumption precisely, so there is no need to bias most blocks
 507        towards strongly lossy compression. Instead, we assign class 2
 508        to most blocks, and use class 3 only when strictly necessary
 509        (for blocks whose largest AC component exceeds 255). */
 510
 511 #if 0 /* SMPTE spec method */
 512     static const int classes[] = {12, 24, 36, 0xffff};
 513 #else /* improved Libav method */
 514     static const int classes[] = {-1, -1, 255, 0xffff};
 515 #endif
 516     int max  = classes[0];
 517     int prev = 0;
 518
 519     assert((((int)blk) & 15) == 0);
 520
 521     bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
 522     bi->partial_bit_count = 0;
 523     bi->partial_bit_buffer = 0;
 524     bi->cur_ac = 0;
 525     if (data) {
 526         bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
 527         s->get_pixels(blk, data, linesize);
 528         s->fdct[bi->dct_mode](blk);
 529     } else {
 530         /* We rely on the fact that encoding all zeros leads to an immediate EOB,
 531            which is precisely what the spec calls for in the "dummy" blocks. */
 532         memset(blk, 0, 64*sizeof(*blk));
 533         bi->dct_mode = 0;
 534     }
 535     bi->mb[0] = blk[0];
 536
 537     zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
 538     weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
 539
 540     for (area = 0; area < 4; area++) {
 541        bi->prev[area]     = prev;
 542        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 543        for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
 544           int level = blk[zigzag_scan[i]];
 545
 546           if (level + 15 > 30U) {
 547               bi->sign[i] = (level >> 31) & 1;
 548               /* weight it and and shift down into range, adding for rounding */
 549               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
 550                  AND the 2x doubling of the weights */
 551               level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
 552               bi->mb[i] = level;
 553               if (level > max)
 554                   max = level;
 555               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
 556               bi->next[prev]= i;
 557               prev = i;
 558           }
 559        }
 560     }
 561     bi->next[prev]= i;
 562     for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
 563
 564     bi->cno += bias;
 565
 566     if (bi->cno >= 3) {
 567         bi->cno = 3;
 568         prev    = 0;
 569         i       = bi->next[prev];
 570         for (area = 0; area < 4; area++) {
 571             bi->prev[area]     = prev;
 572             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 573             for (; i < mb_area_start[area+1]; i = bi->next[i]) {
 574                 bi->mb[i] >>= 1;
 575
 576                 if (bi->mb[i]) {
 577                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
 578                     bi->next[prev]= i;
 579                     prev = i;
 580                 }
 581             }
 582         }
 583         bi->next[prev]= i;
 584     }
 585
 586     return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
 587 }
 588
 589 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
 590 {
 591     int size[5];
 592     int i, j, k, a, prev, a2;
 593     EncBlockInfo* b;
 594
 595     size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
 596     do {
 597        b = blks;
 598        for (i = 0; i < 5; i++) {
 599           if (!qnos[i])
 600               continue;
 601
 602           qnos[i]--;
 603           size[i] = 0;
 604           for (j = 0; j < 6; j++, b++) {
 605              for (a = 0; a < 4; a++) {
 606                 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
 607                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
 608                     b->area_q[a]++;
 609                     prev = b->prev[a];
 610                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
 611                     for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
 612                        b->mb[k] >>= 1;
 613                        if (b->mb[k]) {
 614                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 615                            prev = k;
 616                        } else {
 617                            if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
 618                                 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
 619                                     b->prev[a2] = prev;
 620                                 assert(a2 < 4);
 621                                 assert(b->mb[b->next[k]]);
 622                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
 623                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
 624                                 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
 625                                 b->prev[a2] = prev;
 626                            }
 627                            b->next[prev] = b->next[k];
 628                        }
 629                     }
 630                     b->prev[a+1]= prev;
 631                 }
 632                 size[i] += b->bit_size[a];
 633              }
 634           }
 635           if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
 636                 return;
 637        }
 638     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
 639
 640
 641     for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
 642         b = blks;
 643         size[0] = 5 * 6 * 4; //EOB
 644         for (j = 0; j < 6 *5; j++, b++) {
 645             prev = b->prev[0];
 646             for (k = b->next[prev]; k < 64; k = b->next[k]) {
 647                 if (b->mb[k] < a && b->mb[k] > -a){
 648                     b->next[prev] = b->next[k];
 649                 }else{
 650                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 651                     prev = k;
 652                 }
 653             }
 654         }
 655     }
 656 }
 657
 658 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
 659 {
 660     DVVideoContext *s = avctx->priv_data;
 661     DVwork_chunk *work_chunk = arg;
 662     int mb_index, i, j;
 663     int mb_x, mb_y, c_offset, linesize, y_stride;
 664     uint8_t*  y_ptr;
 665     uint8_t*  dif;
 666     LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
 667     EncBlockInfo  enc_blks[5*DV_MAX_BPM];
 668     PutBitContext pbs[5*DV_MAX_BPM];
 669     PutBitContext* pb;
 670     EncBlockInfo* enc_blk;
 671     int       vs_bit_size = 0;
 672     int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
 673     int*      qnosp = &qnos[0];
 674
 675     dif = &s->buf[work_chunk->buf_offset*80];
 676     enc_blk = &enc_blks[0];
 677     for (mb_index = 0; mb_index < 5; mb_index++) {
 678         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
 679
 680         /* initializing luminance blocks */
 681         if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
 682             (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
 683             (s->sys->height >= 720 && mb_y != 134)) {
 684             y_stride = s->picture.linesize[0] << 3;
 685         } else {
 686             y_stride = 16;
 687         }
 688         y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
 689         linesize = s->picture.linesize[0];
 690
 691         if (s->sys->video_stype == 4) { /* SD 422 */
 692             vs_bit_size +=
 693             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
 694             dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
 695             dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
 696             dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
 697         } else {
 698             vs_bit_size +=
 699             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
 700             dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
 701             dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
 702             dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
 703         }
 704         enc_blk += 4;
 705
 706         /* initializing chrominance blocks */
 707         c_offset = (((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->picture.linesize[1] +
 708                      (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
 709         for (j = 2; j; j--) {
 710             uint8_t *c_ptr = s->picture.data[j] + c_offset;
 711             linesize = s->picture.linesize[j];
 712             y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
 713             if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 714                 uint8_t* d;
 715                 uint8_t* b = scratch;
 716                 for (i = 0; i < 8; i++) {
 717                     d = c_ptr + (linesize << 3);
 718                     b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
 719                     b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
 720                     c_ptr += linesize;
 721                     b += 16;
 722                 }
 723                 c_ptr = scratch;
 724                 linesize = 16;
 725             }
 726
 727             vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
 728             if (s->sys->bpm == 8) {
 729                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
 730             }
 731         }
 732     }
 733
 734     if (vs_total_ac_bits < vs_bit_size)
 735         dv_guess_qnos(&enc_blks[0], qnosp);
 736
 737     /* DIF encoding process */
 738     for (j=0; j<5*s->sys->bpm;) {
 739         int start_mb = j;
 740
 741         dif[3] = *qnosp++;
 742         dif += 4;
 743
 744         /* First pass over individual cells only */
 745         for (i=0; i<s->sys->bpm; i++, j++) {
 746             int sz = s->sys->block_sizes[i]>>3;
 747
 748             init_put_bits(&pbs[j], dif, sz);
 749             put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
 750             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
 751             put_bits(&pbs[j], 2, enc_blks[j].cno);
 752
 753             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
 754             dif += sz;
 755         }
 756
 757         /* Second pass over each MB space */
 758         pb = &pbs[start_mb];
 759         for (i=0; i<s->sys->bpm; i++) {
 760             if (enc_blks[start_mb+i].partial_bit_count)
 761                 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
 762         }
 763     }
 764
 765     /* Third and final pass over the whole video segment space */
 766     pb = &pbs[0];
 767     for (j=0; j<5*s->sys->bpm; j++) {
 768        if (enc_blks[j].partial_bit_count)
 769            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
 770        if (enc_blks[j].partial_bit_count)
 771             av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
 772     }
 773
 774     for (j=0; j<5*s->sys->bpm; j++) {
 775        int pos;
 776        int size = pbs[j].size_in_bits >> 3;
 777        flush_put_bits(&pbs[j]);
 778        pos = put_bits_count(&pbs[j]) >> 3;
 779        if (pos > size) {
 780            av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
 781            return -1;
 782        }
 783        memset(pbs[j].buf + pos, 0xff, size - pos);
 784     }
 785
 786     return 0;
 787 }
 788
 789 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
 790                                 uint8_t* buf)
 791 {
 792     /*
 793      * Here's what SMPTE314M says about these two:
 794      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
 795      *             as track application IDs (APTn = 001, AP1n =
 796      *             001, AP2n = 001, AP3n = 001), if the source signal
 797      *             comes from a digital VCR. If the signal source is
 798      *             unknown, all bits for these data shall be set to 1.
 799      *    (page 12) STYPE: STYPE defines a signal type of video signal
 800      *                     00000b = 4:1:1 compression
 801      *                     00100b = 4:2:2 compression
 802      *                     XXXXXX = Reserved
 803      * Now, I've got two problems with these statements:
 804      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
 805      *      It seems that for PAL as defined in IEC 61834 we have to set
 806      *      APT to 000 and for SMPTE314M to 001.
 807      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
 808      *      compression scheme (if any).
 809      */
 810     int apt   = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
 811
 812     uint8_t aspect = 0;
 813     if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
 814         aspect = 0x02;
 815
 816     buf[0] = (uint8_t)pack_id;
 817     switch (pack_id) {
 818     case dv_header525: /* I can't imagine why these two weren't defined as real */
 819     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
 820           buf[1] = 0xf8 |        /* reserved -- always 1 */
 821                    (apt & 0x07); /* APT: Track application ID */
 822           buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
 823                    (0x0f << 3) | /* reserved -- always 1 */
 824                    (apt & 0x07); /* AP1: Audio application ID */
 825           buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
 826                    (0x0f << 3) | /* reserved -- always 1 */
 827                    (apt & 0x07); /* AP2: Video application ID */
 828           buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
 829                    (0x0f << 3) | /* reserved -- always 1 */
 830                    (apt & 0x07); /* AP3: Subcode application ID */
 831           break;
 832     case dv_video_source:
 833           buf[1] = 0xff;      /* reserved -- always 1 */
 834           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
 835                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
 836                    (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
 837                    0xf;       /* reserved -- always 1 */
 838           buf[3] = (3 << 6) | /* reserved -- always 1 */
 839                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
 840                    c->sys->video_stype; /* signal type video compression */
 841           buf[4] = 0xff;      /* VISC: 0xff -- no information */
 842           break;
 843     case dv_video_control:
 844           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
 845                    0x3f;      /* reserved -- always 1 */
 846           buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
 847                    aspect;
 848           buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
 849                    (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
 850                    (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
 851                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
 852                    0xc;       /* reserved -- always b1100 */
 853           buf[4] = 0xff;      /* reserved -- always 1 */
 854           break;
 855     default:
 856           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
 857     }
 858     return 5;
 859 }
 860
 861 #if CONFIG_DVVIDEO_ENCODER
 862 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
 863                                   uint8_t seq_num, uint8_t dif_num,
 864                                   uint8_t* buf)
 865 {
 866     buf[0] = (uint8_t)t;       /* Section type */
 867     buf[1] = (seq_num  << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
 868              (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
 869              7;                /* reserved -- always 1 */
 870     buf[2] = dif_num;          /* DIF block number Video: 0-134, Audio: 0-8 */
 871     return 3;
 872 }
 873
 874
 875 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
 876 {
 877     if (syb_num == 0 || syb_num == 6) {
 878         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
 879                  (0  << 4) | /* AP3 (Subcode application ID) */
 880                  0x0f;       /* reserved -- always 1 */
 881     }
 882     else if (syb_num == 11) {
 883         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
 884                  0x7f;       /* reserved -- always 1 */
 885     }
 886     else {
 887         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
 888                  (0  << 4) | /* APT (Track application ID) */
 889                  0x0f;       /* reserved -- always 1 */
 890     }
 891     buf[1] = 0xf0 |            /* reserved -- always 1 */
 892              (syb_num & 0x0f); /* SSYB number 0 - 11   */
 893     buf[2] = 0xff;             /* reserved -- always 1 */
 894     return 3;
 895 }
 896
 897 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
 898 {
 899     int chan, i, j, k;
 900
 901     for (chan = 0; chan < c->sys->n_difchan; chan++) {
 902         for (i = 0; i < c->sys->difseg_size; i++) {
 903             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
 904
 905             /* DV header: 1DIF */
 906             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
 907             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
 908             buf += 72; /* unused bytes */
 909
 910             /* DV subcode: 2DIFs */
 911             for (j = 0; j < 2; j++) {
 912                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
 913                 for (k = 0; k < 6; k++)
 914                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
 915                 buf += 29; /* unused bytes */
 916             }
 917
 918             /* DV VAUX: 3DIFS */
 919             for (j = 0; j < 3; j++) {
 920                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
 921                 buf += dv_write_pack(dv_video_source,  c, buf);
 922                 buf += dv_write_pack(dv_video_control, c, buf);
 923                 buf += 7*5;
 924                 buf += dv_write_pack(dv_video_source,  c, buf);
 925                 buf += dv_write_pack(dv_video_control, c, buf);
 926                 buf += 4*5 + 2; /* unused bytes */
 927             }
 928
 929             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
 930             for (j = 0; j < 135; j++) {
 931                 if (j%15 == 0) {
 932                     memset(buf, 0xff, 80);
 933                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
 934                     buf += 77; /* audio control & shuffled PCM audio */
 935                 }
 936                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
 937                 buf += 77; /* 1 video macroblock: 1 bytes control
 938                               4 * 14 bytes Y 8x8 data
 939                               10 bytes Cr 8x8 data
 940                               10 bytes Cb 8x8 data */
 941             }
 942         }
 943     }
 944 }
 945
 946
 947 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
 948                                 const AVFrame *frame, int *got_packet)
 949 {
 950     DVVideoContext *s = c->priv_data;
 951     int ret;
 952
 953     s->sys = avpriv_dv_codec_profile(c);
 954     if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
 955         return -1;
 956     if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
 957         av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
 958         return ret;
 959     }
 960
 961     c->pix_fmt           = s->sys->pix_fmt;
 962     s->picture           = *frame;
 963     s->picture.key_frame = 1;
 964     s->picture.pict_type = AV_PICTURE_TYPE_I;
 965
 966     s->buf = pkt->data;
 967     c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
 968                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
 969
 970     emms_c();
 971
 972     dv_format_frame(s, pkt->data);
 973
 974     pkt->flags |= AV_PKT_FLAG_KEY;
 975     *got_packet = 1;
 976
 977     return 0;
 978 }
 979
 980 AVCodec ff_dvvideo_encoder = {
 981     .name           = "dvvideo",
 982     .type           = AVMEDIA_TYPE_VIDEO,
 983     .id             = AV_CODEC_ID_DVVIDEO,
 984     .priv_data_size = sizeof(DVVideoContext),
 985     .init           = dvvideo_init_encoder,
 986     .encode2        = dvvideo_encode_frame,
 987     .capabilities   = CODEC_CAP_SLICE_THREADS,
 988     .pix_fmts       = (const enum AVPixelFormat[]) {
 989         AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
 990     },
 991     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
 992 };
 993 #endif // CONFIG_DVVIDEO_ENCODER