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