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