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  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
  10  * of DV technical info.
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  25  */
  26
  27 /**
  28  * @file dv.c
  29  * DV codec.
  30  */
  31 #include "avcodec.h"
  32 #include "dsputil.h"
  33 #include "mpegvideo.h"
  34 #include "simple_idct.h"
  35 #include "dvdata.h"
  36
  37 //#undef NDEBUG
  38 //#include <assert.h>
  39
  40 typedef struct DVVideoContext {
  41     const DVprofile* sys;
  42     AVFrame picture;
  43     AVCodecContext *avctx;
  44     uint8_t *buf;
  45
  46     uint8_t dv_zigzag[2][64];
  47     uint8_t dv_idct_shift[2][2][22][64];
  48
  49     void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
  50     void (*fdct[2])(DCTELEM *block);
  51     void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
  52 } DVVideoContext;
  53
  54 /* MultiThreading - applies to entire DV codec, not just the avcontext */
  55 uint8_t** dv_anchor;
  56
  57 #define TEX_VLC_BITS 9
  58
  59 #ifdef DV_CODEC_TINY_TARGET
  60 #define DV_VLC_MAP_RUN_SIZE 15
  61 #define DV_VLC_MAP_LEV_SIZE 23
  62 #else
  63 #define DV_VLC_MAP_RUN_SIZE  64
  64 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
  65 #endif
  66
  67 /* XXX: also include quantization */
  68 static RL_VLC_ELEM *dv_rl_vlc;
  69 /* VLC encoding lookup table */
  70 static struct dv_vlc_pair {
  71    uint32_t vlc;
  72    uint8_t  size;
  73 } (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;
  74
  75 static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
  76 {
  77     int i, q, j;
  78
  79     /* NOTE: max left shift is 6 */
  80     for(q = 0; q < 22; q++) {
  81         /* 88DCT */
  82         for(i = 1; i < 64; i++) {
  83             /* 88 table */
  84             j = perm[i];
  85             s->dv_idct_shift[0][0][q][j] =
  86                 dv_quant_shifts[q][dv_88_areas[i]] + 1;
  87             s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;
  88         }
  89
  90         /* 248DCT */
  91         for(i = 1; i < 64; i++) {
  92             /* 248 table */
  93             s->dv_idct_shift[0][1][q][i] =
  94                 dv_quant_shifts[q][dv_248_areas[i]] + 1;
  95             s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;
  96         }
  97     }
  98 }
  99
 100 static int dvvideo_init(AVCodecContext *avctx)
 101 {
 102     DVVideoContext *s = avctx->priv_data;
 103     DSPContext dsp;
 104     static int done=0;
 105     int i, j;
 106
 107     if (!done) {
 108         VLC dv_vlc;
 109         uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
 110         uint8_t new_dv_vlc_len[NB_DV_VLC*2];
 111         uint8_t new_dv_vlc_run[NB_DV_VLC*2];
 112         int16_t new_dv_vlc_level[NB_DV_VLC*2];
 113
 114         done = 1;
 115
 116         dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
 117         if (!dv_vlc_map)
 118             return -ENOMEM;
 119
 120         /* dv_anchor lets each thread know its Id */
 121         dv_anchor = av_malloc(12*27*sizeof(void*));
 122         if (!dv_anchor) {
 123             return -ENOMEM;
 124         }
 125         for (i=0; i<12*27; i++)
 126             dv_anchor[i] = (void*)(size_t)i;
 127
 128         /* it's faster to include sign bit in a generic VLC parsing scheme */
 129         for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
 130             new_dv_vlc_bits[j] = dv_vlc_bits[i];
 131             new_dv_vlc_len[j] = dv_vlc_len[i];
 132             new_dv_vlc_run[j] = dv_vlc_run[i];
 133             new_dv_vlc_level[j] = dv_vlc_level[i];
 134
 135             if (dv_vlc_level[i]) {
 136                 new_dv_vlc_bits[j] <<= 1;
 137                 new_dv_vlc_len[j]++;
 138
 139                 j++;
 140                 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
 141                 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
 142                 new_dv_vlc_run[j] = dv_vlc_run[i];
 143                 new_dv_vlc_level[j] = -dv_vlc_level[i];
 144             }
 145         }
 146
 147         /* NOTE: as a trick, we use the fact the no codes are unused
 148            to accelerate the parsing of partial codes */
 149         init_vlc(&dv_vlc, TEX_VLC_BITS, j,
 150                  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
 151
 152         dv_rl_vlc = av_mallocz_static(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
 153         if (!dv_rl_vlc)
 154             return -ENOMEM;
 155
 156         for(i = 0; i < dv_vlc.table_size; i++){
 157             int code= dv_vlc.table[i][0];
 158             int len = dv_vlc.table[i][1];
 159             int level, run;
 160
 161             if(len<0){ //more bits needed
 162                 run= 0;
 163                 level= code;
 164             } else {
 165                 run=   new_dv_vlc_run[code] + 1;
 166                 level= new_dv_vlc_level[code];
 167             }
 168             dv_rl_vlc[i].len = len;
 169             dv_rl_vlc[i].level = level;
 170             dv_rl_vlc[i].run = run;
 171         }
 172         free_vlc(&dv_vlc);
 173
 174         for (i = 0; i < NB_DV_VLC - 1; i++) {
 175            if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
 176                continue;
 177 #ifdef DV_CODEC_TINY_TARGET
 178            if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
 179                continue;
 180 #endif
 181
 182            if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
 183                continue;
 184
 185            dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
 186                                                             (!!dv_vlc_level[i]);
 187            dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
 188                                                              (!!dv_vlc_level[i]);
 189         }
 190         for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
 191 #ifdef DV_CODEC_TINY_TARGET
 192            for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
 193               if (dv_vlc_map[i][j].size == 0) {
 194                   dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
 195                             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
 196                   dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
 197                                           dv_vlc_map[0][j].size;
 198               }
 199            }
 200 #else
 201            for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
 202               if (dv_vlc_map[i][j].size == 0) {
 203                   dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
 204                             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
 205                   dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
 206                                           dv_vlc_map[0][j].size;
 207               }
 208               dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
 209                                             dv_vlc_map[i][j].vlc | 1;
 210               dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
 211                                             dv_vlc_map[i][j].size;
 212            }
 213 #endif
 214         }
 215     }
 216
 217     /* Generic DSP setup */
 218     dsputil_init(&dsp, avctx);
 219     s->get_pixels = dsp.get_pixels;
 220
 221     /* 88DCT setup */
 222     s->fdct[0] = dsp.fdct;
 223     s->idct_put[0] = dsp.idct_put;
 224     for (i=0; i<64; i++)
 225        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
 226
 227     /* 248DCT setup */
 228     s->fdct[1] = dsp.fdct248;
 229     s->idct_put[1] = simple_idct248_put;  // FIXME: need to add it to DSP
 230     if(avctx->lowres){
 231         for (i=0; i<64; i++){
 232             int j= ff_zigzag248_direct[i];
 233             s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
 234         }
 235     }else
 236         memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
 237
 238     /* XXX: do it only for constant case */
 239     dv_build_unquantize_tables(s, dsp.idct_permutation);
 240
 241     /* FIXME: I really don't think this should be here */
 242     if (dv_codec_profile(avctx))
 243         avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt;
 244     avctx->coded_frame = &s->picture;
 245     s->avctx= avctx;
 246
 247     return 0;
 248 }
 249
 250 // #define VLC_DEBUG
 251 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
 252
 253 typedef struct BlockInfo {
 254     const uint8_t *shift_table;
 255     const uint8_t *scan_table;
 256     const int *iweight_table;
 257     uint8_t pos; /* position in block */
 258     uint8_t dct_mode;
 259     uint8_t partial_bit_count;
 260     uint16_t partial_bit_buffer;
 261     int shift_offset;
 262 } BlockInfo;
 263
 264 /* block size in bits */
 265 static const uint16_t block_sizes[6] = {
 266     112, 112, 112, 112, 80, 80
 267 };
 268 /* bit budget for AC only in 5 MBs */
 269 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
 270 /* see dv_88_areas and dv_248_areas for details */
 271 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
 272
 273 #ifndef ALT_BITSTREAM_READER
 274 #warning only works with ALT_BITSTREAM_READER
 275 static int re_index; //Hack to make it compile
 276 #endif
 277
 278 static inline int get_bits_left(GetBitContext *s)
 279 {
 280     return s->size_in_bits - get_bits_count(s);
 281 }
 282
 283 static inline int get_bits_size(GetBitContext *s)
 284 {
 285     return s->size_in_bits;
 286 }
 287
 288 static inline int put_bits_left(PutBitContext* s)
 289 {
 290     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
 291 }
 292
 293 /* decode ac coefs */
 294 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
 295 {
 296     int last_index = get_bits_size(gb);
 297     const uint8_t *scan_table = mb->scan_table;
 298     const uint8_t *shift_table = mb->shift_table;
 299     const int *iweight_table = mb->iweight_table;
 300     int pos = mb->pos;
 301     int partial_bit_count = mb->partial_bit_count;
 302     int level, pos1, run, vlc_len, index;
 303
 304     OPEN_READER(re, gb);
 305     UPDATE_CACHE(re, gb);
 306
 307     /* if we must parse a partial vlc, we do it here */
 308     if (partial_bit_count > 0) {
 309         re_cache = ((unsigned)re_cache >> partial_bit_count) |
 310                    (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
 311         re_index -= partial_bit_count;
 312         mb->partial_bit_count = 0;
 313     }
 314
 315     /* get the AC coefficients until last_index is reached */
 316     for(;;) {
 317 #ifdef VLC_DEBUG
 318         printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
 319 #endif
 320         /* our own optimized GET_RL_VLC */
 321         index = NEG_USR32(re_cache, TEX_VLC_BITS);
 322         vlc_len = dv_rl_vlc[index].len;
 323         if (vlc_len < 0) {
 324             index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
 325             vlc_len = TEX_VLC_BITS - vlc_len;
 326         }
 327         level = dv_rl_vlc[index].level;
 328         run = dv_rl_vlc[index].run;
 329
 330         /* gotta check if we're still within gb boundaries */
 331         if (re_index + vlc_len > last_index) {
 332             /* should be < 16 bits otherwise a codeword could have been parsed */
 333             mb->partial_bit_count = last_index - re_index;
 334             mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
 335             re_index = last_index;
 336             break;
 337         }
 338         re_index += vlc_len;
 339
 340 #ifdef VLC_DEBUG
 341         printf("run=%d level=%d\n", run, level);
 342 #endif
 343         pos += run;
 344         if (pos >= 64)
 345             break;
 346
 347         pos1 = scan_table[pos];
 348         level <<= shift_table[pos1];
 349
 350         /* unweigh, round, and shift down */
 351         level = (level*iweight_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits;
 352
 353         block[pos1] = level;
 354
 355         UPDATE_CACHE(re, gb);
 356     }
 357     CLOSE_READER(re, gb);
 358     mb->pos = pos;
 359 }
 360
 361 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
 362 {
 363     int bits_left = get_bits_left(gb);
 364     while (bits_left >= MIN_CACHE_BITS) {
 365         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
 366         bits_left -= MIN_CACHE_BITS;
 367     }
 368     if (bits_left > 0) {
 369         put_bits(pb, bits_left, get_bits(gb, bits_left));
 370     }
 371 }
 372
 373 /* mb_x and mb_y are in units of 8 pixels */
 374 static inline void dv_decode_video_segment(DVVideoContext *s,
 375                                            uint8_t *buf_ptr1,
 376                                            const uint16_t *mb_pos_ptr)
 377 {
 378     int quant, dc, dct_mode, class1, j;
 379     int mb_index, mb_x, mb_y, v, last_index;
 380     DCTELEM *block, *block1;
 381     int c_offset;
 382     uint8_t *y_ptr;
 383     void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
 384     uint8_t *buf_ptr;
 385     PutBitContext pb, vs_pb;
 386     GetBitContext gb;
 387     BlockInfo mb_data[5 * 6], *mb, *mb1;
 388     DECLARE_ALIGNED_8(DCTELEM, sblock[5*6][64]);
 389     DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
 390     DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
 391     const int log2_blocksize= 3-s->avctx->lowres;
 392
 393     assert((((int)mb_bit_buffer)&7)==0);
 394     assert((((int)vs_bit_buffer)&7)==0);
 395
 396     memset(sblock, 0, sizeof(sblock));
 397
 398     /* pass 1 : read DC and AC coefficients in blocks */
 399     buf_ptr = buf_ptr1;
 400     block1 = &sblock[0][0];
 401     mb1 = mb_data;
 402     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
 403     for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
 404         /* skip header */
 405         quant = buf_ptr[3] & 0x0f;
 406         buf_ptr += 4;
 407         init_put_bits(&pb, mb_bit_buffer, 80);
 408         mb = mb1;
 409         block = block1;
 410         for(j = 0;j < 6; j++) {
 411             last_index = block_sizes[j];
 412             init_get_bits(&gb, buf_ptr, last_index);
 413
 414             /* get the dc */
 415             dc = get_sbits(&gb, 9);
 416             dct_mode = get_bits1(&gb);
 417             mb->dct_mode = dct_mode;
 418             mb->scan_table = s->dv_zigzag[dct_mode];
 419             mb->iweight_table = dct_mode ? dv_iweight_248 : dv_iweight_88;
 420             class1 = get_bits(&gb, 2);
 421             mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
 422                 [quant + dv_quant_offset[class1]];
 423             dc = dc << 2;
 424             /* convert to unsigned because 128 is not added in the
 425                standard IDCT */
 426             dc += 1024;
 427             block[0] = dc;
 428             buf_ptr += last_index >> 3;
 429             mb->pos = 0;
 430             mb->partial_bit_count = 0;
 431
 432 #ifdef VLC_DEBUG
 433             printf("MB block: %d, %d ", mb_index, j);
 434 #endif
 435             dv_decode_ac(&gb, mb, block);
 436
 437             /* write the remaining bits  in a new buffer only if the
 438                block is finished */
 439             if (mb->pos >= 64)
 440                 bit_copy(&pb, &gb);
 441
 442             block += 64;
 443             mb++;
 444         }
 445
 446         /* pass 2 : we can do it just after */
 447 #ifdef VLC_DEBUG
 448         printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
 449 #endif
 450         block = block1;
 451         mb = mb1;
 452         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
 453         flush_put_bits(&pb);
 454         for(j = 0;j < 6; j++, block += 64, mb++) {
 455             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
 456                 dv_decode_ac(&gb, mb, block);
 457                 /* if still not finished, no need to parse other blocks */
 458                 if (mb->pos < 64)
 459                     break;
 460             }
 461         }
 462         /* all blocks are finished, so the extra bytes can be used at
 463            the video segment level */
 464         if (j >= 6)
 465             bit_copy(&vs_pb, &gb);
 466     }
 467
 468     /* we need a pass other the whole video segment */
 469 #ifdef VLC_DEBUG
 470     printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
 471 #endif
 472     block = &sblock[0][0];
 473     mb = mb_data;
 474     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
 475     flush_put_bits(&vs_pb);
 476     for(mb_index = 0; mb_index < 5; mb_index++) {
 477         for(j = 0;j < 6; j++) {
 478             if (mb->pos < 64) {
 479 #ifdef VLC_DEBUG
 480                 printf("start %d:%d\n", mb_index, j);
 481 #endif
 482                 dv_decode_ac(&gb, mb, block);
 483             }
 484             if (mb->pos >= 64 && mb->pos < 127)
 485                 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
 486             block += 64;
 487             mb++;
 488         }
 489     }
 490
 491     /* compute idct and place blocks */
 492     block = &sblock[0][0];
 493     mb = mb_data;
 494     for(mb_index = 0; mb_index < 5; mb_index++) {
 495         v = *mb_pos_ptr++;
 496         mb_x = v & 0xff;
 497         mb_y = v >> 8;
 498         y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
 499         if (s->sys->pix_fmt == PIX_FMT_YUV411P)
 500             c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
 501         else
 502             c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize);
 503         for(j = 0;j < 6; j++) {
 504             idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];
 505             if (j < 4) {
 506                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
 507                     /* NOTE: at end of line, the macroblock is handled as 420 */
 508                     idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);
 509                 } else {
 510                     idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),
 511                              s->picture.linesize[0], block);
 512                 }
 513             } else {
 514                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 515                     uint64_t aligned_pixels[64/8];
 516                     uint8_t *pixels= (uint8_t*)aligned_pixels;
 517                     uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
 518                     int x, y, linesize;
 519                     /* NOTE: at end of line, the macroblock is handled as 420 */
 520                     idct_put(pixels, 8, block);
 521                     linesize = s->picture.linesize[6 - j];
 522                     c_ptr = s->picture.data[6 - j] + c_offset;
 523                     ptr = pixels;
 524                     for(y = 0;y < (1<<log2_blocksize); y++) {
 525                         ptr1= ptr + (1<<(log2_blocksize-1));
 526                         c_ptr1 = c_ptr + (linesize<<log2_blocksize);
 527                         for(x=0; x < (1<<(log2_blocksize-1)); x++){
 528                             c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];
 529                         }
 530                         c_ptr += linesize;
 531                         ptr += 8;
 532                     }
 533                 } else {
 534                     /* don't ask me why they inverted Cb and Cr ! */
 535                     idct_put(s->picture.data[6 - j] + c_offset,
 536                              s->picture.linesize[6 - j], block);
 537                 }
 538             }
 539             block += 64;
 540             mb++;
 541         }
 542     }
 543 }
 544
 545 #ifdef DV_CODEC_TINY_TARGET
 546 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
 547 static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
 548 {
 549     int size;
 550     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 551         *vlc = dv_vlc_map[run][level].vlc | sign;
 552         size = dv_vlc_map[run][level].size;
 553     }
 554     else {
 555         if (level < DV_VLC_MAP_LEV_SIZE) {
 556             *vlc = dv_vlc_map[0][level].vlc | sign;
 557             size = dv_vlc_map[0][level].size;
 558         } else {
 559             *vlc = 0xfe00 | (level << 1) | sign;
 560             size = 16;
 561         }
 562         if (run) {
 563             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
 564                                   (0x1f80 | (run - 1))) << size;
 565             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 566         }
 567     }
 568
 569     return size;
 570 }
 571
 572 static always_inline int dv_rl2vlc_size(int run, int level)
 573 {
 574     int size;
 575
 576     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 577         size = dv_vlc_map[run][level].size;
 578     }
 579     else {
 580         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
 581         if (run) {
 582             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 583         }
 584     }
 585     return size;
 586 }
 587 #else
 588 static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
 589 {
 590     *vlc = dv_vlc_map[run][l].vlc | sign;
 591     return dv_vlc_map[run][l].size;
 592 }
 593
 594 static always_inline int dv_rl2vlc_size(int run, int l)
 595 {
 596     return dv_vlc_map[run][l].size;
 597 }
 598 #endif
 599
 600 typedef struct EncBlockInfo {
 601     int area_q[4];
 602     int bit_size[4];
 603     int prev[5];
 604     int cur_ac;
 605     int cno;
 606     int dct_mode;
 607     DCTELEM mb[64];
 608     uint8_t next[64];
 609     uint8_t sign[64];
 610     uint8_t partial_bit_count;
 611     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
 612 } EncBlockInfo;
 613
 614 static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
 615                                        PutBitContext* pb_end)
 616 {
 617     int prev;
 618     int bits_left;
 619     PutBitContext* pb = pb_pool;
 620     int size = bi->partial_bit_count;
 621     uint32_t vlc = bi->partial_bit_buffer;
 622
 623     bi->partial_bit_count = bi->partial_bit_buffer = 0;
 624     for(;;){
 625        /* Find suitable storage space */
 626        for (; size > (bits_left = put_bits_left(pb)); pb++) {
 627           if (bits_left) {
 628               size -= bits_left;
 629               put_bits(pb, bits_left, vlc >> size);
 630               vlc = vlc & ((1<<size)-1);
 631           }
 632           if (pb + 1 >= pb_end) {
 633               bi->partial_bit_count = size;
 634               bi->partial_bit_buffer = vlc;
 635               return pb;
 636           }
 637        }
 638
 639        /* Store VLC */
 640        put_bits(pb, size, vlc);
 641
 642        if(bi->cur_ac>=64)
 643            break;
 644
 645        /* Construct the next VLC */
 646        prev= bi->cur_ac;
 647        bi->cur_ac = bi->next[prev];
 648        if(bi->cur_ac < 64){
 649            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
 650        } else {
 651            size = 4; vlc = 6; /* End Of Block stamp */
 652        }
 653     }
 654     return pb;
 655 }
 656
 657 static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
 658                                               const uint8_t* zigzag_scan, const int *weight, int bias)
 659 {
 660     int i, area;
 661     /* We offer two different methods for class number assignment: the
 662        method suggested in SMPTE 314M Table 22, and an improved
 663        method. The SMPTE method is very conservative; it assigns class
 664        3 (i.e. severe quantization) to any block where the largest AC
 665        component is greater than 36. ffmpeg's DV encoder tracks AC bit
 666        consumption precisely, so there is no need to bias most blocks
 667        towards strongly lossy compression. Instead, we assign class 2
 668        to most blocks, and use class 3 only when strictly necessary
 669        (for blocks whose largest AC component exceeds 255). */
 670
 671 #if 0 /* SMPTE spec method */
 672     static const int classes[] = {12, 24, 36, 0xffff};
 673 #else /* improved ffmpeg method */
 674     static const int classes[] = {-1, -1, 255, 0xffff};
 675 #endif
 676     int max=classes[0];
 677     int prev=0;
 678
 679     bi->mb[0] = blk[0];
 680
 681     for (area = 0; area < 4; area++) {
 682        bi->prev[area] = prev;
 683        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 684        for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
 685           int level = blk[zigzag_scan[i]];
 686
 687           if (level+15 > 30U) {
 688               bi->sign[i] = (level>>31)&1;
 689               /* weigh it and and shift down into range, adding for rounding */
 690               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
 691                  AND the 2x doubling of the weights */
 692               level = (ABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);
 693               bi->mb[i] = level;
 694               if(level>max) max= level;
 695               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
 696               bi->next[prev]= i;
 697               prev= i;
 698           }
 699        }
 700     }
 701     bi->next[prev]= i;
 702     for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
 703
 704     bi->cno += bias;
 705
 706     if (bi->cno >= 3) {
 707         bi->cno = 3;
 708         prev=0;
 709         i= bi->next[prev];
 710         for (area = 0; area < 4; area++) {
 711             bi->prev[area] = prev;
 712             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 713             for (; i<mb_area_start[area+1]; i= bi->next[i]) {
 714                 bi->mb[i] >>=1;
 715
 716                 if (bi->mb[i]) {
 717                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
 718                     bi->next[prev]= i;
 719                     prev= i;
 720                 }
 721             }
 722         }
 723         bi->next[prev]= i;
 724     }
 725 }
 726
 727 //FIXME replace this by dsputil
 728 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
 729 static always_inline int dv_guess_dct_mode(DCTELEM *blk) {
 730     DCTELEM *s;
 731     int score88 = 0;
 732     int score248 = 0;
 733     int i;
 734
 735     /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
 736     s = blk;
 737     for(i=0; i<7; i++) {
 738         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
 739                    SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
 740         s += 8;
 741     }
 742     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
 743     s = blk;
 744     for(i=0; i<6; i++) {
 745         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
 746                     SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
 747         s += 8;
 748     }
 749
 750     return (score88 - score248 > -10);
 751 }
 752
 753 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
 754 {
 755     int size[5];
 756     int i, j, k, a, prev, a2;
 757     EncBlockInfo* b;
 758
 759     size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
 760     do {
 761        b = blks;
 762        for (i=0; i<5; i++) {
 763           if (!qnos[i])
 764               continue;
 765
 766           qnos[i]--;
 767           size[i] = 0;
 768           for (j=0; j<6; j++, b++) {
 769              for (a=0; a<4; a++) {
 770                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
 771                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
 772                     b->area_q[a]++;
 773                     prev= b->prev[a];
 774                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
 775                     for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
 776                        b->mb[k] >>= 1;
 777                        if (b->mb[k]) {
 778                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 779                            prev= k;
 780                        } else {
 781                            if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
 782                                 for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
 783                                     b->prev[a2] = prev;
 784                                 assert(a2<4);
 785                                 assert(b->mb[b->next[k]]);
 786                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
 787                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
 788                                 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
 789                                 b->prev[a2] = prev;
 790                            }
 791                            b->next[prev] = b->next[k];
 792                        }
 793                     }
 794                     b->prev[a+1]= prev;
 795                 }
 796                 size[i] += b->bit_size[a];
 797              }
 798           }
 799           if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
 800                 return;
 801        }
 802     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
 803
 804
 805     for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
 806         b = blks;
 807         size[0] = 5*6*4; //EOB
 808         for (j=0; j<6*5; j++, b++) {
 809             prev= b->prev[0];
 810             for (k= b->next[prev]; k<64; k= b->next[k]) {
 811                 if(b->mb[k] < a && b->mb[k] > -a){
 812                     b->next[prev] = b->next[k];
 813                 }else{
 814                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 815                     prev= k;
 816                 }
 817             }
 818         }
 819     }
 820 }
 821
 822 static inline void dv_encode_video_segment(DVVideoContext *s,
 823                                            uint8_t *dif,
 824                                            const uint16_t *mb_pos_ptr)
 825 {
 826     int mb_index, i, j, v;
 827     int mb_x, mb_y, c_offset, linesize;
 828     uint8_t*  y_ptr;
 829     uint8_t*  data;
 830     uint8_t*  ptr;
 831     int       do_edge_wrap;
 832     DECLARE_ALIGNED_8(DCTELEM, block[64]);
 833     EncBlockInfo  enc_blks[5*6];
 834     PutBitContext pbs[5*6];
 835     PutBitContext* pb;
 836     EncBlockInfo* enc_blk;
 837     int       vs_bit_size = 0;
 838     int       qnos[5];
 839
 840     assert((((int)block) & 7) == 0);
 841
 842     enc_blk = &enc_blks[0];
 843     pb = &pbs[0];
 844     for(mb_index = 0; mb_index < 5; mb_index++) {
 845         v = *mb_pos_ptr++;
 846         mb_x = v & 0xff;
 847         mb_y = v >> 8;
 848         y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
 849         c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ?
 850                    ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) :
 851                    (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
 852         do_edge_wrap = 0;
 853         qnos[mb_index] = 15; /* No quantization */
 854         ptr = dif + mb_index*80 + 4;
 855         for(j = 0;j < 6; j++) {
 856             if (j < 4) {  /* Four Y blocks */
 857                 /* NOTE: at end of line, the macroblock is handled as 420 */
 858                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
 859                     data = y_ptr + (j * 8);
 860                 } else {
 861                     data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
 862                 }
 863                 linesize = s->picture.linesize[0];
 864             } else {      /* Cr and Cb blocks */
 865                 /* don't ask Fabrice why they inverted Cb and Cr ! */
 866                 data = s->picture.data[6 - j] + c_offset;
 867                 linesize = s->picture.linesize[6 - j];
 868                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
 869                     do_edge_wrap = 1;
 870             }
 871
 872             /* Everything is set up -- now just copy data -> DCT block */
 873             if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
 874                 uint8_t* d;
 875                 DCTELEM *b = block;
 876                 for (i=0;i<8;i++) {
 877                    d = data + 8 * linesize;
 878                    b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
 879                    b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
 880                    data += linesize;
 881                    b += 8;
 882                 }
 883             } else {             /* Simple copy: 8x8 -> 8x8 */
 884                 s->get_pixels(block, data, linesize);
 885             }
 886
 887             if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
 888                 enc_blk->dct_mode = dv_guess_dct_mode(block);
 889             else
 890                 enc_blk->dct_mode = 0;
 891             enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
 892             enc_blk->partial_bit_count = 0;
 893             enc_blk->partial_bit_buffer = 0;
 894             enc_blk->cur_ac = 0;
 895
 896             s->fdct[enc_blk->dct_mode](block);
 897
 898             dv_set_class_number(block, enc_blk,
 899                                 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
 900                                 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
 901                                 j/4);
 902
 903             init_put_bits(pb, ptr, block_sizes[j]/8);
 904             put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
 905             put_bits(pb, 1, enc_blk->dct_mode);
 906             put_bits(pb, 2, enc_blk->cno);
 907
 908             vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
 909                            enc_blk->bit_size[2] + enc_blk->bit_size[3];
 910             ++enc_blk;
 911             ++pb;
 912             ptr += block_sizes[j]/8;
 913         }
 914     }
 915
 916     if (vs_total_ac_bits < vs_bit_size)
 917         dv_guess_qnos(&enc_blks[0], &qnos[0]);
 918
 919     for (i=0; i<5; i++) {
 920        dif[i*80 + 3] = qnos[i];
 921     }
 922
 923     /* First pass over individual cells only */
 924     for (j=0; j<5*6; j++)
 925        dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
 926
 927     /* Second pass over each MB space */
 928     for (j=0; j<5*6; j+=6) {
 929         pb= &pbs[j];
 930         for (i=0; i<6; i++) {
 931             if (enc_blks[i+j].partial_bit_count)
 932                 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
 933         }
 934     }
 935
 936     /* Third and final pass over the whole vides segment space */
 937     pb= &pbs[0];
 938     for (j=0; j<5*6; j++) {
 939        if (enc_blks[j].partial_bit_count)
 940            pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
 941        if (enc_blks[j].partial_bit_count)
 942             av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
 943     }
 944
 945     for (j=0; j<5*6; j++)
 946        flush_put_bits(&pbs[j]);
 947 }
 948
 949 static int dv_decode_mt(AVCodecContext *avctx, void* sl)
 950 {
 951     DVVideoContext *s = avctx->priv_data;
 952     int slice = (size_t)sl;
 953     dv_decode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
 954                             &s->sys->video_place[slice*5]);
 955     return 0;
 956 }
 957
 958 static int dv_encode_mt(AVCodecContext *avctx, void* sl)
 959 {
 960     DVVideoContext *s = avctx->priv_data;
 961     int slice = (size_t)sl;
 962     dv_encode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
 963                             &s->sys->video_place[slice*5]);
 964     return 0;
 965 }
 966
 967 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
 968    144000 bytes for PAL) */
 969 static int dvvideo_decode_frame(AVCodecContext *avctx,
 970                                  void *data, int *data_size,
 971                                  uint8_t *buf, int buf_size)
 972 {
 973     DVVideoContext *s = avctx->priv_data;
 974
 975     s->sys = dv_frame_profile(buf);
 976     if (!s->sys || buf_size < s->sys->frame_size)
 977         return -1; /* NOTE: we only accept several full frames */
 978
 979     if(s->picture.data[0])
 980         avctx->release_buffer(avctx, &s->picture);
 981
 982     s->picture.reference = 0;
 983     s->picture.key_frame = 1;
 984     s->picture.pict_type = FF_I_TYPE;
 985     avctx->pix_fmt = s->sys->pix_fmt;
 986     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
 987     if(avctx->get_buffer(avctx, &s->picture) < 0) {
 988         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 989         return -1;
 990     }
 991     s->picture.interlaced_frame = 1;
 992     s->picture.top_field_first = 0;
 993
 994     s->buf = buf;
 995     avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
 996                    s->sys->difseg_size * 27);
 997
 998     emms_c();
 999
1000     /* return image */
1001     *data_size = sizeof(AVFrame);
1002     *(AVFrame*)data= s->picture;
1003
1004     return s->sys->frame_size;
1005 }
1006
1007 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1008                                 void *data)
1009 {
1010     DVVideoContext *s = c->priv_data;
1011
1012     s->sys = dv_codec_profile(c);
1013     if (!s->sys)
1014         return -1;
1015     if(buf_size < s->sys->frame_size)
1016         return -1;
1017
1018     c->pix_fmt = s->sys->pix_fmt;
1019     s->picture = *((AVFrame *)data);
1020     s->picture.key_frame = 1;
1021     s->picture.pict_type = FF_I_TYPE;
1022
1023     s->buf = buf;
1024     c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1025                s->sys->difseg_size * 27);
1026
1027     emms_c();
1028     return s->sys->frame_size;
1029 }
1030
1031 static int dvvideo_close(AVCodecContext *c)
1032 {
1033
1034     return 0;
1035 }
1036
1037
1038 #ifdef CONFIG_DVVIDEO_ENCODER
1039 AVCodec dvvideo_encoder = {
1040     "dvvideo",
1041     CODEC_TYPE_VIDEO,
1042     CODEC_ID_DVVIDEO,
1043     sizeof(DVVideoContext),
1044     dvvideo_init,
1045     dvvideo_encode_frame,
1046     dvvideo_close,
1047     NULL,
1048     CODEC_CAP_DR1,
1049     NULL
1050 };
1051 #endif // CONFIG_DVVIDEO_ENCODER
1052
1053 AVCodec dvvideo_decoder = {
1054     "dvvideo",
1055     CODEC_TYPE_VIDEO,
1056     CODEC_ID_DVVIDEO,
1057     sizeof(DVVideoContext),
1058     dvvideo_init,
1059     NULL,
1060     dvvideo_close,
1061     dvvideo_decode_frame,
1062     CODEC_CAP_DR1,
1063     NULL
1064 };