git.sesse.net Git - ffmpeg/blob - libavcodec/dv.c

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