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