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

   1 /*
   2  * MSMPEG4 backend for ffmpeg encoder and decoder
   3  * Copyright (c) 2001 Gerard Lantau.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include "common.h"
  22 #include "dsputil.h"
  23 #include "mpegvideo.h"
  24 #include "avcodec.h"
  25
  26 /*
  27  * You can also call this codec : MPEG4 with a twist !
  28  *
  29  * TODO:
  30  *        - (encoding) select best mv table (two choices)
  31  *        - (encoding) select best vlc/dc table
  32  */
  33 //#define DEBUG
  34
  35 /* motion vector table */
  36 typedef struct MVTable {
  37     int n;
  38     const UINT16 *table_mv_code;
  39     const UINT8 *table_mv_bits;
  40     const UINT8 *table_mvx;
  41     const UINT8 *table_mvy;
  42     UINT16 *table_mv_index; /* encoding: convert mv to index in table_mv */
  43     VLC vlc;                /* decoding: vlc */
  44 } MVTable;
  45
  46 static UINT32 v2_dc_lum_table[512][2];
  47 static UINT32 v2_dc_chroma_table[512][2];
  48
  49 static void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
  50 static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
  51                                 int n, int coded);
  52 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
  53 static int msmpeg4_decode_motion(MpegEncContext * s,
  54                                  int *mx_ptr, int *my_ptr);
  55 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
  56 static void init_h263_dc_for_msmpeg4();
  57
  58
  59 extern UINT32 inverse[256];
  60
  61 #ifdef DEBUG
  62 int intra_count = 0;
  63 int frame_count = 0;
  64 #endif
  65 /* XXX: move it to mpegvideo.h */
  66
  67 static int init_done = 0;
  68
  69 #include "msmpeg4data.h"
  70
  71 #ifdef STATS
  72
  73 const char *st_names[ST_NB] = {
  74     "unknown",
  75     "dc",
  76     "intra_ac",
  77     "inter_ac",
  78     "intra_mb",
  79     "inter_mb",
  80     "mv",
  81 };
  82
  83 int st_current_index = 0;
  84 unsigned int st_bit_counts[ST_NB];
  85 unsigned int st_out_bit_counts[ST_NB];
  86
  87 #define set_stat(var) st_current_index = var;
  88
  89 void print_stats(void)
  90 {
  91     unsigned int total;
  92     int i;
  93
  94     printf("Input:\n");
  95     total = 0;
  96     for(i=0;i<ST_NB;i++)
  97         total += st_bit_counts[i];
  98     if (total == 0)
  99         total = 1;
 100     for(i=0;i<ST_NB;i++) {
 101         printf("%-10s : %10.1f %5.1f%%\n",
 102                st_names[i],
 103                (double)st_bit_counts[i] / 8.0,
 104                (double)st_bit_counts[i] * 100.0 / total);
 105     }
 106     printf("%-10s : %10.1f %5.1f%%\n",
 107            "total",
 108            (double)total / 8.0,
 109            100.0);
 110
 111     printf("Output:\n");
 112     total = 0;
 113     for(i=0;i<ST_NB;i++)
 114         total += st_out_bit_counts[i];
 115     if (total == 0)
 116         total = 1;
 117     for(i=0;i<ST_NB;i++) {
 118         printf("%-10s : %10.1f %5.1f%%\n",
 119                st_names[i],
 120                (double)st_out_bit_counts[i] / 8.0,
 121                (double)st_out_bit_counts[i] * 100.0 / total);
 122     }
 123     printf("%-10s : %10.1f %5.1f%%\n",
 124            "total",
 125            (double)total / 8.0,
 126            100.0);
 127 }
 128
 129 #else
 130
 131 #define set_stat(var)
 132
 133 #endif
 134
 135 /* build the table which associate a (x,y) motion vector to a vlc */
 136 static void init_mv_table(MVTable *tab)
 137 {
 138     int i, x, y;
 139
 140     tab->table_mv_index = malloc(sizeof(UINT16) * 4096);
 141     /* mark all entries as not used */
 142     for(i=0;i<4096;i++)
 143         tab->table_mv_index[i] = tab->n;
 144
 145     for(i=0;i<tab->n;i++) {
 146         x = tab->table_mvx[i];
 147         y = tab->table_mvy[i];
 148         tab->table_mv_index[(x << 6) | y] = i;
 149     }
 150 }
 151
 152 static void code012(PutBitContext *pb, int n)
 153 {
 154     if (n == 0) {
 155         put_bits(pb, 1, 0);
 156     } else {
 157         put_bits(pb, 1, 1);
 158         put_bits(pb, 1, (n >= 2));
 159     }
 160 }
 161
 162 /* write MSMPEG4 V3 compatible frame header */
 163 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
 164 {
 165     int i;
 166
 167     align_put_bits(&s->pb);
 168
 169     put_bits(&s->pb, 2, s->pict_type - 1);
 170
 171     put_bits(&s->pb, 5, s->qscale);
 172
 173     s->rl_table_index = 2;
 174     if(s->msmpeg4_version==2)
 175         s->rl_chroma_table_index = 2; /* only for I frame */
 176     else
 177         s->rl_chroma_table_index = 1; /* only for I frame */
 178
 179     s->dc_table_index = 1;
 180     s->mv_table_index = 1; /* only if P frame */
 181     s->use_skip_mb_code = 1; /* only if P frame */
 182
 183     if (s->pict_type == I_TYPE) {
 184         put_bits(&s->pb, 5, 0x17); /* indicate only one "slice" */
 185
 186         if(s->msmpeg4_version!=2){
 187             code012(&s->pb, s->rl_chroma_table_index);
 188             code012(&s->pb, s->rl_table_index);
 189
 190             put_bits(&s->pb, 1, s->dc_table_index);
 191         }
 192         s->no_rounding = 1;
 193     } else {
 194         put_bits(&s->pb, 1, s->use_skip_mb_code);
 195
 196         s->rl_chroma_table_index = s->rl_table_index;
 197         if(s->msmpeg4_version!=2){
 198             code012(&s->pb, s->rl_table_index);
 199
 200             put_bits(&s->pb, 1, s->dc_table_index);
 201
 202             put_bits(&s->pb, 1, s->mv_table_index);
 203         }
 204
 205         if(s->flipflop_rounding){
 206             s->no_rounding ^= 1;
 207         }else{
 208             s->no_rounding = 0;
 209         }
 210     }
 211
 212     if (!init_done) {
 213         /* init various encoding tables */
 214         init_done = 1;
 215         init_mv_table(&mv_tables[0]);
 216         init_mv_table(&mv_tables[1]);
 217         for(i=0;i<NB_RL_TABLES;i++)
 218             init_rl(&rl_table[i]);
 219
 220         init_h263_dc_for_msmpeg4();
 221     }
 222
 223 #ifdef DEBUG
 224     intra_count = 0;
 225     printf("*****frame %d:\n", frame_count++);
 226 #endif
 227 }
 228
 229 void msmpeg4_encode_ext_header(MpegEncContext * s)
 230 {
 231         s->flipflop_rounding=1;
 232         s->bitrate= 910; // FIXME
 233
 234         put_bits(&s->pb, 5, s->frame_rate / FRAME_RATE_BASE); //yes 29.97 -> 29
 235
 236         put_bits(&s->pb, 11, s->bitrate);
 237
 238         put_bits(&s->pb, 1, s->flipflop_rounding);
 239 }
 240
 241 /* predict coded block */
 242 static inline int coded_block_pred(MpegEncContext * s, int n, UINT8 **coded_block_ptr)
 243 {
 244     int xy, wrap, pred, a, b, c;
 245
 246     xy = s->block_index[n];
 247     wrap = s->block_wrap[0];
 248
 249     /* B C
 250      * A X
 251      */
 252     a = s->coded_block[xy - 1       ];
 253     b = s->coded_block[xy - 1 - wrap];
 254     c = s->coded_block[xy     - wrap];
 255
 256     if (b == c) {
 257         pred = a;
 258     } else {
 259         pred = c;
 260     }
 261
 262     /* store value */
 263     *coded_block_ptr = &s->coded_block[xy];
 264
 265     return pred;
 266 }
 267
 268 static void msmpeg4_encode_motion(MpegEncContext * s,
 269                                   int mx, int my)
 270 {
 271     int code;
 272     MVTable *mv;
 273
 274     /* modulo encoding */
 275     /* WARNING : you cannot reach all the MVs even with the modulo
 276        encoding. This is a somewhat strange compromise they took !!!  */
 277     if (mx <= -64)
 278         mx += 64;
 279     else if (mx >= 64)
 280         mx -= 64;
 281     if (my <= -64)
 282         my += 64;
 283     else if (my >= 64)
 284         my -= 64;
 285
 286     mx += 32;
 287     my += 32;
 288 #if 0
 289     if ((unsigned)mx >= 64 ||
 290         (unsigned)my >= 64)
 291         fprintf(stderr, "error mx=%d my=%d\n", mx, my);
 292 #endif
 293     mv = &mv_tables[s->mv_table_index];
 294
 295     code = mv->table_mv_index[(mx << 6) | my];
 296     set_stat(ST_MV);
 297     put_bits(&s->pb,
 298              mv->table_mv_bits[code],
 299              mv->table_mv_code[code]);
 300     if (code == mv->n) {
 301         /* escape : code litterally */
 302         put_bits(&s->pb, 6, mx);
 303         put_bits(&s->pb, 6, my);
 304     }
 305 }
 306
 307 void msmpeg4_encode_mb(MpegEncContext * s,
 308                        DCTELEM block[6][64],
 309                        int motion_x, int motion_y)
 310 {
 311     int cbp, coded_cbp, i;
 312     int pred_x, pred_y;
 313     UINT8 *coded_block;
 314
 315     if (!s->mb_intra) {
 316         /* compute cbp */
 317         set_stat(ST_INTER_MB);
 318         cbp = 0;
 319         for (i = 0; i < 6; i++) {
 320             if (s->block_last_index[i] >= 0)
 321                 cbp |= 1 << (5 - i);
 322         }
 323         if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
 324             /* skip macroblock */
 325             put_bits(&s->pb, 1, 1);
 326             return;
 327         }
 328         if (s->use_skip_mb_code)
 329             put_bits(&s->pb, 1, 0);     /* mb coded */
 330
 331         if(s->msmpeg4_version==2){
 332             put_bits(&s->pb,
 333                      v2_mb_type[cbp&3][1],
 334                      v2_mb_type[cbp&3][0]);
 335             if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
 336             else             coded_cbp= cbp;
 337
 338             put_bits(&s->pb,
 339                      cbpy_tab[coded_cbp>>2][1],
 340                      cbpy_tab[coded_cbp>>2][0]);
 341
 342             h263_pred_motion(s, 0, &pred_x, &pred_y);
 343             msmpeg4v2_encode_motion(s, motion_x - pred_x);
 344             msmpeg4v2_encode_motion(s, motion_y - pred_y);
 345         }else{
 346             put_bits(&s->pb,
 347                      table_mb_non_intra[cbp + 64][1],
 348                      table_mb_non_intra[cbp + 64][0]);
 349
 350             /* motion vector */
 351             h263_pred_motion(s, 0, &pred_x, &pred_y);
 352             msmpeg4_encode_motion(s, motion_x - pred_x,
 353                                   motion_y - pred_y);
 354         }
 355     } else {
 356         /* compute cbp */
 357         cbp = 0;
 358         coded_cbp = 0;
 359         for (i = 0; i < 6; i++) {
 360             int val, pred;
 361             val = (s->block_last_index[i] >= 1);
 362             cbp |= val << (5 - i);
 363             if (i < 4) {
 364                 /* predict value for close blocks only for luma */
 365                 pred = coded_block_pred(s, i, &coded_block);
 366                 *coded_block = val;
 367                 val = val ^ pred;
 368             }
 369             coded_cbp |= val << (5 - i);
 370         }
 371 #if 0
 372         if (coded_cbp)
 373             printf("cbp=%x %x\n", cbp, coded_cbp);
 374 #endif
 375
 376         if(s->msmpeg4_version==2){
 377             if (s->pict_type == I_TYPE) {
 378                 put_bits(&s->pb,
 379                          v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
 380             } else {
 381                 if (s->use_skip_mb_code)
 382                     put_bits(&s->pb, 1, 0);     /* mb coded */
 383                 put_bits(&s->pb,
 384                          v2_mb_type[(cbp&3) + 4][1],
 385                          v2_mb_type[(cbp&3) + 4][0]);
 386             }
 387             put_bits(&s->pb, 1, 0);     /* no AC prediction yet */
 388             put_bits(&s->pb,
 389                      cbpy_tab[cbp>>2][1],
 390                      cbpy_tab[cbp>>2][0]);
 391         }else{
 392             if (s->pict_type == I_TYPE) {
 393                 set_stat(ST_INTRA_MB);
 394                 put_bits(&s->pb,
 395                          table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
 396             } else {
 397                 if (s->use_skip_mb_code)
 398                     put_bits(&s->pb, 1, 0);     /* mb coded */
 399                 put_bits(&s->pb,
 400                          table_mb_non_intra[cbp][1],
 401                          table_mb_non_intra[cbp][0]);
 402             }
 403             set_stat(ST_INTRA_MB);
 404             put_bits(&s->pb, 1, 0);     /* no AC prediction yet */
 405         }
 406     }
 407
 408     for (i = 0; i < 6; i++) {
 409         msmpeg4_encode_block(s, block[i], i);
 410     }
 411 }
 412
 413
 414 /* strongly inspirated from MPEG4, but not exactly the same ! */
 415 void msmpeg4_dc_scale(MpegEncContext * s)
 416 {
 417     if (s->qscale < 5 || s->msmpeg4_version==2){
 418         s->y_dc_scale = 8;
 419         s->c_dc_scale = 8;
 420     }else if (s->qscale < 9){
 421         s->y_dc_scale = 2 * s->qscale;
 422         s->c_dc_scale = (s->qscale + 13)>>1;
 423     }else{
 424         s->y_dc_scale = s->qscale + 8;
 425         s->c_dc_scale = (s->qscale + 13)>>1;
 426     }
 427 }
 428
 429 /* dir = 0: left, dir = 1: top prediction */
 430 static int msmpeg4_pred_dc(MpegEncContext * s, int n,
 431                            INT16 **dc_val_ptr, int *dir_ptr)
 432 {
 433     int a, b, c, wrap, pred, scale;
 434     INT16 *dc_val;
 435
 436     /* find prediction */
 437     if (n < 4) {
 438         scale = s->y_dc_scale;
 439     } else {
 440         scale = s->c_dc_scale;
 441     }
 442     wrap = s->block_wrap[n];
 443     dc_val= s->dc_val[0] + s->block_index[n];
 444
 445     /* B C
 446      * A X
 447      */
 448     a = dc_val[ - 1];
 449     b = dc_val[ - 1 - wrap];
 450     c = dc_val[ - wrap];
 451
 452     /* XXX: the following solution consumes divisions, but it does not
 453        necessitate to modify mpegvideo.c. The problem comes from the
 454        fact they decided to store the quantized DC (which would lead
 455        to problems if Q could vary !) */
 456 #if defined ARCH_X86 && !defined PIC
 457     asm volatile(
 458         "movl %3, %%eax         \n\t"
 459         "shrl $1, %%eax         \n\t"
 460         "addl %%eax, %2         \n\t"
 461         "addl %%eax, %1         \n\t"
 462         "addl %0, %%eax         \n\t"
 463         "mull %4                \n\t"
 464         "movl %%edx, %0         \n\t"
 465         "movl %1, %%eax         \n\t"
 466         "mull %4                \n\t"
 467         "movl %%edx, %1         \n\t"
 468         "movl %2, %%eax         \n\t"
 469         "mull %4                \n\t"
 470         "movl %%edx, %2         \n\t"
 471         : "+b" (a), "+c" (b), "+D" (c)
 472         : "g" (scale), "S" (inverse[scale])
 473         : "%eax", "%edx"
 474     );
 475 #else
 476     /* #elif defined (ARCH_ALPHA) */
 477     /* Divisions are extremely costly on Alpha; optimize the most
 478        common case. But they are costly everywhere...
 479      */
 480     if (scale == 8) {
 481         a = (a + (8 >> 1)) / 8;
 482         b = (b + (8 >> 1)) / 8;
 483         c = (c + (8 >> 1)) / 8;
 484     } else {
 485         a = (a + (scale >> 1)) / scale;
 486         b = (b + (scale >> 1)) / scale;
 487         c = (c + (scale >> 1)) / scale;
 488     }
 489 #endif
 490     /* XXX: WARNING: they did not choose the same test as MPEG4. This
 491        is very important ! */
 492     if (abs(a - b) <= abs(b - c)) {
 493         pred = c;
 494         *dir_ptr = 1;
 495     } else {
 496         pred = a;
 497         *dir_ptr = 0;
 498     }
 499
 500     /* update predictor */
 501     *dc_val_ptr = &dc_val[0];
 502     return pred;
 503 }
 504
 505 #define DC_MAX 119
 506
 507 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
 508 {
 509     int sign, code;
 510     int pred;
 511     INT16 *dc_val;
 512
 513     pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
 514
 515     /* update predictor */
 516     if (n < 4) {
 517         *dc_val = level * s->y_dc_scale;
 518     } else {
 519         *dc_val = level * s->c_dc_scale;
 520     }
 521
 522     /* do the prediction */
 523     level -= pred;
 524
 525     if(s->msmpeg4_version==2){
 526         if (n < 4) {
 527             put_bits(&s->pb,
 528                      v2_dc_lum_table[level+256][1],
 529                      v2_dc_lum_table[level+256][0]);
 530         }else{
 531             put_bits(&s->pb,
 532                      v2_dc_chroma_table[level+256][1],
 533                      v2_dc_chroma_table[level+256][0]);
 534         }
 535     }else{
 536         sign = 0;
 537         if (level < 0) {
 538             level = -level;
 539             sign = 1;
 540         }
 541         code = level;
 542         if (code > DC_MAX)
 543             code = DC_MAX;
 544
 545         if (s->dc_table_index == 0) {
 546             if (n < 4) {
 547                 put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
 548             } else {
 549                 put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
 550             }
 551         } else {
 552             if (n < 4) {
 553                 put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
 554             } else {
 555                 put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
 556             }
 557         }
 558
 559         if (code == DC_MAX)
 560             put_bits(&s->pb, 8, level);
 561
 562         if (level != 0) {
 563             put_bits(&s->pb, 1, sign);
 564         }
 565     }
 566 }
 567
 568 /* Encoding of a block. Very similar to MPEG4 except for a different
 569    escape coding (same as H263) and more vlc tables.
 570  */
 571 static void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
 572 {
 573     int level, run, last, i, j, last_index;
 574     int last_non_zero, sign, slevel;
 575     int code, run_diff, dc_pred_dir;
 576     const RLTable *rl;
 577
 578     if (s->mb_intra) {
 579         set_stat(ST_DC);
 580         msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
 581         i = 1;
 582         if (n < 4) {
 583             rl = &rl_table[s->rl_table_index];
 584         } else {
 585             rl = &rl_table[3 + s->rl_chroma_table_index];
 586         }
 587         run_diff = 0;
 588         set_stat(ST_INTRA_AC);
 589     } else {
 590         i = 0;
 591         rl = &rl_table[3 + s->rl_table_index];
 592         if(s->msmpeg4_version==2)
 593             run_diff = 0;
 594         else
 595             run_diff = 1;
 596         set_stat(ST_INTER_AC);
 597     }
 598
 599     /* AC coefs */
 600     last_index = s->block_last_index[n];
 601     last_non_zero = i - 1;
 602     for (; i <= last_index; i++) {
 603         j = zigzag_direct[i];
 604         level = block[j];
 605         if (level) {
 606             run = i - last_non_zero - 1;
 607             last = (i == last_index);
 608             sign = 0;
 609             slevel = level;
 610             if (level < 0) {
 611                 sign = 1;
 612                 level = -level;
 613             }
 614             code = get_rl_index(rl, last, run, level);
 615             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 616             if (code == rl->n) {
 617                 int level1, run1;
 618
 619                 level1 = level - rl->max_level[last][run];
 620                 if (level1 < 1)
 621                     goto esc2;
 622                 code = get_rl_index(rl, last, run, level1);
 623                 if (code == rl->n) {
 624                 esc2:
 625                     put_bits(&s->pb, 1, 0);
 626                     if (level > MAX_LEVEL)
 627                         goto esc3;
 628                     run1 = run - rl->max_run[last][level] - run_diff;
 629                     if (run1 < 0)
 630                         goto esc3;
 631                     code = get_rl_index(rl, last, run1, level);
 632                     if (code == rl->n) {
 633                     esc3:
 634                         /* third escape */
 635                         put_bits(&s->pb, 1, 0);
 636                         put_bits(&s->pb, 1, last);
 637                         put_bits(&s->pb, 6, run);
 638                         put_bits(&s->pb, 8, slevel & 0xff);
 639                     } else {
 640                         /* second escape */
 641                         put_bits(&s->pb, 1, 1);
 642                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 643                         put_bits(&s->pb, 1, sign);
 644                     }
 645                 } else {
 646                     /* first escape */
 647                     put_bits(&s->pb, 1, 1);
 648                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 649                     put_bits(&s->pb, 1, sign);
 650                 }
 651             } else {
 652                 put_bits(&s->pb, 1, sign);
 653             }
 654             last_non_zero = i;
 655         }
 656     }
 657 }
 658
 659 /****************************************/
 660 /* decoding stuff */
 661
 662 static VLC mb_non_intra_vlc;
 663 static VLC mb_intra_vlc;
 664 static VLC dc_lum_vlc[2];
 665 static VLC dc_chroma_vlc[2];
 666 static VLC v2_dc_lum_vlc;
 667 static VLC v2_dc_chroma_vlc;
 668 static VLC cbpy_vlc;
 669 static VLC v2_intra_cbpc_vlc;
 670 static VLC v2_mb_type_vlc;
 671 static VLC v2_mv_vlc;
 672
 673 /* this table is practically identical to the one from h263 except that its inverted */
 674 static void init_h263_dc_for_msmpeg4()
 675 {
 676     static int inited=0;
 677
 678     if(!inited){
 679         int level, uni_code, uni_len;
 680         inited=1;
 681
 682         for(level=-256; level<256; level++){
 683             int size, v, l;
 684             /* find number of bits */
 685             size = 0;
 686             v = abs(level);
 687             while (v) {
 688                 v >>= 1;
 689                     size++;
 690             }
 691
 692             if (level < 0)
 693                 l= (-level) ^ ((1 << size) - 1);
 694             else
 695                 l= level;
 696
 697             /* luminance h263 */
 698             uni_code= DCtab_lum[size][0];
 699             uni_len = DCtab_lum[size][1];
 700             uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
 701
 702             if (size > 0) {
 703                 uni_code<<=size; uni_code|=l;
 704                 uni_len+=size;
 705                 if (size > 8){
 706                     uni_code<<=1; uni_code|=1;
 707                     uni_len++;
 708                 }
 709             }
 710             v2_dc_lum_table[level+256][0]= uni_code;
 711             v2_dc_lum_table[level+256][1]= uni_len;
 712
 713             /* chrominance h263 */
 714             uni_code= DCtab_chrom[size][0];
 715             uni_len = DCtab_chrom[size][1];
 716             uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
 717
 718             if (size > 0) {
 719                 uni_code<<=size; uni_code|=l;
 720                 uni_len+=size;
 721                 if (size > 8){
 722                     uni_code<<=1; uni_code|=1;
 723                     uni_len++;
 724                 }
 725             }
 726             v2_dc_chroma_table[level+256][0]= uni_code;
 727             v2_dc_chroma_table[level+256][1]= uni_len;
 728
 729         }
 730     }
 731 }
 732
 733 /* init all vlc decoding tables */
 734 int msmpeg4_decode_init_vlc(MpegEncContext *s)
 735 {
 736     int i;
 737     MVTable *mv;
 738
 739     for(i=0;i<NB_RL_TABLES;i++) {
 740         init_rl(&rl_table[i]);
 741         init_vlc_rl(&rl_table[i]);
 742     }
 743     for(i=0;i<2;i++) {
 744         mv = &mv_tables[i];
 745         init_vlc(&mv->vlc, 9, mv->n + 1,
 746                  mv->table_mv_bits, 1, 1,
 747                  mv->table_mv_code, 2, 2);
 748     }
 749
 750     init_vlc(&dc_lum_vlc[0], 9, 120,
 751              &table0_dc_lum[0][1], 8, 4,
 752              &table0_dc_lum[0][0], 8, 4);
 753     init_vlc(&dc_chroma_vlc[0], 9, 120,
 754              &table0_dc_chroma[0][1], 8, 4,
 755              &table0_dc_chroma[0][0], 8, 4);
 756     init_vlc(&dc_lum_vlc[1], 9, 120,
 757              &table1_dc_lum[0][1], 8, 4,
 758              &table1_dc_lum[0][0], 8, 4);
 759     init_vlc(&dc_chroma_vlc[1], 9, 120,
 760              &table1_dc_chroma[0][1], 8, 4,
 761              &table1_dc_chroma[0][0], 8, 4);
 762
 763     init_h263_dc_for_msmpeg4();
 764     init_vlc(&v2_dc_lum_vlc, 9, 512,
 765              &v2_dc_lum_table[0][1], 8, 4,
 766              &v2_dc_lum_table[0][0], 8, 4);
 767     init_vlc(&v2_dc_chroma_vlc, 9, 512,
 768              &v2_dc_chroma_table[0][1], 8, 4,
 769              &v2_dc_chroma_table[0][0], 8, 4);
 770
 771     init_vlc(&cbpy_vlc, 6, 16,
 772              &cbpy_tab[0][1], 2, 1,
 773              &cbpy_tab[0][0], 2, 1);
 774     init_vlc(&v2_intra_cbpc_vlc, 3, 4,
 775              &v2_intra_cbpc[0][1], 2, 1,
 776              &v2_intra_cbpc[0][0], 2, 1);
 777     init_vlc(&v2_mb_type_vlc, 5, 8,
 778              &v2_mb_type[0][1], 2, 1,
 779              &v2_mb_type[0][0], 2, 1);
 780     init_vlc(&v2_mv_vlc, 9, 33,
 781              &mvtab[0][1], 2, 1,
 782              &mvtab[0][0], 2, 1);
 783
 784     init_vlc(&mb_non_intra_vlc, 9, 128,
 785              &table_mb_non_intra[0][1], 8, 4,
 786              &table_mb_non_intra[0][0], 8, 4);
 787     init_vlc(&mb_intra_vlc, 9, 64,
 788              &table_mb_intra[0][1], 4, 2,
 789              &table_mb_intra[0][0], 4, 2);
 790     return 0;
 791 }
 792
 793 static int decode012(GetBitContext *gb)
 794 {
 795     int n;
 796     n = get_bits1(gb);
 797     if (n == 0)
 798         return 0;
 799     else
 800         return get_bits1(gb) + 1;
 801 }
 802
 803 int msmpeg4_decode_picture_header(MpegEncContext * s)
 804 {
 805     int code;
 806
 807     s->pict_type = get_bits(&s->gb, 2) + 1;
 808     if (s->pict_type != I_TYPE &&
 809         s->pict_type != P_TYPE)
 810         return -1;
 811
 812     s->qscale = get_bits(&s->gb, 5);
 813
 814     if (s->pict_type == I_TYPE) {
 815         code = get_bits(&s->gb, 5);
 816         /* 0x17: one slice, 0x18: two slices */
 817         if (code < 0x17)
 818             return -1;
 819         s->slice_height = s->mb_height / (code - 0x16);
 820         if(s->msmpeg4_version==2){
 821             s->rl_chroma_table_index = 2;
 822             s->rl_table_index = 2;
 823
 824             s->dc_table_index = 0; //not used
 825         }else{
 826             s->rl_chroma_table_index = decode012(&s->gb);
 827             s->rl_table_index = decode012(&s->gb);
 828
 829             s->dc_table_index = get_bits1(&s->gb);
 830         }
 831         s->no_rounding = 1;
 832 /*      printf(" %d %d %d %d     \n",
 833                 s->qscale,
 834                 s->rl_chroma_table_index,
 835                 s->rl_table_index,
 836                 s->dc_table_index);*/
 837     } else {
 838         s->use_skip_mb_code = get_bits1(&s->gb);
 839
 840         if(s->msmpeg4_version==2){
 841             s->rl_table_index = 2;
 842             s->rl_chroma_table_index = s->rl_table_index;
 843
 844             s->dc_table_index = 0; //not used
 845
 846             s->mv_table_index = 0;
 847         }else{
 848             s->rl_table_index = decode012(&s->gb);
 849             s->rl_chroma_table_index = s->rl_table_index;
 850
 851             s->dc_table_index = get_bits1(&s->gb);
 852
 853             s->mv_table_index = get_bits1(&s->gb);
 854         }
 855 /*      printf(" %d %d %d %d %d     \n",
 856                 s->use_skip_mb_code,
 857                 s->rl_table_index,
 858                 s->rl_chroma_table_index,
 859                 s->dc_table_index,
 860                 s->mv_table_index);*/
 861         if(s->flipflop_rounding){
 862             s->no_rounding ^= 1;
 863         }else{
 864             s->no_rounding = 0;
 865         }
 866 //      printf("%d", s->no_rounding);
 867     }
 868
 869 #if 0
 870 if(s->msmpeg4_version==2)
 871 {
 872 int i;
 873 for(i=0; i<s->gb.size*8; i++)
 874 //    printf("%d", get_bits1(&s->gb));
 875     get_bits1(&s->gb);
 876 printf("END\n");
 877 return -1;
 878 }
 879 #endif
 880
 881 #ifdef DEBUG
 882     printf("*****frame %d:\n", frame_count++);
 883 #endif
 884     return 0;
 885 }
 886
 887 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
 888 {
 889     /* the alt_bitstream reader could read over the end so we need to check it */
 890     if(get_bits_count(&s->gb) + 16 < buf_size*8)
 891     {
 892         int fps;
 893
 894         fps= get_bits(&s->gb, 5);
 895         s->bitrate= get_bits(&s->gb, 11);
 896         s->flipflop_rounding= get_bits1(&s->gb);
 897
 898 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bitrate, s->flipflop_rounding);
 899     }
 900     else
 901     {
 902         s->flipflop_rounding= 0;
 903         s->bitrate= 0;
 904     }
 905
 906     return 0;
 907 }
 908
 909 static inline void memsetw(short *tab, int val, int n)
 910 {
 911     int i;
 912     for(i=0;i<n;i++)
 913         tab[i] = val;
 914 }
 915
 916 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
 917 {
 918     int range, bit_size, sign, code, bits;
 919
 920     if (val == 0) {
 921         /* zero vector */
 922         code = 0;
 923         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
 924     } else {
 925         bit_size = s->f_code - 1;
 926         range = 1 << bit_size;
 927         if (val <= -64)
 928             val += 64;
 929         else if (val >= 64)
 930             val -= 64;
 931
 932         if (val >= 0) {
 933             sign = 0;
 934         } else {
 935             val = -val;
 936             sign = 1;
 937         }
 938         val--;
 939         code = (val >> bit_size) + 1;
 940         bits = val & (range - 1);
 941
 942         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
 943         if (bit_size > 0) {
 944             put_bits(&s->pb, bit_size, bits);
 945         }
 946     }
 947 }
 948
 949 /* this is identical to h263 except that its range is multiplied by 2 */
 950 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
 951 {
 952     int code, val, sign, shift;
 953
 954     code = get_vlc(&s->gb, &v2_mv_vlc);
 955     if (code < 0)
 956         return 0xffff;
 957
 958     if (code == 0)
 959         return pred;
 960     sign = get_bits1(&s->gb);
 961     shift = f_code - 1;
 962     val = (code - 1) << shift;
 963     if (shift > 0)
 964         val |= get_bits(&s->gb, shift);
 965     val++;
 966     if (sign)
 967         val = -val;
 968     val += pred;
 969
 970     if (val <= -64)
 971         val += 64;
 972     else if (val >= 64)
 973         val -= 64;
 974
 975     return val;
 976 }
 977
 978
 979 int msmpeg4v2_decode_mb(MpegEncContext *s,
 980                       DCTELEM block[6][64])
 981 {
 982     int cbp, code, i;
 983     if (s->pict_type == P_TYPE) {
 984         if (s->use_skip_mb_code) {
 985             if (get_bits1(&s->gb)) {
 986                 /* skip mb */
 987                 s->mb_intra = 0;
 988                 for(i=0;i<6;i++)
 989                     s->block_last_index[i] = -1;
 990                 s->mv_dir = MV_DIR_FORWARD;
 991                 s->mv_type = MV_TYPE_16X16;
 992                 s->mv[0][0][0] = 0;
 993                 s->mv[0][0][1] = 0;
 994                 s->mb_skiped = 1;
 995                 return 0;
 996             }
 997         }
 998
 999         code = get_vlc(&s->gb, &v2_mb_type_vlc);
1000         s->mb_intra = code >>2;
1001
1002         cbp = code & 0x3;
1003     } else {
1004         s->mb_intra = 1;
1005         cbp= get_vlc(&s->gb, &v2_intra_cbpc_vlc);
1006     }
1007
1008     if (!s->mb_intra) {
1009         int mx, my;
1010
1011         cbp|= get_vlc(&s->gb, &cbpy_vlc)<<2;
1012         if((cbp&3) != 3) cbp^= 0x3C;
1013
1014         h263_pred_motion(s, 0, &mx, &my);
1015         mx= msmpeg4v2_decode_motion(s, mx, 1);
1016         my= msmpeg4v2_decode_motion(s, my, 1);
1017
1018         s->mv_dir = MV_DIR_FORWARD;
1019         s->mv_type = MV_TYPE_16X16;
1020         s->mv[0][0][0] = mx;
1021         s->mv[0][0][1] = my;
1022     } else {
1023         s->ac_pred = get_bits1(&s->gb);
1024         cbp|= get_vlc(&s->gb, &cbpy_vlc)<<2;
1025     }
1026
1027     for (i = 0; i < 6; i++) {
1028         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1029         {
1030              fprintf(stderr,"\nIgnoring error while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1031              return -1;
1032         }
1033     }
1034     return 0;
1035 }
1036
1037 int msmpeg4_decode_mb(MpegEncContext *s,
1038                       DCTELEM block[6][64])
1039 {
1040     int cbp, code, i;
1041     UINT8 *coded_val;
1042
1043     /* special slice handling */
1044     if (s->mb_x == 0) {
1045         if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
1046             int wrap;
1047             /* reset DC pred (set previous line to 1024) */
1048             wrap = 2 * s->mb_width + 2;
1049             memsetw(&s->dc_val[0][(1) + (2 * s->mb_y) * wrap],
1050                     1024, 2 * s->mb_width);
1051             wrap = s->mb_width + 2;
1052             memsetw(&s->dc_val[1][(1) + (s->mb_y) * wrap],
1053                     1024, s->mb_width);
1054             memsetw(&s->dc_val[2][(1) + (s->mb_y) * wrap],
1055                     1024, s->mb_width);
1056
1057             /* reset AC pred (set previous line to 0) */
1058             wrap = s->mb_width * 2 + 2;
1059             memsetw(s->ac_val[0][0] + (1 + (2 * s->mb_y) * wrap)*16,
1060                     0, 2 * s->mb_width*16);
1061             wrap = s->mb_width + 2;
1062             memsetw(s->ac_val[1][0] + (1 + (s->mb_y) * wrap)*16,
1063                     0, s->mb_width*16);
1064             memsetw(s->ac_val[2][0] + (1 + (s->mb_y) * wrap)*16,
1065                     0, s->mb_width*16);
1066
1067             s->first_slice_line = 1;
1068         } else {
1069             s->first_slice_line = 0;
1070         }
1071     }
1072
1073     if(s->msmpeg4_version==2) return msmpeg4v2_decode_mb(s, block); //FIXME merge if possible
1074
1075     if (s->pict_type == P_TYPE) {
1076         set_stat(ST_INTER_MB);
1077         if (s->use_skip_mb_code) {
1078             if (get_bits1(&s->gb)) {
1079                 /* skip mb */
1080                 s->mb_intra = 0;
1081                 for(i=0;i<6;i++)
1082                     s->block_last_index[i] = -1;
1083                 s->mv_dir = MV_DIR_FORWARD;
1084                 s->mv_type = MV_TYPE_16X16;
1085                 s->mv[0][0][0] = 0;
1086                 s->mv[0][0][1] = 0;
1087                 s->mb_skiped = 1;
1088                 return 0;
1089             }
1090         }
1091
1092         code = get_vlc(&s->gb, &mb_non_intra_vlc);
1093         if (code < 0)
1094             return -1;
1095         //s->mb_intra = (code & 0x40) ? 0 : 1;
1096         s->mb_intra = (~code & 0x40) >> 6;
1097
1098         cbp = code & 0x3f;
1099     } else {
1100         set_stat(ST_INTRA_MB);
1101         s->mb_intra = 1;
1102         code = get_vlc(&s->gb, &mb_intra_vlc);
1103         if (code < 0)
1104             return -1;
1105         /* predict coded block pattern */
1106         cbp = 0;
1107         for(i=0;i<6;i++) {
1108             int val = ((code >> (5 - i)) & 1);
1109             if (i < 4) {
1110                 int pred = coded_block_pred(s, i, &coded_val);
1111                 val = val ^ pred;
1112                 *coded_val = val;
1113             }
1114             cbp |= val << (5 - i);
1115         }
1116     }
1117
1118     if (!s->mb_intra) {
1119         int mx, my;
1120         set_stat(ST_MV);
1121         h263_pred_motion(s, 0, &mx, &my);
1122         if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1123             return -1;
1124         s->mv_dir = MV_DIR_FORWARD;
1125         s->mv_type = MV_TYPE_16X16;
1126         s->mv[0][0][0] = mx;
1127         s->mv[0][0][1] = my;
1128     } else {
1129         set_stat(ST_INTRA_MB);
1130         s->ac_pred = get_bits1(&s->gb);
1131     }
1132
1133     for (i = 0; i < 6; i++) {
1134         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1135         {
1136             fprintf(stderr,"\nIgnoring error while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1137             // return -1;
1138         }
1139     }
1140     return 0;
1141 }
1142
1143 static int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1144                               int n, int coded)
1145 {
1146     int code, level, i, j, last, run, run_diff;
1147     int dc_pred_dir;
1148     RLTable *rl;
1149     const UINT8 *scan_table;
1150     int qmul, qadd;
1151
1152     if (s->mb_intra) {
1153         qmul=1;
1154         qadd=0;
1155
1156         /* DC coef */
1157         set_stat(ST_DC);
1158         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1159         if (level < 0)
1160             return -1;
1161         block[0] = level;
1162         if (n < 4) {
1163             rl = &rl_table[s->rl_table_index];
1164         } else {
1165             rl = &rl_table[3 + s->rl_chroma_table_index];
1166         }
1167
1168         run_diff = 0;
1169         i = 1;
1170         if (!coded) {
1171             goto not_coded;
1172         }
1173         if (s->ac_pred) {
1174             if (dc_pred_dir == 0)
1175                 scan_table = ff_alternate_vertical_scan; /* left */
1176             else
1177                 scan_table = ff_alternate_horizontal_scan; /* top */
1178         } else {
1179             scan_table = zigzag_direct;
1180         }
1181         set_stat(ST_INTRA_AC);
1182     } else {
1183         qmul = s->qscale << 1;
1184         qadd = (s->qscale - 1) | 1;
1185         i = 0;
1186         rl = &rl_table[3 + s->rl_table_index];
1187
1188         if(s->msmpeg4_version==2)
1189             run_diff = 0;
1190         else
1191             run_diff = 1;
1192
1193         if (!coded) {
1194             s->block_last_index[n] = i - 1;
1195             return 0;
1196         }
1197         scan_table = zigzag_direct;
1198         set_stat(ST_INTER_AC);
1199     }
1200
1201     for(;;) {
1202         code = get_vlc(&s->gb, &rl->vlc);
1203         if (code < 0)
1204             return -1;
1205         if (code == rl->n) {
1206             /* escape */
1207             if (get_bits1(&s->gb) == 0) {
1208                 if (get_bits1(&s->gb) == 0) {
1209                     /* third escape */
1210                     last = get_bits1(&s->gb);
1211                     run = get_bits(&s->gb, 6);
1212                     level = get_bits(&s->gb, 8);
1213                     level = (level << 24) >> 24; /* sign extend */
1214                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1215                     if (level>0) level= level * qmul + qadd;
1216                     else        level= level * qmul - qadd;
1217                 } else {
1218                     /* second escape */
1219                     code = get_vlc(&s->gb, &rl->vlc);
1220                     if (code < 0 || code >= rl->n)
1221                         return -1;
1222                     run = rl->table_run[code];
1223                     level = rl->table_level[code];
1224                     last = code >= rl->last;
1225                     run += rl->max_run[last][level] + run_diff;
1226                     level= level * qmul + qadd;
1227                     if (get_bits1(&s->gb))
1228                         level = -level;
1229                 }
1230             } else {
1231                 /* first escape */
1232                 code = get_vlc(&s->gb, &rl->vlc);
1233                 if (code < 0 || code >= rl->n)
1234                     return -1;
1235                 run = rl->table_run[code];
1236                 level = rl->table_level[code];
1237                 last = code >= rl->last;
1238                 level += rl->max_level[last][run];
1239                 level= level * qmul + qadd;
1240                 if (get_bits1(&s->gb))
1241                     level = -level;
1242             }
1243         } else {
1244             run = rl->table_run[code];
1245             level = rl->table_level[code] * qmul + qadd;
1246             last = code >= rl->last;
1247             if (get_bits1(&s->gb))
1248                 level = -level;
1249         }
1250         i += run;
1251         if (i >= 64)
1252             return -1;
1253         j = scan_table[i];
1254         block[j] = level;
1255         i++;
1256         if (last)
1257             break;
1258     }
1259  not_coded:
1260     if (s->mb_intra) {
1261         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1262         if (s->ac_pred) {
1263             i = 64; /* XXX: not optimal */
1264         }
1265     }
1266     s->block_last_index[n] = i - 1;
1267
1268     return 0;
1269 }
1270
1271 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1272 {
1273     int level, pred;
1274     INT16 *dc_val;
1275
1276     if(s->msmpeg4_version==2){
1277         if (n < 4) {
1278             level = get_vlc(&s->gb, &v2_dc_lum_vlc);
1279         } else {
1280             level = get_vlc(&s->gb, &v2_dc_chroma_vlc);
1281         }
1282         if (level < 0)
1283             return -1;
1284         level-=256;
1285     }else{  //FIXME optimize use unified tables & index
1286         if (n < 4) {
1287             level = get_vlc(&s->gb, &dc_lum_vlc[s->dc_table_index]);
1288         } else {
1289             level = get_vlc(&s->gb, &dc_chroma_vlc[s->dc_table_index]);
1290         }
1291         if (level < 0)
1292             return -1;
1293
1294         if (level == DC_MAX) {
1295             level = get_bits(&s->gb, 8);
1296             if (get_bits1(&s->gb))
1297                 level = -level;
1298         } else if (level != 0) {
1299             if (get_bits1(&s->gb))
1300                 level = -level;
1301         }
1302     }
1303
1304     pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1305     level += pred;
1306
1307     /* update predictor */
1308     if (n < 4) {
1309         *dc_val = level * s->y_dc_scale;
1310     } else {
1311         *dc_val = level * s->c_dc_scale;
1312     }
1313
1314     return level;
1315 }
1316
1317 static int msmpeg4_decode_motion(MpegEncContext * s,
1318                                  int *mx_ptr, int *my_ptr)
1319 {
1320     MVTable *mv;
1321     int code, mx, my;
1322
1323     mv = &mv_tables[s->mv_table_index];
1324
1325     code = get_vlc(&s->gb, &mv->vlc);
1326     if (code < 0)
1327         return -1;
1328     if (code == mv->n) {
1329         mx = get_bits(&s->gb, 6);
1330         my = get_bits(&s->gb, 6);
1331     } else {
1332         mx = mv->table_mvx[code];
1333         my = mv->table_mvy[code];
1334     }
1335
1336     mx += *mx_ptr - 32;
1337     my += *my_ptr - 32;
1338     /* WARNING : they do not do exactly modulo encoding */
1339     if (mx <= -64)
1340         mx += 64;
1341     else if (mx >= 64)
1342         mx -= 64;
1343
1344     if (my <= -64)
1345         my += 64;
1346     else if (my >= 64)
1347         my -= 64;
1348     *mx_ptr = mx;
1349     *my_ptr = my;
1350     return 0;
1351 }