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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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     uint8_t pos; /* position in block */
 257     uint8_t dct_mode;
 258     uint8_t partial_bit_count;
 259     uint16_t partial_bit_buffer;
 260     int shift_offset;
 261 } BlockInfo;
 262
 263 /* block size in bits */
 264 static const uint16_t block_sizes[6] = {
 265     112, 112, 112, 112, 80, 80
 266 };
 267 /* bit budget for AC only in 5 MBs */
 268 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
 269 /* see dv_88_areas and dv_248_areas for details */
 270 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
 271
 272 #ifndef ALT_BITSTREAM_READER
 273 #warning only works with ALT_BITSTREAM_READER
 274 static int re_index; //Hack to make it compile
 275 #endif
 276
 277 static inline int get_bits_left(GetBitContext *s)
 278 {
 279     return s->size_in_bits - get_bits_count(s);
 280 }
 281
 282 static inline int get_bits_size(GetBitContext *s)
 283 {
 284     return s->size_in_bits;
 285 }
 286
 287 static inline int put_bits_left(PutBitContext* s)
 288 {
 289     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
 290 }
 291
 292 /* decode ac coefs */
 293 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
 294 {
 295     int last_index = get_bits_size(gb);
 296     const uint8_t *scan_table = mb->scan_table;
 297     const uint8_t *shift_table = mb->shift_table;
 298     int pos = mb->pos;
 299     int partial_bit_count = mb->partial_bit_count;
 300     int level, pos1, run, vlc_len, index;
 301
 302     OPEN_READER(re, gb);
 303     UPDATE_CACHE(re, gb);
 304
 305     /* if we must parse a partial vlc, we do it here */
 306     if (partial_bit_count > 0) {
 307         re_cache = ((unsigned)re_cache >> partial_bit_count) |
 308                    (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
 309         re_index -= partial_bit_count;
 310         mb->partial_bit_count = 0;
 311     }
 312
 313     /* get the AC coefficients until last_index is reached */
 314     for(;;) {
 315 #ifdef VLC_DEBUG
 316         printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
 317 #endif
 318         /* our own optimized GET_RL_VLC */
 319         index = NEG_USR32(re_cache, TEX_VLC_BITS);
 320         vlc_len = dv_rl_vlc[index].len;
 321         if (vlc_len < 0) {
 322             index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
 323             vlc_len = TEX_VLC_BITS - vlc_len;
 324         }
 325         level = dv_rl_vlc[index].level;
 326         run = dv_rl_vlc[index].run;
 327
 328         /* gotta check if we're still within gb boundaries */
 329         if (re_index + vlc_len > last_index) {
 330             /* should be < 16 bits otherwise a codeword could have been parsed */
 331             mb->partial_bit_count = last_index - re_index;
 332             mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
 333             re_index = last_index;
 334             break;
 335         }
 336         re_index += vlc_len;
 337
 338 #ifdef VLC_DEBUG
 339         printf("run=%d level=%d\n", run, level);
 340 #endif
 341         pos += run;
 342         if (pos >= 64)
 343             break;
 344
 345         assert(level);
 346         pos1 = scan_table[pos];
 347         block[pos1] = level << shift_table[pos1];
 348
 349         UPDATE_CACHE(re, gb);
 350     }
 351     CLOSE_READER(re, gb);
 352     mb->pos = pos;
 353 }
 354
 355 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
 356 {
 357     int bits_left = get_bits_left(gb);
 358     while (bits_left >= MIN_CACHE_BITS) {
 359         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
 360         bits_left -= MIN_CACHE_BITS;
 361     }
 362     if (bits_left > 0) {
 363         put_bits(pb, bits_left, get_bits(gb, bits_left));
 364     }
 365 }
 366
 367 /* mb_x and mb_y are in units of 8 pixels */
 368 static inline void dv_decode_video_segment(DVVideoContext *s,
 369                                            uint8_t *buf_ptr1,
 370                                            const uint16_t *mb_pos_ptr)
 371 {
 372     int quant, dc, dct_mode, class1, j;
 373     int mb_index, mb_x, mb_y, v, last_index;
 374     DCTELEM *block, *block1;
 375     int c_offset;
 376     uint8_t *y_ptr;
 377     void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
 378     uint8_t *buf_ptr;
 379     PutBitContext pb, vs_pb;
 380     GetBitContext gb;
 381     BlockInfo mb_data[5 * 6], *mb, *mb1;
 382     DCTELEM sblock[5*6][64] __align8;
 383     uint8_t mb_bit_buffer[80 + 4] __align8; /* allow some slack */
 384     uint8_t vs_bit_buffer[5 * 80 + 4] __align8; /* allow some slack */
 385     const int log2_blocksize= 3-s->avctx->lowres;
 386
 387     assert((((int)mb_bit_buffer)&7)==0);
 388     assert((((int)vs_bit_buffer)&7)==0);
 389
 390     memset(sblock, 0, sizeof(sblock));
 391
 392     /* pass 1 : read DC and AC coefficients in blocks */
 393     buf_ptr = buf_ptr1;
 394     block1 = &sblock[0][0];
 395     mb1 = mb_data;
 396     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
 397     for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
 398         /* skip header */
 399         quant = buf_ptr[3] & 0x0f;
 400         buf_ptr += 4;
 401         init_put_bits(&pb, mb_bit_buffer, 80);
 402         mb = mb1;
 403         block = block1;
 404         for(j = 0;j < 6; j++) {
 405             last_index = block_sizes[j];
 406             init_get_bits(&gb, buf_ptr, last_index);
 407
 408             /* get the dc */
 409             dc = get_sbits(&gb, 9);
 410             dct_mode = get_bits1(&gb);
 411             mb->dct_mode = dct_mode;
 412             mb->scan_table = s->dv_zigzag[dct_mode];
 413             class1 = get_bits(&gb, 2);
 414             mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
 415                 [quant + dv_quant_offset[class1]];
 416             dc = dc << 2;
 417             /* convert to unsigned because 128 is not added in the
 418                standard IDCT */
 419             dc += 1024;
 420             block[0] = dc;
 421             buf_ptr += last_index >> 3;
 422             mb->pos = 0;
 423             mb->partial_bit_count = 0;
 424
 425 #ifdef VLC_DEBUG
 426             printf("MB block: %d, %d ", mb_index, j);
 427 #endif
 428             dv_decode_ac(&gb, mb, block);
 429
 430             /* write the remaining bits  in a new buffer only if the
 431                block is finished */
 432             if (mb->pos >= 64)
 433                 bit_copy(&pb, &gb);
 434
 435             block += 64;
 436             mb++;
 437         }
 438
 439         /* pass 2 : we can do it just after */
 440 #ifdef VLC_DEBUG
 441         printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
 442 #endif
 443         block = block1;
 444         mb = mb1;
 445         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
 446         flush_put_bits(&pb);
 447         for(j = 0;j < 6; j++, block += 64, mb++) {
 448             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
 449                 dv_decode_ac(&gb, mb, block);
 450                 /* if still not finished, no need to parse other blocks */
 451                 if (mb->pos < 64)
 452                     break;
 453             }
 454         }
 455         /* all blocks are finished, so the extra bytes can be used at
 456            the video segment level */
 457         if (j >= 6)
 458             bit_copy(&vs_pb, &gb);
 459     }
 460
 461     /* we need a pass other the whole video segment */
 462 #ifdef VLC_DEBUG
 463     printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
 464 #endif
 465     block = &sblock[0][0];
 466     mb = mb_data;
 467     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
 468     flush_put_bits(&vs_pb);
 469     for(mb_index = 0; mb_index < 5; mb_index++) {
 470         for(j = 0;j < 6; j++) {
 471             if (mb->pos < 64) {
 472 #ifdef VLC_DEBUG
 473                 printf("start %d:%d\n", mb_index, j);
 474 #endif
 475                 dv_decode_ac(&gb, mb, block);
 476             }
 477             if (mb->pos >= 64 && mb->pos < 127)
 478                 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
 479             block += 64;
 480             mb++;
 481         }
 482     }
 483
 484     /* compute idct and place blocks */
 485     block = &sblock[0][0];
 486     mb = mb_data;
 487     for(mb_index = 0; mb_index < 5; mb_index++) {
 488         v = *mb_pos_ptr++;
 489         mb_x = v & 0xff;
 490         mb_y = v >> 8;
 491         y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
 492         if (s->sys->pix_fmt == PIX_FMT_YUV411P)
 493             c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
 494         else
 495             c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize);
 496         for(j = 0;j < 6; j++) {
 497             idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];
 498             if (j < 4) {
 499                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
 500                     /* NOTE: at end of line, the macroblock is handled as 420 */
 501                     idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);
 502                 } else {
 503                     idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),
 504                              s->picture.linesize[0], block);
 505                 }
 506             } else {
 507                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 508                     uint64_t aligned_pixels[64/8];
 509                     uint8_t *pixels= (uint8_t*)aligned_pixels;
 510                     uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
 511                     int x, y, linesize;
 512                     /* NOTE: at end of line, the macroblock is handled as 420 */
 513                     idct_put(pixels, 8, block);
 514                     linesize = s->picture.linesize[6 - j];
 515                     c_ptr = s->picture.data[6 - j] + c_offset;
 516                     ptr = pixels;
 517                     for(y = 0;y < (1<<log2_blocksize); y++) {
 518                         ptr1= ptr + (1<<(log2_blocksize-1));
 519                         c_ptr1 = c_ptr + (linesize<<log2_blocksize);
 520                         for(x=0; x < (1<<(log2_blocksize-1)); x++){
 521                             c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];
 522                         }
 523                         c_ptr += linesize;
 524                         ptr += 8;
 525                     }
 526                 } else {
 527                     /* don't ask me why they inverted Cb and Cr ! */
 528                     idct_put(s->picture.data[6 - j] + c_offset,
 529                              s->picture.linesize[6 - j], block);
 530                 }
 531             }
 532             block += 64;
 533             mb++;
 534         }
 535     }
 536 }
 537
 538 #ifdef DV_CODEC_TINY_TARGET
 539 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
 540 static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
 541 {
 542     int size;
 543     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 544         *vlc = dv_vlc_map[run][level].vlc | sign;
 545         size = dv_vlc_map[run][level].size;
 546     }
 547     else {
 548         if (level < DV_VLC_MAP_LEV_SIZE) {
 549             *vlc = dv_vlc_map[0][level].vlc | sign;
 550             size = dv_vlc_map[0][level].size;
 551         } else {
 552             *vlc = 0xfe00 | (level << 1) | sign;
 553             size = 16;
 554         }
 555         if (run) {
 556             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
 557                                   (0x1f80 | (run - 1))) << size;
 558             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 559         }
 560     }
 561
 562     return size;
 563 }
 564
 565 static always_inline int dv_rl2vlc_size(int run, int level)
 566 {
 567     int size;
 568
 569     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 570         size = dv_vlc_map[run][level].size;
 571     }
 572     else {
 573         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
 574         if (run) {
 575             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 576         }
 577     }
 578     return size;
 579 }
 580 #else
 581 static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
 582 {
 583     *vlc = dv_vlc_map[run][l].vlc | sign;
 584     return dv_vlc_map[run][l].size;
 585 }
 586
 587 static always_inline int dv_rl2vlc_size(int run, int l)
 588 {
 589     return dv_vlc_map[run][l].size;
 590 }
 591 #endif
 592
 593 typedef struct EncBlockInfo {
 594     int area_q[4];
 595     int bit_size[4];
 596     int prev[5];
 597     int cur_ac;
 598     int cno;
 599     int dct_mode;
 600     DCTELEM mb[64];
 601     uint8_t next[64];
 602     uint8_t sign[64];
 603     uint8_t partial_bit_count;
 604     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
 605 } EncBlockInfo;
 606
 607 static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
 608                                        PutBitContext* pb_end)
 609 {
 610     int prev;
 611     int bits_left;
 612     PutBitContext* pb = pb_pool;
 613     int size = bi->partial_bit_count;
 614     uint32_t vlc = bi->partial_bit_buffer;
 615
 616     bi->partial_bit_count = bi->partial_bit_buffer = 0;
 617     for(;;){
 618        /* Find suitable storage space */
 619        for (; size > (bits_left = put_bits_left(pb)); pb++) {
 620           if (bits_left) {
 621               size -= bits_left;
 622               put_bits(pb, bits_left, vlc >> size);
 623               vlc = vlc & ((1<<size)-1);
 624           }
 625           if (pb + 1 >= pb_end) {
 626               bi->partial_bit_count = size;
 627               bi->partial_bit_buffer = vlc;
 628               return pb;
 629           }
 630        }
 631
 632        /* Store VLC */
 633        put_bits(pb, size, vlc);
 634
 635        if(bi->cur_ac>=64)
 636            break;
 637
 638        /* Construct the next VLC */
 639        prev= bi->cur_ac;
 640        bi->cur_ac = bi->next[prev];
 641        if(bi->cur_ac < 64){
 642            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
 643        } else {
 644            size = 4; vlc = 6; /* End Of Block stamp */
 645        }
 646     }
 647     return pb;
 648 }
 649
 650 static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
 651                                               const uint8_t* zigzag_scan, int bias)
 652 {
 653     int i, area;
 654     static const int classes[] = {12, 24, 36, 0xffff};
 655     int max=12;
 656     int prev=0;
 657
 658     bi->mb[0] = blk[0];
 659
 660     for (area = 0; area < 4; area++) {
 661        bi->prev[area] = prev;
 662        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 663        for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
 664           int level = blk[zigzag_scan[i]];
 665
 666           if (level+15 > 30U) {
 667               bi->sign[i] = (level>>31)&1;
 668               bi->mb[i] = level= ABS(level)>>4;
 669               if(level>max) max= level;
 670               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
 671               bi->next[prev]= i;
 672               prev= i;
 673           }
 674        }
 675     }
 676     bi->next[prev]= i;
 677     for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
 678
 679     bi->cno += bias;
 680
 681     if (bi->cno >= 3) {
 682         bi->cno = 3;
 683         prev=0;
 684         i= bi->next[prev];
 685         for (area = 0; area < 4; area++) {
 686             bi->prev[area] = prev;
 687             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 688             for (; i<mb_area_start[area+1]; i= bi->next[i]) {
 689                 bi->mb[i] >>=1;
 690
 691                 if (bi->mb[i]) {
 692                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
 693                     bi->next[prev]= i;
 694                     prev= i;
 695                 }
 696             }
 697         }
 698         bi->next[prev]= i;
 699     }
 700 }
 701
 702 //FIXME replace this by dsputil
 703 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
 704 static always_inline int dv_guess_dct_mode(DCTELEM *blk) {
 705     DCTELEM *s;
 706     int score88 = 0;
 707     int score248 = 0;
 708     int i;
 709
 710     /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
 711     s = blk;
 712     for(i=0; i<7; i++) {
 713         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
 714                    SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
 715         s += 8;
 716     }
 717     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
 718     s = blk;
 719     for(i=0; i<6; i++) {
 720         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
 721                     SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
 722         s += 8;
 723     }
 724
 725     return (score88 - score248 > -10);
 726 }
 727
 728 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
 729 {
 730     int size[5];
 731     int i, j, k, a, prev;
 732     EncBlockInfo* b;
 733
 734     do {
 735        b = blks;
 736        for (i=0; i<5; i++) {
 737           if (!qnos[i])
 738               continue;
 739
 740           qnos[i]--;
 741           size[i] = 0;
 742           for (j=0; j<6; j++, b++) {
 743              for (a=0; a<4; a++) {
 744                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
 745                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
 746                     b->area_q[a]++;
 747                     prev= b->prev[a];
 748                     for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
 749                        b->mb[k] >>= 1;
 750                        if (b->mb[k]) {
 751                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 752                            prev= k;
 753                        } else {
 754                            b->next[prev] = b->next[k];
 755                        }
 756                     }
 757                     b->prev[a+1]= prev;
 758                 }
 759                 size[i] += b->bit_size[a];
 760              }
 761           }
 762        }
 763     } while ((vs_total_ac_bits < size[0] + size[1] + size[2] + size[3] + size[4]) &&
 764              (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]));
 765 }
 766
 767 /*
 768  * This is a very rough initial implementaion. The performance is
 769  * horrible and the weighting is missing. But it's missing from the
 770  * decoding step also -- so at least we're on the same page with decoder ;-)
 771  */
 772 static inline void dv_encode_video_segment(DVVideoContext *s,
 773                                            uint8_t *dif,
 774                                            const uint16_t *mb_pos_ptr)
 775 {
 776     int mb_index, i, j, v;
 777     int mb_x, mb_y, c_offset, linesize;
 778     uint8_t*  y_ptr;
 779     uint8_t*  data;
 780     uint8_t*  ptr;
 781     int       do_edge_wrap;
 782     DCTELEM   block[64] __align8;
 783     EncBlockInfo  enc_blks[5*6];
 784     PutBitContext pbs[5*6];
 785     PutBitContext* pb;
 786     EncBlockInfo* enc_blk;
 787     int       vs_bit_size = 0;
 788     int       qnos[5];
 789
 790     assert((((int)block) & 7) == 0);
 791
 792     enc_blk = &enc_blks[0];
 793     pb = &pbs[0];
 794     for(mb_index = 0; mb_index < 5; mb_index++) {
 795         v = *mb_pos_ptr++;
 796         mb_x = v & 0xff;
 797         mb_y = v >> 8;
 798         y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
 799         c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ?
 800                    ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) :
 801                    (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
 802         do_edge_wrap = 0;
 803         qnos[mb_index] = 15; /* No quantization */
 804         ptr = dif + mb_index*80 + 4;
 805         for(j = 0;j < 6; j++) {
 806             if (j < 4) {  /* Four Y blocks */
 807                 /* NOTE: at end of line, the macroblock is handled as 420 */
 808                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
 809                     data = y_ptr + (j * 8);
 810                 } else {
 811                     data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
 812                 }
 813                 linesize = s->picture.linesize[0];
 814             } else {      /* Cr and Cb blocks */
 815                 /* don't ask Fabrice why they inverted Cb and Cr ! */
 816                 data = s->picture.data[6 - j] + c_offset;
 817                 linesize = s->picture.linesize[6 - j];
 818                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
 819                     do_edge_wrap = 1;
 820             }
 821
 822             /* Everything is set up -- now just copy data -> DCT block */
 823             if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
 824                 uint8_t* d;
 825                 DCTELEM *b = block;
 826                 for (i=0;i<8;i++) {
 827                    d = data + 8 * linesize;
 828                    b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
 829                    b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
 830                    data += linesize;
 831                    b += 8;
 832                 }
 833             } else {             /* Simple copy: 8x8 -> 8x8 */
 834                 s->get_pixels(block, data, linesize);
 835             }
 836
 837             if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
 838                 enc_blk->dct_mode = dv_guess_dct_mode(block);
 839             else
 840                 enc_blk->dct_mode = 0;
 841             enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
 842             enc_blk->partial_bit_count = 0;
 843             enc_blk->partial_bit_buffer = 0;
 844             enc_blk->cur_ac = 0;
 845
 846             s->fdct[enc_blk->dct_mode](block);
 847
 848             dv_set_class_number(block, enc_blk,
 849                                 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, j/4);
 850
 851             init_put_bits(pb, ptr, block_sizes[j]/8);
 852             put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
 853             put_bits(pb, 1, enc_blk->dct_mode);
 854             put_bits(pb, 2, enc_blk->cno);
 855
 856             vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
 857                            enc_blk->bit_size[2] + enc_blk->bit_size[3];
 858             ++enc_blk;
 859             ++pb;
 860             ptr += block_sizes[j]/8;
 861         }
 862     }
 863
 864     if (vs_total_ac_bits < vs_bit_size)
 865         dv_guess_qnos(&enc_blks[0], &qnos[0]);
 866
 867     for (i=0; i<5; i++) {
 868        dif[i*80 + 3] = qnos[i];
 869     }
 870
 871     /* First pass over individual cells only */
 872     for (j=0; j<5*6; j++)
 873        dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
 874
 875     /* Second pass over each MB space */
 876     for (j=0; j<5*6; j+=6) {
 877         pb= &pbs[j];
 878         for (i=0; i<6; i++) {
 879             if (enc_blks[i+j].partial_bit_count)
 880                 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
 881         }
 882     }
 883
 884     /* Third and final pass over the whole vides segment space */
 885     pb= &pbs[0];
 886     for (j=0; j<5*6; j++) {
 887        if (enc_blks[j].partial_bit_count)
 888            pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
 889     }
 890
 891     for (j=0; j<5*6; j++)
 892        flush_put_bits(&pbs[j]);
 893 }
 894
 895 static int dv_decode_mt(AVCodecContext *avctx, void* sl)
 896 {
 897     DVVideoContext *s = avctx->priv_data;
 898     int slice = (size_t)sl;
 899     dv_decode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
 900                             &s->sys->video_place[slice*5]);
 901     return 0;
 902 }
 903
 904 static int dv_encode_mt(AVCodecContext *avctx, void* sl)
 905 {
 906     DVVideoContext *s = avctx->priv_data;
 907     int slice = (size_t)sl;
 908     dv_encode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
 909                             &s->sys->video_place[slice*5]);
 910     return 0;
 911 }
 912
 913 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
 914    144000 bytes for PAL) */
 915 static int dvvideo_decode_frame(AVCodecContext *avctx,
 916                                  void *data, int *data_size,
 917                                  uint8_t *buf, int buf_size)
 918 {
 919     DVVideoContext *s = avctx->priv_data;
 920
 921     s->sys = dv_frame_profile(buf);
 922     if (!s->sys || buf_size < s->sys->frame_size)
 923         return -1; /* NOTE: we only accept several full frames */
 924
 925     if(s->picture.data[0])
 926         avctx->release_buffer(avctx, &s->picture);
 927
 928     s->picture.reference = 0;
 929     s->picture.key_frame = 1;
 930     s->picture.pict_type = FF_I_TYPE;
 931     avctx->pix_fmt = s->sys->pix_fmt;
 932     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
 933     if(avctx->get_buffer(avctx, &s->picture) < 0) {
 934         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 935         return -1;
 936     }
 937     s->picture.interlaced_frame = 1;
 938     s->picture.top_field_first = 0;
 939
 940     s->buf = buf;
 941     avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
 942                    s->sys->difseg_size * 27);
 943
 944     emms_c();
 945
 946     /* return image */
 947     *data_size = sizeof(AVFrame);
 948     *(AVFrame*)data= s->picture;
 949
 950     return s->sys->frame_size;
 951 }
 952
 953 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
 954                                 void *data)
 955 {
 956     DVVideoContext *s = c->priv_data;
 957
 958     s->sys = dv_codec_profile(c);
 959     if (!s->sys)
 960         return -1;
 961     if(buf_size < s->sys->frame_size)
 962         return -1;
 963
 964     c->pix_fmt = s->sys->pix_fmt;
 965     s->picture = *((AVFrame *)data);
 966     s->picture.key_frame = 1;
 967     s->picture.pict_type = FF_I_TYPE;
 968
 969     s->buf = buf;
 970     c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
 971                s->sys->difseg_size * 27);
 972
 973     emms_c();
 974     return s->sys->frame_size;
 975 }
 976
 977 static int dvvideo_close(AVCodecContext *c)
 978 {
 979
 980     return 0;
 981 }
 982
 983
 984 #ifdef CONFIG_DVVIDEO_ENCODER
 985 AVCodec dvvideo_encoder = {
 986     "dvvideo",
 987     CODEC_TYPE_VIDEO,
 988     CODEC_ID_DVVIDEO,
 989     sizeof(DVVideoContext),
 990     dvvideo_init,
 991     dvvideo_encode_frame,
 992     dvvideo_close,
 993     NULL,
 994     CODEC_CAP_DR1,
 995     NULL
 996 };
 997 #endif // CONFIG_DVVIDEO_ENCODER
 998
 999 AVCodec dvvideo_decoder = {
1000     "dvvideo",
1001     CODEC_TYPE_VIDEO,
1002     CODEC_ID_DVVIDEO,
1003     sizeof(DVVideoContext),
1004     dvvideo_init,
1005     NULL,
1006     dvvideo_close,
1007     dvvideo_decode_frame,
1008     CODEC_CAP_DR1,
1009     NULL
1010 };