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