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

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