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 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 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 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     ff_dsputil_init(&dsp, avctx);
 301     ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
 302     s->get_pixels = dsp.get_pixels;
 303     s->ildct_cmp = dsp.ildct_cmp[5];
 304
 305     /* 88DCT setup */
 306     s->fdct[0]     = dsp.fdct;
 307     s->idct_put[0] = dsp.idct_put;
 308     for (i = 0; i < 64; i++)
 309        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
 310
 311     /* 248DCT setup */
 312     s->fdct[1]     = dsp.fdct248;
 313     s->idct_put[1] = ff_simple_idct248_put;  // FIXME: need to add it to DSP
 314     if (avctx->lowres){
 315         for (i = 0; i < 64; i++){
 316             int j = ff_zigzag248_direct[i];
 317             s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
 318         }
 319     }else
 320         memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
 321
 322     avctx->coded_frame = &s->picture;
 323     s->avctx = avctx;
 324     avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
 325
 326     return 0;
 327 }
 328
 329 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
 330 {
 331     if (!avpriv_dv_codec_profile(avctx)) {
 332         av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
 333                "Valid DV profiles are:\n",
 334                avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
 335         ff_dv_print_profiles(avctx, AV_LOG_ERROR);
 336         return AVERROR(EINVAL);
 337     }
 338     if (avctx->height > 576) {
 339         av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
 340         return AVERROR_PATCHWELCOME;
 341     }
 342
 343     dv_vlc_map_tableinit();
 344
 345     return ff_dvvideo_init(avctx);
 346 }
 347
 348 /* bit budget for AC only in 5 MBs */
 349 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
 350 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
 351
 352 static inline int put_bits_left(PutBitContext* s)
 353 {
 354     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
 355 }
 356
 357 #if CONFIG_SMALL
 358 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
 359 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
 360 {
 361     int size;
 362     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 363         *vlc = dv_vlc_map[run][level].vlc | sign;
 364         size = dv_vlc_map[run][level].size;
 365     }
 366     else {
 367         if (level < DV_VLC_MAP_LEV_SIZE) {
 368             *vlc = dv_vlc_map[0][level].vlc | sign;
 369             size = dv_vlc_map[0][level].size;
 370         } else {
 371             *vlc = 0xfe00 | (level << 1) | sign;
 372             size = 16;
 373         }
 374         if (run) {
 375             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
 376                                   (0x1f80 | (run - 1))) << size;
 377             size +=  (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 378         }
 379     }
 380
 381     return size;
 382 }
 383
 384 static av_always_inline int dv_rl2vlc_size(int run, int level)
 385 {
 386     int size;
 387
 388     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 389         size = dv_vlc_map[run][level].size;
 390     }
 391     else {
 392         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
 393         if (run) {
 394             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 395         }
 396     }
 397     return size;
 398 }
 399 #else
 400 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
 401 {
 402     *vlc = dv_vlc_map[run][l].vlc | sign;
 403     return dv_vlc_map[run][l].size;
 404 }
 405
 406 static av_always_inline int dv_rl2vlc_size(int run, int l)
 407 {
 408     return dv_vlc_map[run][l].size;
 409 }
 410 #endif
 411
 412 typedef struct EncBlockInfo {
 413     int      area_q[4];
 414     int      bit_size[4];
 415     int      prev[5];
 416     int      cur_ac;
 417     int      cno;
 418     int      dct_mode;
 419     DCTELEM  mb[64];
 420     uint8_t  next[64];
 421     uint8_t  sign[64];
 422     uint8_t  partial_bit_count;
 423     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
 424 } EncBlockInfo;
 425
 426 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
 427                                                     PutBitContext* pb_pool,
 428                                                     PutBitContext* pb_end)
 429 {
 430     int prev, bits_left;
 431     PutBitContext* pb = pb_pool;
 432     int size = bi->partial_bit_count;
 433     uint32_t vlc = bi->partial_bit_buffer;
 434
 435     bi->partial_bit_count = bi->partial_bit_buffer = 0;
 436     for (;;){
 437        /* Find suitable storage space */
 438        for (; size > (bits_left = put_bits_left(pb)); pb++) {
 439           if (bits_left) {
 440               size -= bits_left;
 441               put_bits(pb, bits_left, vlc >> size);
 442               vlc = vlc & ((1 << size) - 1);
 443           }
 444           if (pb + 1 >= pb_end) {
 445               bi->partial_bit_count  = size;
 446               bi->partial_bit_buffer = vlc;
 447               return pb;
 448           }
 449        }
 450
 451        /* Store VLC */
 452        put_bits(pb, size, vlc);
 453
 454        if (bi->cur_ac >= 64)
 455            break;
 456
 457        /* Construct the next VLC */
 458        prev       = bi->cur_ac;
 459        bi->cur_ac = bi->next[prev];
 460        if (bi->cur_ac < 64){
 461            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
 462        } else {
 463            size = 4; vlc = 6; /* End Of Block stamp */
 464        }
 465     }
 466     return pb;
 467 }
 468
 469 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
 470     if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
 471         int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
 472         if (ps > 0) {
 473             int is = s->ildct_cmp(NULL, data           , NULL, linesize<<1, 4) +
 474                      s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
 475             return ps > is;
 476         }
 477     }
 478
 479     return 0;
 480 }
 481
 482 static const int dv_weight_bits = 18;
 483 static const int dv_weight_88[64] = {
 484  131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
 485  237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
 486  224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
 487  212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
 488  206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
 489  200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
 490  174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
 491  170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
 492 };
 493 static const int dv_weight_248[64] = {
 494  131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
 495  224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
 496  211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
 497  242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
 498  200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
 499  229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
 500  175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
 501  195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
 502 };
 503
 504 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
 505 {
 506     const int *weight;
 507     const uint8_t* zigzag_scan;
 508     LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
 509     int i, area;
 510     /* We offer two different methods for class number assignment: the
 511        method suggested in SMPTE 314M Table 22, and an improved
 512        method. The SMPTE method is very conservative; it assigns class
 513        3 (i.e. severe quantization) to any block where the largest AC
 514        component is greater than 36. FFmpeg's DV encoder tracks AC bit
 515        consumption precisely, so there is no need to bias most blocks
 516        towards strongly lossy compression. Instead, we assign class 2
 517        to most blocks, and use class 3 only when strictly necessary
 518        (for blocks whose largest AC component exceeds 255). */
 519
 520 #if 0 /* SMPTE spec method */
 521     static const int classes[] = {12, 24, 36, 0xffff};
 522 #else /* improved FFmpeg method */
 523     static const int classes[] = {-1, -1, 255, 0xffff};
 524 #endif
 525     int max  = classes[0];
 526     int prev = 0;
 527
 528     assert((((int)blk) & 15) == 0);
 529
 530     bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
 531     bi->partial_bit_count = 0;
 532     bi->partial_bit_buffer = 0;
 533     bi->cur_ac = 0;
 534     if (data) {
 535         bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
 536         s->get_pixels(blk, data, linesize);
 537         s->fdct[bi->dct_mode](blk);
 538     } else {
 539         /* We rely on the fact that encoding all zeros leads to an immediate EOB,
 540            which is precisely what the spec calls for in the "dummy" blocks. */
 541         memset(blk, 0, 64*sizeof(*blk));
 542         bi->dct_mode = 0;
 543     }
 544     bi->mb[0] = blk[0];
 545
 546     zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
 547     weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
 548
 549     for (area = 0; area < 4; area++) {
 550        bi->prev[area]     = prev;
 551        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 552        for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
 553           int level = blk[zigzag_scan[i]];
 554
 555           if (level + 15 > 30U) {
 556               bi->sign[i] = (level >> 31) & 1;
 557               /* weight it and and shift down into range, adding for rounding */
 558               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
 559                  AND the 2x doubling of the weights */
 560               level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
 561               bi->mb[i] = level;
 562               if (level > max)
 563                   max = level;
 564               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
 565               bi->next[prev]= i;
 566               prev = i;
 567           }
 568        }
 569     }
 570     bi->next[prev]= i;
 571     for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
 572
 573     bi->cno += bias;
 574
 575     if (bi->cno >= 3) {
 576         bi->cno = 3;
 577         prev    = 0;
 578         i       = bi->next[prev];
 579         for (area = 0; area < 4; area++) {
 580             bi->prev[area]     = prev;
 581             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 582             for (; i < mb_area_start[area+1]; i = bi->next[i]) {
 583                 bi->mb[i] >>= 1;
 584
 585                 if (bi->mb[i]) {
 586                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
 587                     bi->next[prev]= i;
 588                     prev = i;
 589                 }
 590             }
 591         }
 592         bi->next[prev]= i;
 593     }
 594
 595     return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
 596 }
 597
 598 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
 599 {
 600     int size[5];
 601     int i, j, k, a, prev, a2;
 602     EncBlockInfo* b;
 603
 604     size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
 605     do {
 606        b = blks;
 607        for (i = 0; i < 5; i++) {
 608           if (!qnos[i])
 609               continue;
 610
 611           qnos[i]--;
 612           size[i] = 0;
 613           for (j = 0; j < 6; j++, b++) {
 614              for (a = 0; a < 4; a++) {
 615                 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
 616                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
 617                     b->area_q[a]++;
 618                     prev = b->prev[a];
 619                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
 620                     for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
 621                        b->mb[k] >>= 1;
 622                        if (b->mb[k]) {
 623                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 624                            prev = k;
 625                        } else {
 626                            if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
 627                                 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
 628                                     b->prev[a2] = prev;
 629                                 assert(a2 < 4);
 630                                 assert(b->mb[b->next[k]]);
 631                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
 632                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
 633                                 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
 634                                 b->prev[a2] = prev;
 635                            }
 636                            b->next[prev] = b->next[k];
 637                        }
 638                     }
 639                     b->prev[a+1]= prev;
 640                 }
 641                 size[i] += b->bit_size[a];
 642              }
 643           }
 644           if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
 645                 return;
 646        }
 647     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
 648
 649
 650     for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
 651         b = blks;
 652         size[0] = 5 * 6 * 4; //EOB
 653         for (j = 0; j < 6 *5; j++, b++) {
 654             prev = b->prev[0];
 655             for (k = b->next[prev]; k < 64; k = b->next[k]) {
 656                 if (b->mb[k] < a && b->mb[k] > -a){
 657                     b->next[prev] = b->next[k];
 658                 }else{
 659                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 660                     prev = k;
 661                 }
 662             }
 663         }
 664     }
 665 }
 666
 667 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
 668 {
 669     DVVideoContext *s = avctx->priv_data;
 670     DVwork_chunk *work_chunk = arg;
 671     int mb_index, i, j;
 672     int mb_x, mb_y, c_offset, linesize, y_stride;
 673     uint8_t*  y_ptr;
 674     uint8_t*  dif;
 675     LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
 676     EncBlockInfo  enc_blks[5*DV_MAX_BPM];
 677     PutBitContext pbs[5*DV_MAX_BPM];
 678     PutBitContext* pb;
 679     EncBlockInfo* enc_blk;
 680     int       vs_bit_size = 0;
 681     int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
 682     int*      qnosp = &qnos[0];
 683
 684     dif = &s->buf[work_chunk->buf_offset*80];
 685     enc_blk = &enc_blks[0];
 686     for (mb_index = 0; mb_index < 5; mb_index++) {
 687         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
 688
 689         /* initializing luminance blocks */
 690         if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
 691             (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
 692             (s->sys->height >= 720 && mb_y != 134)) {
 693             y_stride = s->picture.linesize[0] << 3;
 694         } else {
 695             y_stride = 16;
 696         }
 697         y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
 698         linesize = s->picture.linesize[0];
 699
 700         if (s->sys->video_stype == 4) { /* SD 422 */
 701             vs_bit_size +=
 702             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
 703             dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
 704             dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
 705             dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
 706         } else {
 707             vs_bit_size +=
 708             dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
 709             dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
 710             dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
 711             dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
 712         }
 713         enc_blk += 4;
 714
 715         /* initializing chrominance blocks */
 716         c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
 717                      (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
 718         for (j = 2; j; j--) {
 719             uint8_t *c_ptr = s->picture.data[j] + c_offset;
 720             linesize = s->picture.linesize[j];
 721             y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
 722             if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 723                 uint8_t* d;
 724                 uint8_t* b = scratch;
 725                 for (i = 0; i < 8; i++) {
 726                     d = c_ptr + (linesize << 3);
 727                     b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
 728                     b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
 729                     c_ptr += linesize;
 730                     b += 16;
 731                 }
 732                 c_ptr = scratch;
 733                 linesize = 16;
 734             }
 735
 736             vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
 737             if (s->sys->bpm == 8) {
 738                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
 739             }
 740         }
 741     }
 742
 743     if (vs_total_ac_bits < vs_bit_size)
 744         dv_guess_qnos(&enc_blks[0], qnosp);
 745
 746     /* DIF encoding process */
 747     for (j=0; j<5*s->sys->bpm;) {
 748         int start_mb = j;
 749
 750         dif[3] = *qnosp++;
 751         dif += 4;
 752
 753         /* First pass over individual cells only */
 754         for (i=0; i<s->sys->bpm; i++, j++) {
 755             int sz = s->sys->block_sizes[i]>>3;
 756
 757             init_put_bits(&pbs[j], dif, sz);
 758             put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
 759             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
 760             put_bits(&pbs[j], 2, enc_blks[j].cno);
 761
 762             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
 763             dif += sz;
 764         }
 765
 766         /* Second pass over each MB space */
 767         pb = &pbs[start_mb];
 768         for (i=0; i<s->sys->bpm; i++) {
 769             if (enc_blks[start_mb+i].partial_bit_count)
 770                 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
 771         }
 772     }
 773
 774     /* Third and final pass over the whole video segment space */
 775     pb = &pbs[0];
 776     for (j=0; j<5*s->sys->bpm; j++) {
 777        if (enc_blks[j].partial_bit_count)
 778            pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
 779        if (enc_blks[j].partial_bit_count)
 780             av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
 781     }
 782
 783     for (j=0; j<5*s->sys->bpm; j++) {
 784        int pos;
 785        int size = pbs[j].size_in_bits >> 3;
 786        flush_put_bits(&pbs[j]);
 787        pos = put_bits_count(&pbs[j]) >> 3;
 788        if (pos > size) {
 789            av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
 790            return -1;
 791        }
 792        memset(pbs[j].buf + pos, 0xff, size - pos);
 793     }
 794
 795     return 0;
 796 }
 797
 798 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
 799                                 uint8_t* buf)
 800 {
 801     /*
 802      * Here's what SMPTE314M says about these two:
 803      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
 804      *             as track application IDs (APTn = 001, AP1n =
 805      *             001, AP2n = 001, AP3n = 001), if the source signal
 806      *             comes from a digital VCR. If the signal source is
 807      *             unknown, all bits for these data shall be set to 1.
 808      *    (page 12) STYPE: STYPE defines a signal type of video signal
 809      *                     00000b = 4:1:1 compression
 810      *                     00100b = 4:2:2 compression
 811      *                     XXXXXX = Reserved
 812      * Now, I've got two problems with these statements:
 813      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
 814      *      It seems that for PAL as defined in IEC 61834 we have to set
 815      *      APT to 000 and for SMPTE314M to 001.
 816      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
 817      *      compression scheme (if any).
 818      */
 819     int apt   = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
 820
 821     uint8_t aspect = 0;
 822     if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
 823         aspect = 0x02;
 824
 825     buf[0] = (uint8_t)pack_id;
 826     switch (pack_id) {
 827     case dv_header525: /* I can't imagine why these two weren't defined as real */
 828     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
 829           buf[1] = 0xf8 |        /* reserved -- always 1 */
 830                    (apt & 0x07); /* APT: Track application ID */
 831           buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
 832                    (0x0f << 3) | /* reserved -- always 1 */
 833                    (apt & 0x07); /* AP1: Audio application ID */
 834           buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
 835                    (0x0f << 3) | /* reserved -- always 1 */
 836                    (apt & 0x07); /* AP2: Video application ID */
 837           buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
 838                    (0x0f << 3) | /* reserved -- always 1 */
 839                    (apt & 0x07); /* AP3: Subcode application ID */
 840           break;
 841     case dv_video_source:
 842           buf[1] = 0xff;      /* reserved -- always 1 */
 843           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
 844                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
 845                    (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
 846                    0xf;       /* reserved -- always 1 */
 847           buf[3] = (3 << 6) | /* reserved -- always 1 */
 848                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
 849                    c->sys->video_stype; /* signal type video compression */
 850           buf[4] = 0xff;      /* VISC: 0xff -- no information */
 851           break;
 852     case dv_video_control:
 853           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
 854                    0x3f;      /* reserved -- always 1 */
 855           buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
 856                    aspect;
 857           buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
 858                    (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
 859                    (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
 860                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
 861                    0xc;       /* reserved -- always b1100 */
 862           buf[4] = 0xff;      /* reserved -- always 1 */
 863           break;
 864     default:
 865           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
 866     }
 867     return 5;
 868 }
 869
 870 #if CONFIG_DVVIDEO_ENCODER
 871 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
 872                                   uint8_t seq_num, uint8_t dif_num,
 873                                   uint8_t* buf)
 874 {
 875     buf[0] = (uint8_t)t;       /* Section type */
 876     buf[1] = (seq_num  << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
 877              (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
 878              7;                /* reserved -- always 1 */
 879     buf[2] = dif_num;          /* DIF block number Video: 0-134, Audio: 0-8 */
 880     return 3;
 881 }
 882
 883
 884 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
 885 {
 886     if (syb_num == 0 || syb_num == 6) {
 887         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
 888                  (0  << 4) | /* AP3 (Subcode application ID) */
 889                  0x0f;       /* reserved -- always 1 */
 890     }
 891     else if (syb_num == 11) {
 892         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
 893                  0x7f;       /* reserved -- always 1 */
 894     }
 895     else {
 896         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
 897                  (0  << 4) | /* APT (Track application ID) */
 898                  0x0f;       /* reserved -- always 1 */
 899     }
 900     buf[1] = 0xf0 |            /* reserved -- always 1 */
 901              (syb_num & 0x0f); /* SSYB number 0 - 11   */
 902     buf[2] = 0xff;             /* reserved -- always 1 */
 903     return 3;
 904 }
 905
 906 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
 907 {
 908     int chan, i, j, k;
 909
 910     for (chan = 0; chan < c->sys->n_difchan; chan++) {
 911         for (i = 0; i < c->sys->difseg_size; i++) {
 912             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
 913
 914             /* DV header: 1DIF */
 915             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
 916             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
 917             buf += 72; /* unused bytes */
 918
 919             /* DV subcode: 2DIFs */
 920             for (j = 0; j < 2; j++) {
 921                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
 922                 for (k = 0; k < 6; k++)
 923                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
 924                 buf += 29; /* unused bytes */
 925             }
 926
 927             /* DV VAUX: 3DIFS */
 928             for (j = 0; j < 3; j++) {
 929                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
 930                 buf += dv_write_pack(dv_video_source,  c, buf);
 931                 buf += dv_write_pack(dv_video_control, c, buf);
 932                 buf += 7*5;
 933                 buf += dv_write_pack(dv_video_source,  c, buf);
 934                 buf += dv_write_pack(dv_video_control, c, buf);
 935                 buf += 4*5 + 2; /* unused bytes */
 936             }
 937
 938             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
 939             for (j = 0; j < 135; j++) {
 940                 if (j%15 == 0) {
 941                     memset(buf, 0xff, 80);
 942                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
 943                     buf += 77; /* audio control & shuffled PCM audio */
 944                 }
 945                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
 946                 buf += 77; /* 1 video macroblock: 1 bytes control
 947                               4 * 14 bytes Y 8x8 data
 948                               10 bytes Cr 8x8 data
 949                               10 bytes Cb 8x8 data */
 950             }
 951         }
 952     }
 953 }
 954
 955
 956 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
 957                                 const AVFrame *frame, int *got_packet)
 958 {
 959     DVVideoContext *s = c->priv_data;
 960     int ret;
 961
 962     s->sys = avpriv_dv_codec_profile(c);
 963     if (!s->sys || ff_dv_init_dynamic_tables(s->sys))
 964         return -1;
 965     if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
 966         return ret;
 967
 968     c->pix_fmt           = s->sys->pix_fmt;
 969     s->picture           = *frame;
 970     s->picture.key_frame = 1;
 971     s->picture.pict_type = AV_PICTURE_TYPE_I;
 972
 973     s->buf = pkt->data;
 974     c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
 975                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
 976
 977     emms_c();
 978
 979     dv_format_frame(s, pkt->data);
 980
 981     pkt->flags |= AV_PKT_FLAG_KEY;
 982     *got_packet = 1;
 983
 984     return 0;
 985 }
 986
 987 AVCodec ff_dvvideo_encoder = {
 988     .name           = "dvvideo",
 989     .type           = AVMEDIA_TYPE_VIDEO,
 990     .id             = CODEC_ID_DVVIDEO,
 991     .priv_data_size = sizeof(DVVideoContext),
 992     .init           = dvvideo_init_encoder,
 993     .encode2        = dvvideo_encode_frame,
 994     .capabilities   = CODEC_CAP_SLICE_THREADS,
 995     .pix_fmts       = (const enum PixelFormat[]) {
 996         PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE
 997     },
 998     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
 999 };
1000 #endif // CONFIG_DVVIDEO_ENCODER