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