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     static const int classes[] = {12, 24, 36, 0xffff};
 662     int max=12;
 663     int prev=0;
 664
 665     bi->mb[0] = blk[0];
 666
 667     for (area = 0; area < 4; area++) {
 668        bi->prev[area] = prev;
 669        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 670        for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
 671           int level = blk[zigzag_scan[i]];
 672
 673           if (level+15 > 30U) {
 674               bi->sign[i] = (level>>31)&1;
 675               /* weigh it and and shift down into range, adding for rounding */
 676               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
 677                  AND the 2x doubling of the weights */
 678               level = (ABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);
 679               bi->mb[i] = level;
 680               if(level>max) max= level;
 681               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
 682               bi->next[prev]= i;
 683               prev= i;
 684           }
 685        }
 686     }
 687     bi->next[prev]= i;
 688     for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
 689
 690     bi->cno += bias;
 691
 692     if (bi->cno >= 3) {
 693         bi->cno = 3;
 694         prev=0;
 695         i= bi->next[prev];
 696         for (area = 0; area < 4; area++) {
 697             bi->prev[area] = prev;
 698             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 699             for (; i<mb_area_start[area+1]; i= bi->next[i]) {
 700                 bi->mb[i] >>=1;
 701
 702                 if (bi->mb[i]) {
 703                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
 704                     bi->next[prev]= i;
 705                     prev= i;
 706                 }
 707             }
 708         }
 709         bi->next[prev]= i;
 710     }
 711 }
 712
 713 //FIXME replace this by dsputil
 714 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
 715 static always_inline int dv_guess_dct_mode(DCTELEM *blk) {
 716     DCTELEM *s;
 717     int score88 = 0;
 718     int score248 = 0;
 719     int i;
 720
 721     /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
 722     s = blk;
 723     for(i=0; i<7; i++) {
 724         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
 725                    SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
 726         s += 8;
 727     }
 728     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
 729     s = blk;
 730     for(i=0; i<6; i++) {
 731         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
 732                     SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
 733         s += 8;
 734     }
 735
 736     return (score88 - score248 > -10);
 737 }
 738
 739 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
 740 {
 741     int size[5];
 742     int i, j, k, a, prev, a2;
 743     EncBlockInfo* b;
 744
 745     size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
 746     do {
 747        b = blks;
 748        for (i=0; i<5; i++) {
 749           if (!qnos[i])
 750               continue;
 751
 752           qnos[i]--;
 753           size[i] = 0;
 754           for (j=0; j<6; j++, b++) {
 755              for (a=0; a<4; a++) {
 756                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
 757                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
 758                     b->area_q[a]++;
 759                     prev= b->prev[a];
 760                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
 761                     for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
 762                        b->mb[k] >>= 1;
 763                        if (b->mb[k]) {
 764                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 765                            prev= k;
 766                        } else {
 767                            if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
 768                                 for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
 769                                     b->prev[a2] = prev;
 770                                 assert(a2<4);
 771                                 assert(b->mb[b->next[k]]);
 772                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
 773                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
 774                                 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
 775                                 b->prev[a2] = prev;
 776                            }
 777                            b->next[prev] = b->next[k];
 778                        }
 779                     }
 780                     b->prev[a+1]= prev;
 781                 }
 782                 size[i] += b->bit_size[a];
 783              }
 784           }
 785           if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
 786                 return;
 787        }
 788     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
 789
 790
 791     for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
 792         b = blks;
 793         size[0] = 5*6*4; //EOB
 794         for (j=0; j<6*5; j++, b++) {
 795             prev= b->prev[0];
 796             for (k= b->next[prev]; k<64; k= b->next[k]) {
 797                 if(b->mb[k] < a && b->mb[k] > -a){
 798                     b->next[prev] = b->next[k];
 799                 }else{
 800                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 801                     prev= k;
 802                 }
 803             }
 804         }
 805     }
 806 }
 807
 808 static inline void dv_encode_video_segment(DVVideoContext *s,
 809                                            uint8_t *dif,
 810                                            const uint16_t *mb_pos_ptr)
 811 {
 812     int mb_index, i, j, v;
 813     int mb_x, mb_y, c_offset, linesize;
 814     uint8_t*  y_ptr;
 815     uint8_t*  data;
 816     uint8_t*  ptr;
 817     int       do_edge_wrap;
 818     DECLARE_ALIGNED_8(DCTELEM, block[64]);
 819     EncBlockInfo  enc_blks[5*6];
 820     PutBitContext pbs[5*6];
 821     PutBitContext* pb;
 822     EncBlockInfo* enc_blk;
 823     int       vs_bit_size = 0;
 824     int       qnos[5];
 825
 826     assert((((int)block) & 7) == 0);
 827
 828     enc_blk = &enc_blks[0];
 829     pb = &pbs[0];
 830     for(mb_index = 0; mb_index < 5; mb_index++) {
 831         v = *mb_pos_ptr++;
 832         mb_x = v & 0xff;
 833         mb_y = v >> 8;
 834         y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
 835         c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ?
 836                    ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) :
 837                    (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
 838         do_edge_wrap = 0;
 839         qnos[mb_index] = 15; /* No quantization */
 840         ptr = dif + mb_index*80 + 4;
 841         for(j = 0;j < 6; j++) {
 842             if (j < 4) {  /* Four Y blocks */
 843                 /* NOTE: at end of line, the macroblock is handled as 420 */
 844                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
 845                     data = y_ptr + (j * 8);
 846                 } else {
 847                     data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
 848                 }
 849                 linesize = s->picture.linesize[0];
 850             } else {      /* Cr and Cb blocks */
 851                 /* don't ask Fabrice why they inverted Cb and Cr ! */
 852                 data = s->picture.data[6 - j] + c_offset;
 853                 linesize = s->picture.linesize[6 - j];
 854                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
 855                     do_edge_wrap = 1;
 856             }
 857
 858             /* Everything is set up -- now just copy data -> DCT block */
 859             if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
 860                 uint8_t* d;
 861                 DCTELEM *b = block;
 862                 for (i=0;i<8;i++) {
 863                    d = data + 8 * linesize;
 864                    b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
 865                    b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
 866                    data += linesize;
 867                    b += 8;
 868                 }
 869             } else {             /* Simple copy: 8x8 -> 8x8 */
 870                 s->get_pixels(block, data, linesize);
 871             }
 872
 873             if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
 874                 enc_blk->dct_mode = dv_guess_dct_mode(block);
 875             else
 876                 enc_blk->dct_mode = 0;
 877             enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
 878             enc_blk->partial_bit_count = 0;
 879             enc_blk->partial_bit_buffer = 0;
 880             enc_blk->cur_ac = 0;
 881
 882             s->fdct[enc_blk->dct_mode](block);
 883
 884             dv_set_class_number(block, enc_blk,
 885                                 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
 886                                 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
 887                                 j/4);
 888
 889             init_put_bits(pb, ptr, block_sizes[j]/8);
 890             put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
 891             put_bits(pb, 1, enc_blk->dct_mode);
 892             put_bits(pb, 2, enc_blk->cno);
 893
 894             vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
 895                            enc_blk->bit_size[2] + enc_blk->bit_size[3];
 896             ++enc_blk;
 897             ++pb;
 898             ptr += block_sizes[j]/8;
 899         }
 900     }
 901
 902     if (vs_total_ac_bits < vs_bit_size)
 903         dv_guess_qnos(&enc_blks[0], &qnos[0]);
 904
 905     for (i=0; i<5; i++) {
 906        dif[i*80 + 3] = qnos[i];
 907     }
 908
 909     /* First pass over individual cells only */
 910     for (j=0; j<5*6; j++)
 911        dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
 912
 913     /* Second pass over each MB space */
 914     for (j=0; j<5*6; j+=6) {
 915         pb= &pbs[j];
 916         for (i=0; i<6; i++) {
 917             if (enc_blks[i+j].partial_bit_count)
 918                 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
 919         }
 920     }
 921
 922     /* Third and final pass over the whole vides segment space */
 923     pb= &pbs[0];
 924     for (j=0; j<5*6; j++) {
 925        if (enc_blks[j].partial_bit_count)
 926            pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
 927        if (enc_blks[j].partial_bit_count)
 928             av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
 929     }
 930
 931     for (j=0; j<5*6; j++)
 932        flush_put_bits(&pbs[j]);
 933 }
 934
 935 static int dv_decode_mt(AVCodecContext *avctx, void* sl)
 936 {
 937     DVVideoContext *s = avctx->priv_data;
 938     int slice = (size_t)sl;
 939     dv_decode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
 940                             &s->sys->video_place[slice*5]);
 941     return 0;
 942 }
 943
 944 static int dv_encode_mt(AVCodecContext *avctx, void* sl)
 945 {
 946     DVVideoContext *s = avctx->priv_data;
 947     int slice = (size_t)sl;
 948     dv_encode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
 949                             &s->sys->video_place[slice*5]);
 950     return 0;
 951 }
 952
 953 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
 954    144000 bytes for PAL) */
 955 static int dvvideo_decode_frame(AVCodecContext *avctx,
 956                                  void *data, int *data_size,
 957                                  uint8_t *buf, int buf_size)
 958 {
 959     DVVideoContext *s = avctx->priv_data;
 960
 961     s->sys = dv_frame_profile(buf);
 962     if (!s->sys || buf_size < s->sys->frame_size)
 963         return -1; /* NOTE: we only accept several full frames */
 964
 965     if(s->picture.data[0])
 966         avctx->release_buffer(avctx, &s->picture);
 967
 968     s->picture.reference = 0;
 969     s->picture.key_frame = 1;
 970     s->picture.pict_type = FF_I_TYPE;
 971     avctx->pix_fmt = s->sys->pix_fmt;
 972     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
 973     if(avctx->get_buffer(avctx, &s->picture) < 0) {
 974         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 975         return -1;
 976     }
 977     s->picture.interlaced_frame = 1;
 978     s->picture.top_field_first = 0;
 979
 980     s->buf = buf;
 981     avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
 982                    s->sys->difseg_size * 27);
 983
 984     emms_c();
 985
 986     /* return image */
 987     *data_size = sizeof(AVFrame);
 988     *(AVFrame*)data= s->picture;
 989
 990     return s->sys->frame_size;
 991 }
 992
 993 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
 994                                 void *data)
 995 {
 996     DVVideoContext *s = c->priv_data;
 997
 998     s->sys = dv_codec_profile(c);
 999     if (!s->sys)
1000         return -1;
1001     if(buf_size < s->sys->frame_size)
1002         return -1;
1003
1004     c->pix_fmt = s->sys->pix_fmt;
1005     s->picture = *((AVFrame *)data);
1006     s->picture.key_frame = 1;
1007     s->picture.pict_type = FF_I_TYPE;
1008
1009     s->buf = buf;
1010     c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1011                s->sys->difseg_size * 27);
1012
1013     emms_c();
1014     return s->sys->frame_size;
1015 }
1016
1017 static int dvvideo_close(AVCodecContext *c)
1018 {
1019
1020     return 0;
1021 }
1022
1023
1024 #ifdef CONFIG_DVVIDEO_ENCODER
1025 AVCodec dvvideo_encoder = {
1026     "dvvideo",
1027     CODEC_TYPE_VIDEO,
1028     CODEC_ID_DVVIDEO,
1029     sizeof(DVVideoContext),
1030     dvvideo_init,
1031     dvvideo_encode_frame,
1032     dvvideo_close,
1033     NULL,
1034     CODEC_CAP_DR1,
1035     NULL
1036 };
1037 #endif // CONFIG_DVVIDEO_ENCODER
1038
1039 AVCodec dvvideo_decoder = {
1040     "dvvideo",
1041     CODEC_TYPE_VIDEO,
1042     CODEC_ID_DVVIDEO,
1043     sizeof(DVVideoContext),
1044     dvvideo_init,
1045     NULL,
1046     dvvideo_close,
1047     dvvideo_decode_frame,
1048     CODEC_CAP_DR1,
1049     NULL
1050 };