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

   1 /*
   2  * H263/MPEG4 backend for ffmpeg encoder and decoder
   3  * Copyright (c) 2000,2001 Gerard Lantau.
   4  * H263+ support.
   5  * Copyright (c) 2001 Juan J. Sierralta P.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  * ac prediction encoding by Michael Niedermayer <michaelni@gmx.at>
  22  */
  23 #include "common.h"
  24 #include "dsputil.h"
  25 #include "avcodec.h"
  26 #include "mpegvideo.h"
  27 #include "h263data.h"
  28 #include "mpeg4data.h"
  29
  30 //rounded divison & shift
  31 #define RDIV(a,b) ((a) > 0 ? ((a)+((b)>>1))/(b) : ((a)-((b)>>1))/(b))
  32 #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
  33 #define ABS(a) (((a)>=0)?(a):(-(a)))
  34
  35 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
  36                               int n);
  37 static void h263_encode_motion(MpegEncContext * s, int val);
  38 static void h263p_encode_umotion(MpegEncContext * s, int val);
  39 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
  40                                int n, int dc, UINT8 *scan_table);
  41 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
  42 static int h263p_decode_umotion(MpegEncContext * s, int pred);
  43 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
  44                              int n, int coded);
  45 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
  46                               int n, int coded);
  47 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
  48 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
  49                               int dir);
  50 extern UINT32 inverse[256];
  51
  52 static UINT16 mv_penalty[MAX_FCODE][MAX_MV*2+1];
  53 static UINT8 fcode_tab[MAX_MV*2+1];
  54
  55 int h263_get_picture_format(int width, int height)
  56 {
  57     int format;
  58
  59     if (width == 128 && height == 96)
  60         format = 1;
  61     else if (width == 176 && height == 144)
  62         format = 2;
  63     else if (width == 352 && height == 288)
  64         format = 3;
  65     else if (width == 704 && height == 576)
  66         format = 4;
  67     else if (width == 1408 && height == 1152)
  68         format = 5;
  69     else
  70         format = 7;
  71     return format;
  72 }
  73
  74 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
  75 {
  76     int format;
  77
  78     align_put_bits(&s->pb);
  79
  80     /* Update the pointer to last GOB */
  81     s->ptr_lastgob = pbBufPtr(&s->pb);
  82     s->gob_number = 0;
  83
  84     put_bits(&s->pb, 22, 0x20); /* PSC */
  85     put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
  86                          s->frame_rate) & 0xff);
  87
  88     put_bits(&s->pb, 1, 1);     /* marker */
  89     put_bits(&s->pb, 1, 0);     /* h263 id */
  90     put_bits(&s->pb, 1, 0);     /* split screen off */
  91     put_bits(&s->pb, 1, 0);     /* camera  off */
  92     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
  93
  94     format = h263_get_picture_format(s->width, s->height);
  95     if (!s->h263_plus) {
  96         /* H.263v1 */
  97         put_bits(&s->pb, 3, format);
  98         put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
  99         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
 100         of H.263v1 UMV implies to check the predicted MV after
 101         calculation of the current MB to see if we're on the limits */
 102         put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
 103         put_bits(&s->pb, 1, 0); /* SAC: off */
 104         put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
 105         put_bits(&s->pb, 1, 0); /* not PB frame */
 106         put_bits(&s->pb, 5, s->qscale);
 107         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
 108     } else {
 109         /* H.263v2 */
 110         /* H.263 Plus PTYPE */
 111         put_bits(&s->pb, 3, 7);
 112         put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
 113         if (format == 7)
 114             put_bits(&s->pb,3,6); /* Custom Source Format */
 115         else
 116             put_bits(&s->pb, 3, format);
 117
 118         put_bits(&s->pb,1,0); /* Custom PCF: off */
 119         s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
 120         put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
 121         put_bits(&s->pb,1,0); /* SAC: off */
 122         put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
 123         put_bits(&s->pb,1,0); /* Advanced Intra Coding: off */
 124         put_bits(&s->pb,1,0); /* Deblocking Filter: off */
 125         put_bits(&s->pb,1,0); /* Slice Structured: off */
 126         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
 127         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
 128         put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
 129         put_bits(&s->pb,1,0); /* Modified Quantization: off */
 130         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 131         put_bits(&s->pb,3,0); /* Reserved */
 132
 133         put_bits(&s->pb, 3, s->pict_type == P_TYPE);
 134
 135         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
 136         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
 137         put_bits(&s->pb,1,0); /* Rounding Type */
 138         put_bits(&s->pb,2,0); /* Reserved */
 139         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 140
 141         /* This should be here if PLUSPTYPE */
 142         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
 143
 144                 if (format == 7) {
 145             /* Custom Picture Format (CPFMT) */
 146
 147             put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
 148             put_bits(&s->pb,9,(s->width >> 2) - 1);
 149             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 150             put_bits(&s->pb,9,(s->height >> 2));
 151         }
 152
 153         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
 154         if (s->umvplus)
 155             put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
 156         put_bits(&s->pb, 5, s->qscale);
 157     }
 158
 159     put_bits(&s->pb, 1, 0);     /* no PEI */
 160 }
 161
 162 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
 163 {
 164     int pdif=0;
 165
 166     /* Check to see if we need to put a new GBSC */
 167     /* for RTP packetization                    */
 168     if (s->rtp_mode) {
 169         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
 170         if (pdif >= s->rtp_payload_size) {
 171             /* Bad luck, packet must be cut before */
 172             align_put_bits(&s->pb);
 173             flush_put_bits(&s->pb);
 174             /* Call the RTP callback to send the last GOB */
 175             if (s->rtp_callback) {
 176                 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
 177                 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
 178             }
 179             s->ptr_lastgob = pbBufPtr(&s->pb);
 180             put_bits(&s->pb, 17, 1); /* GBSC */
 181             s->gob_number = mb_line / s->gob_index;
 182             put_bits(&s->pb, 5, s->gob_number); /* GN */
 183             put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
 184             put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 185             //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
 186             return pdif;
 187        } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
 188            /* Cut the packet before we can't */
 189            align_put_bits(&s->pb);
 190            flush_put_bits(&s->pb);
 191            /* Call the RTP callback to send the last GOB */
 192            if (s->rtp_callback) {
 193                pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
 194                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
 195            }
 196            s->ptr_lastgob = pbBufPtr(&s->pb);
 197            put_bits(&s->pb, 17, 1); /* GBSC */
 198            s->gob_number = mb_line / s->gob_index;
 199            put_bits(&s->pb, 5, s->gob_number); /* GN */
 200            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
 201            put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 202            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
 203            return pdif;
 204        }
 205    }
 206    return 0;
 207 }
 208
 209 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
 210 {
 211     int score0=0, score1=0;
 212     int i, n;
 213
 214     for(n=0; n<6; n++){
 215         INT16 *ac_val, *ac_val1;
 216
 217         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
 218         ac_val1= ac_val;
 219         if(dir[n]){
 220             ac_val-= s->block_wrap[n]*16;
 221             for(i=1; i<8; i++){
 222                 const int level= block[n][block_permute_op(i   )];
 223                 score0+= ABS(level);
 224                 score1+= ABS(level - ac_val[i+8]);
 225                 ac_val1[i  ]=    block[n][block_permute_op(i<<3)];
 226                 ac_val1[i+8]= level;
 227             }
 228         }else{
 229             ac_val-= 16;
 230             for(i=1; i<8; i++){
 231                 const int level= block[n][block_permute_op(i<<3)];
 232                 score0+= ABS(level);
 233                 score1+= ABS(level - ac_val[i]);
 234                 ac_val1[i  ]= level;
 235                 ac_val1[i+8]=    block[n][block_permute_op(i   )];
 236             }
 237         }
 238     }
 239
 240     return score0 > score1 ? 1 : 0;
 241 }
 242
 243 void mpeg4_encode_mb(MpegEncContext * s,
 244                     DCTELEM block[6][64],
 245                     int motion_x, int motion_y)
 246 {
 247     int cbpc, cbpy, i, cbp, pred_x, pred_y;
 248
 249     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 250     if (!s->mb_intra) {
 251         /* compute cbp */
 252         cbp = 0;
 253         for (i = 0; i < 6; i++) {
 254         if (s->block_last_index[i] >= 0)
 255             cbp |= 1 << (5 - i);
 256         }
 257         if ((cbp | motion_x | motion_y) == 0) {
 258             /* skip macroblock */
 259             put_bits(&s->pb, 1, 1);
 260             return;
 261         }
 262         put_bits(&s->pb, 1, 0); /* mb coded */
 263         cbpc = cbp & 3;
 264         put_bits(&s->pb,
 265                 inter_MCBPC_bits[cbpc],
 266                 inter_MCBPC_code[cbpc]);
 267         cbpy = cbp >> 2;
 268         cbpy ^= 0xf;
 269         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 270
 271         /* motion vectors: 16x16 mode only now */
 272         h263_pred_motion(s, 0, &pred_x, &pred_y);
 273
 274         h263_encode_motion(s, motion_x - pred_x);
 275         h263_encode_motion(s, motion_y - pred_y);
 276
 277         /* encode each block */
 278         for (i = 0; i < 6; i++) {
 279             mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);
 280         }
 281     } else {
 282         int dc_diff[6];   //dc values with the dc prediction subtracted
 283         int dir[6];  //prediction direction
 284         int zigzag_last_index[6];
 285         UINT8 *scan_table[6];
 286
 287         for(i=0; i<6; i++){
 288             const int level= block[i][0];
 289             UINT16 *dc_ptr;
 290
 291             dc_diff[i]= level - mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
 292             if (i < 4) {
 293                 *dc_ptr = level * s->y_dc_scale;
 294             } else {
 295                 *dc_ptr = level * s->c_dc_scale;
 296             }
 297         }
 298
 299         s->ac_pred= decide_ac_pred(s, block, dir);
 300
 301         if(s->ac_pred){
 302             for(i=0; i<6; i++){
 303                 UINT8 *st;
 304                 int last_index;
 305
 306                 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
 307                 if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
 308                 else           st = ff_alternate_horizontal_scan; /* top */
 309
 310                 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
 311                     if(block[i][st[last_index]]) break;
 312                 zigzag_last_index[i]= s->block_last_index[i];
 313                 s->block_last_index[i]= last_index;
 314                 scan_table[i]= st;
 315             }
 316         }else{
 317             for(i=0; i<6; i++)
 318                 scan_table[i]= zigzag_direct;
 319         }
 320
 321         /* compute cbp */
 322         cbp = 0;
 323         for (i = 0; i < 6; i++) {
 324             if (s->block_last_index[i] >= 1)
 325                 cbp |= 1 << (5 - i);
 326         }
 327
 328         cbpc = cbp & 3;
 329         if (s->pict_type == I_TYPE) {
 330             put_bits(&s->pb,
 331                 intra_MCBPC_bits[cbpc],
 332                 intra_MCBPC_code[cbpc]);
 333         } else {
 334             put_bits(&s->pb, 1, 0);     /* mb coded */
 335             put_bits(&s->pb,
 336                 inter_MCBPC_bits[cbpc + 4],
 337                 inter_MCBPC_code[cbpc + 4]);
 338         }
 339         put_bits(&s->pb, 1, s->ac_pred);
 340         cbpy = cbp >> 2;
 341         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 342
 343         /* encode each block */
 344         for (i = 0; i < 6; i++) {
 345             mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i]);
 346         }
 347
 348         /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
 349         if(s->ac_pred){
 350             for(i=0; i<6; i++){
 351                 int j;
 352                 INT16 *ac_val;
 353
 354                 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
 355
 356                 if(dir[i]){
 357                     for(j=1; j<8; j++)
 358                         block[i][block_permute_op(j   )]= ac_val[j+8];
 359                 }else{
 360                     for(j=1; j<8; j++)
 361                         block[i][block_permute_op(j<<3)]= ac_val[j  ];
 362                 }
 363                 s->block_last_index[i]= zigzag_last_index[i];
 364             }
 365         }
 366     }
 367 }
 368
 369 void h263_encode_mb(MpegEncContext * s,
 370                     DCTELEM block[6][64],
 371                     int motion_x, int motion_y)
 372 {
 373     int cbpc, cbpy, i, cbp, pred_x, pred_y;
 374
 375     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 376    if (!s->mb_intra) {
 377            /* compute cbp */
 378            cbp = 0;
 379            for (i = 0; i < 6; i++) {
 380               if (s->block_last_index[i] >= 0)
 381                    cbp |= 1 << (5 - i);
 382            }
 383            if ((cbp | motion_x | motion_y) == 0) {
 384               /* skip macroblock */
 385               put_bits(&s->pb, 1, 1);
 386               return;
 387            }
 388            put_bits(&s->pb, 1, 0);      /* mb coded */
 389            cbpc = cbp & 3;
 390            put_bits(&s->pb,
 391                 inter_MCBPC_bits[cbpc],
 392                 inter_MCBPC_code[cbpc]);
 393            cbpy = cbp >> 2;
 394            cbpy ^= 0xf;
 395            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 396
 397            /* motion vectors: 16x16 mode only now */
 398       h263_pred_motion(s, 0, &pred_x, &pred_y);
 399
 400       if (!s->umvplus) {
 401          h263_encode_motion(s, motion_x - pred_x);
 402          h263_encode_motion(s, motion_y - pred_y);
 403       }
 404       else {
 405          h263p_encode_umotion(s, motion_x - pred_x);
 406          h263p_encode_umotion(s, motion_y - pred_y);
 407          if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 408             /* To prevent Start Code emulation */
 409             put_bits(&s->pb,1,1);
 410       }
 411    } else {
 412         /* compute cbp */
 413         cbp = 0;
 414         for (i = 0; i < 6; i++) {
 415             if (s->block_last_index[i] >= 1)
 416                 cbp |= 1 << (5 - i);
 417         }
 418
 419         cbpc = cbp & 3;
 420         if (s->pict_type == I_TYPE) {
 421             put_bits(&s->pb,
 422                      intra_MCBPC_bits[cbpc],
 423                      intra_MCBPC_code[cbpc]);
 424         } else {
 425             put_bits(&s->pb, 1, 0);     /* mb coded */
 426             put_bits(&s->pb,
 427                      inter_MCBPC_bits[cbpc + 4],
 428                      inter_MCBPC_code[cbpc + 4]);
 429         }
 430         if (s->h263_pred) {
 431             /* XXX: currently, we do not try to use ac prediction */
 432             put_bits(&s->pb, 1, 0);     /* no ac prediction */
 433         }
 434         cbpy = cbp >> 2;
 435         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 436     }
 437
 438     /* encode each block */
 439     if (s->h263_pred) {
 440         for (i = 0; i < 6; i++) {
 441 //          mpeg4_encode_block(s, block[i], i);
 442         }
 443     } else {
 444         for (i = 0; i < 6; i++) {
 445             h263_encode_block(s, block[i], i);
 446         }
 447     }
 448 }
 449
 450 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
 451 {
 452     int x, y, wrap, a, c, pred_dc, scale, i;
 453     INT16 *dc_val, *ac_val, *ac_val1;
 454
 455     /* find prediction */
 456     if (n < 4) {
 457         x = 2 * s->mb_x + 1 + (n & 1);
 458         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
 459         wrap = s->mb_width * 2 + 2;
 460         dc_val = s->dc_val[0];
 461         ac_val = s->ac_val[0][0];
 462         scale = s->y_dc_scale;
 463     } else {
 464         x = s->mb_x + 1;
 465         y = s->mb_y + 1;
 466         wrap = s->mb_width + 2;
 467         dc_val = s->dc_val[n - 4 + 1];
 468         ac_val = s->ac_val[n - 4 + 1][0];
 469         scale = s->c_dc_scale;
 470     }
 471
 472     ac_val += ((y) * wrap + (x)) * 16;
 473     ac_val1 = ac_val;
 474
 475     /* B C
 476      * A X
 477      */
 478     a = dc_val[(x - 1) + (y) * wrap];
 479     c = dc_val[(x) + (y - 1) * wrap];
 480
 481     pred_dc = 1024;
 482     if (s->ac_pred) {
 483         if (s->h263_aic_dir) {
 484             /* left prediction */
 485             if (a != 1024) {
 486                 ac_val -= 16;
 487                 for(i=1;i<8;i++) {
 488                     block[block_permute_op(i*8)] += ac_val[i];
 489                 }
 490                 pred_dc = a;
 491             }
 492         } else {
 493             /* top prediction */
 494             if (c != 1024) {
 495                 ac_val -= 16 * wrap;
 496                 for(i=1;i<8;i++) {
 497                     block[block_permute_op(i)] += ac_val[i + 8];
 498                 }
 499                 pred_dc = c;
 500             }
 501         }
 502     } else {
 503         /* just DC prediction */
 504         if (a != 1024 && c != 1024)
 505             pred_dc = (a + c) >> 1;
 506         else if (a != 1024)
 507             pred_dc = a;
 508         else
 509             pred_dc = c;
 510     }
 511
 512     /* we assume pred is positive */
 513     block[0]=block[0]*scale + pred_dc;
 514
 515     if (block[0] < 0)
 516         block[0] = 0;
 517     else if (!(block[0] & 1))
 518         block[0]++;
 519
 520     /* Update AC/DC tables */
 521     dc_val[(x) + (y) * wrap] = block[0];
 522
 523     /* left copy */
 524     for(i=1;i<8;i++)
 525         ac_val1[i] = block[block_permute_op(i * 8)];
 526     /* top copy */
 527     for(i=1;i<8;i++)
 528         ac_val1[8 + i] = block[block_permute_op(i)];
 529 }
 530
 531 INT16 *h263_pred_motion(MpegEncContext * s, int block,
 532                         int *px, int *py)
 533 {
 534     int xy, wrap;
 535     INT16 *A, *B, *C, *mot_val;
 536     static const int off[4]= {2, 1, 1, -1};
 537
 538     wrap = s->block_wrap[0];
 539     xy = s->block_index[block];
 540
 541     mot_val = s->motion_val[xy];
 542
 543     /* special case for first line */
 544     if ((s->mb_y == 0 || s->first_slice_line || s->first_gob_line) && block<2) {
 545         A = s->motion_val[xy - 1];
 546         *px = A[0];
 547         *py = A[1];
 548     } else {
 549         A = s->motion_val[xy - 1];
 550         B = s->motion_val[xy - wrap];
 551         C = s->motion_val[xy + off[block] - wrap];
 552         *px = mid_pred(A[0], B[0], C[0]);
 553         *py = mid_pred(A[1], B[1], C[1]);
 554     }
 555     return mot_val;
 556 }
 557
 558 static void h263_encode_motion(MpegEncContext * s, int val)
 559 {
 560     int range, l, m, bit_size, sign, code, bits;
 561
 562     if (val == 0) {
 563         /* zero vector */
 564         code = 0;
 565         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
 566     } else {
 567         bit_size = s->f_code - 1;
 568         range = 1 << bit_size;
 569         /* modulo encoding */
 570         l = range * 32;
 571         m = 2 * l;
 572         if (val < -l) {
 573             val += m;
 574         } else if (val >= l) {
 575             val -= m;
 576         }
 577
 578         if (val >= 0) {
 579             val--;
 580             code = (val >> bit_size) + 1;
 581             bits = val & (range - 1);
 582             sign = 0;
 583         } else {
 584             val = -val;
 585             val--;
 586             code = (val >> bit_size) + 1;
 587             bits = val & (range - 1);
 588             sign = 1;
 589         }
 590
 591         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
 592         if (bit_size > 0) {
 593             put_bits(&s->pb, bit_size, bits);
 594         }
 595     }
 596 }
 597
 598 /* Encode MV differences on H.263+ with Unrestricted MV mode */
 599 static void h263p_encode_umotion(MpegEncContext * s, int val)
 600 {
 601     short sval = 0;
 602     short i = 0;
 603     short n_bits = 0;
 604     short temp_val;
 605     int code = 0;
 606     int tcode;
 607
 608     if ( val == 0)
 609         put_bits(&s->pb, 1, 1);
 610     else if (val == 1)
 611         put_bits(&s->pb, 3, 0);
 612     else if (val == -1)
 613         put_bits(&s->pb, 3, 2);
 614     else {
 615
 616         sval = ((val < 0) ? (short)(-val):(short)val);
 617         temp_val = sval;
 618
 619         while (temp_val != 0) {
 620             temp_val = temp_val >> 1;
 621             n_bits++;
 622         }
 623
 624         i = n_bits - 1;
 625         while (i > 0) {
 626             tcode = (sval & (1 << (i-1))) >> (i-1);
 627             tcode = (tcode << 1) | 1;
 628             code = (code << 2) | tcode;
 629             i--;
 630         }
 631         code = ((code << 1) | (val < 0)) << 1;
 632         put_bits(&s->pb, (2*n_bits)+1, code);
 633         //printf("\nVal = %d\tCode = %d", sval, code);
 634     }
 635 }
 636
 637 static void init_mv_penalty_and_fcode(MpegEncContext *s)
 638 {
 639     int f_code;
 640     int mv;
 641     for(f_code=1; f_code<=MAX_FCODE; f_code++){
 642         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
 643             int len;
 644
 645             if(mv==0) len= mvtab[0][1];
 646             else{
 647                 int val, bit_size, range, code;
 648
 649                 bit_size = s->f_code - 1;
 650                 range = 1 << bit_size;
 651
 652                 val=mv;
 653                 if (val < 0)
 654                     val = -val;
 655                 val--;
 656                 code = (val >> bit_size) + 1;
 657                 if(code<33){
 658                     len= mvtab[code][1] + 1 + bit_size;
 659                 }else{
 660                     len= mvtab[32][1] + 2 + bit_size;
 661                 }
 662             }
 663
 664             mv_penalty[f_code][mv+MAX_MV]= len;
 665         }
 666     }
 667
 668
 669     for(f_code=MAX_FCODE; f_code>0; f_code--){
 670         for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
 671             fcode_tab[mv+MAX_MV]= f_code;
 672         }
 673     }
 674 }
 675
 676 void h263_encode_init(MpegEncContext *s)
 677 {
 678     static int done = 0;
 679
 680     if (!done) {
 681         done = 1;
 682         init_rl(&rl_inter);
 683         init_rl(&rl_intra);
 684
 685         init_mv_penalty_and_fcode(s);
 686     }
 687     s->mv_penalty= mv_penalty;
 688
 689     // use fcodes >1 only for mpeg4 FIXME
 690     if(!s->h263_msmpeg4 && s->h263_pred) s->fcode_tab= fcode_tab;
 691 }
 692
 693 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
 694 {
 695     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
 696     int code;
 697     RLTable *rl = &rl_inter;
 698
 699     if (s->mb_intra) {
 700         /* DC coef */
 701             level = block[0];
 702         /* 255 cannot be represented, so we clamp */
 703         if (level > 254) {
 704             level = 254;
 705             block[0] = 254;
 706         }
 707         /* 0 cannot be represented also */
 708         else if (!level) {
 709             level = 1;
 710             block[0] = 1;
 711         }
 712             if (level == 128)
 713                 put_bits(&s->pb, 8, 0xff);
 714             else
 715                 put_bits(&s->pb, 8, level & 0xff);
 716             i = 1;
 717     } else {
 718             i = 0;
 719     }
 720
 721     /* AC coefs */
 722     last_index = s->block_last_index[n];
 723     last_non_zero = i - 1;
 724     for (; i <= last_index; i++) {
 725         j = zigzag_direct[i];
 726         level = block[j];
 727         if (level) {
 728             run = i - last_non_zero - 1;
 729             last = (i == last_index);
 730             sign = 0;
 731             slevel = level;
 732             if (level < 0) {
 733                 sign = 1;
 734                 level = -level;
 735             }
 736             code = get_rl_index(rl, last, run, level);
 737             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 738             if (code == rl->n) {
 739                 put_bits(&s->pb, 1, last);
 740                 put_bits(&s->pb, 6, run);
 741                 put_bits(&s->pb, 8, slevel & 0xff);
 742             } else {
 743                 put_bits(&s->pb, 1, sign);
 744             }
 745             last_non_zero = i;
 746         }
 747     }
 748 }
 749
 750 /***************************************************/
 751
 752 static void mpeg4_stuffing(PutBitContext * pbc)
 753 {
 754     int length;
 755     put_bits(pbc, 1, 0);
 756     length= (-get_bit_count(pbc))&7;
 757     put_bits(pbc, length, (1<<length)-1);
 758 }
 759
 760 static void put_string(PutBitContext * pbc, char *s)
 761 {
 762     while(*s){
 763         put_bits(pbc, 8, *s);
 764         s++;
 765     }
 766     put_bits(pbc, 8, 0);
 767 }
 768
 769 static void mpeg4_encode_vol_header(MpegEncContext * s)
 770 {
 771     int vo_ver_id=1; //must be 2 if we want GMC or q-pel
 772
 773     if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
 774     put_bits(&s->pb, 16, 0);
 775     put_bits(&s->pb, 16, 0x100);        /* video obj */
 776     put_bits(&s->pb, 16, 0);
 777     put_bits(&s->pb, 16, 0x120);        /* video obj layer */
 778
 779     put_bits(&s->pb, 1, 0);             /* random access vol */
 780     put_bits(&s->pb, 8, 1);             /* video obj type indication= simple obj */
 781     put_bits(&s->pb, 1, 1);             /* is obj layer id= yes */
 782       put_bits(&s->pb, 4, vo_ver_id);   /* is obj layer ver id */
 783       put_bits(&s->pb, 3, 1);           /* is obj layer priority */
 784     put_bits(&s->pb, 4, 1);             /* aspect ratio info= sqare pixel */ //FIXME real aspect
 785     put_bits(&s->pb, 1, 0);             /* vol control parameters= no */
 786     put_bits(&s->pb, 2, RECT_SHAPE);    /* vol shape= rectangle */
 787     put_bits(&s->pb, 1, 1);             /* marker bit */
 788     put_bits(&s->pb, 16, s->time_increment_resolution=30000);
 789     s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
 790     if (s->time_increment_bits < 1)
 791         s->time_increment_bits = 1;
 792     put_bits(&s->pb, 1, 1);             /* marker bit */
 793     put_bits(&s->pb, 1, 0);             /* fixed vop rate=no */
 794     put_bits(&s->pb, 1, 1);             /* marker bit */
 795     put_bits(&s->pb, 13, s->width);     /* vol width */
 796     put_bits(&s->pb, 1, 1);             /* marker bit */
 797     put_bits(&s->pb, 13, s->height);    /* vol height */
 798     put_bits(&s->pb, 1, 1);             /* marker bit */
 799     put_bits(&s->pb, 1, 0);             /* interlace */
 800     put_bits(&s->pb, 1, 1);             /* obmc disable */
 801     if (vo_ver_id == 1) {
 802         put_bits(&s->pb, 1, s->vol_sprite_usage=0);             /* sprite enable */
 803     }else{ /* vo_ver_id == 2 */
 804         put_bits(&s->pb, 2, s->vol_sprite_usage=0);             /* sprite enable */
 805     }
 806     put_bits(&s->pb, 1, 0);             /* not 8 bit */
 807     put_bits(&s->pb, 1, 0);             /* quant type= h263 style*/
 808     if (vo_ver_id != 1)
 809         put_bits(&s->pb, 1, s->quarter_sample=0);
 810     put_bits(&s->pb, 1, 1);             /* complexity estimation disable */
 811     put_bits(&s->pb, 1, 1);             /* resync marker disable */
 812     put_bits(&s->pb, 1, 0);             /* data partitioned */
 813     if (vo_ver_id != 1){
 814         put_bits(&s->pb, 1, 0);         /* newpred */
 815         put_bits(&s->pb, 1, 0);         /* reduced res vop */
 816     }
 817     put_bits(&s->pb, 1, 0);             /* scalability */
 818
 819     mpeg4_stuffing(&s->pb);
 820     put_bits(&s->pb, 16, 0);
 821     put_bits(&s->pb, 16, 0x1B2);        /* user_data */
 822     put_string(&s->pb, "ffmpeg"); //FIXME append some version ...
 823
 824     s->no_rounding = 0;
 825 }
 826
 827 /* write mpeg4 VOP header */
 828 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
 829 {
 830     if(s->pict_type==I_TYPE) mpeg4_encode_vol_header(s);
 831
 832     if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
 833     put_bits(&s->pb, 16, 0);            /* vop header */
 834     put_bits(&s->pb, 16, 0x1B6);        /* vop header */
 835     put_bits(&s->pb, 2, s->pict_type - 1);      /* pict type: I = 0 , P = 1 */
 836     /* XXX: time base + 1 not always correct */
 837     put_bits(&s->pb, 1, 1);
 838     put_bits(&s->pb, 1, 0);
 839
 840     put_bits(&s->pb, 1, 1);     /* marker */
 841     put_bits(&s->pb, s->time_increment_bits, 1);        /* XXX: correct time increment */
 842     put_bits(&s->pb, 1, 1);     /* marker */
 843     put_bits(&s->pb, 1, 1);     /* vop coded */
 844     if (    s->pict_type == P_TYPE
 845         || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
 846         s->no_rounding ^= 1;
 847         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
 848     }
 849     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
 850     //FIXME sprite stuff
 851
 852     put_bits(&s->pb, 5, s->qscale);
 853
 854     if (s->pict_type != I_TYPE)
 855         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
 856     if (s->pict_type == B_TYPE)
 857         put_bits(&s->pb, 3, s->b_code); /* fcode_back */
 858     //    printf("****frame %d\n", picture_number);
 859 }
 860
 861 void h263_dc_scale(MpegEncContext * s)
 862 {
 863 #if 1
 864     const static UINT8 y_tab[32]={
 865     //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 866         0, 8, 8, 8, 8,10,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,36,38,40,42,44,46
 867     };
 868     const static UINT8 c_tab[32]={
 869     //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 870         0, 8, 8, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,20,21,22,23,24,25
 871     };
 872     s->y_dc_scale = y_tab[s->qscale];
 873     s->c_dc_scale = c_tab[s->qscale];
 874 #else
 875     int quant;
 876     quant = s->qscale;
 877     /* luminance */
 878     if (quant < 5)
 879         s->y_dc_scale = 8;
 880     else if (quant > 4 && quant < 9)
 881         s->y_dc_scale = (2 * quant);
 882     else if (quant > 8 && quant < 25)
 883         s->y_dc_scale = (quant + 8);
 884     else
 885         s->y_dc_scale = (2 * quant - 16);
 886     /* chrominance */
 887     if (quant < 5)
 888         s->c_dc_scale = 8;
 889     else if (quant > 4 && quant < 25)
 890         s->c_dc_scale = ((quant + 13) / 2);
 891     else
 892         s->c_dc_scale = (quant - 6);
 893 #endif
 894 }
 895
 896 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
 897 {
 898     int a, b, c, wrap, pred, scale;
 899     UINT16 *dc_val;
 900     int dummy;
 901
 902     /* find prediction */
 903     if (n < 4) {
 904         scale = s->y_dc_scale;
 905     } else {
 906         scale = s->c_dc_scale;
 907     }
 908     wrap= s->block_wrap[n];
 909     dc_val = s->dc_val[0] + s->block_index[n];
 910
 911     /* B C
 912      * A X
 913      */
 914     a = dc_val[ - 1];
 915     b = dc_val[ - 1 - wrap];
 916     c = dc_val[ - wrap];
 917
 918     if (abs(a - b) < abs(b - c)) {
 919         pred = c;
 920         *dir_ptr = 1; /* top */
 921     } else {
 922         pred = a;
 923         *dir_ptr = 0; /* left */
 924     }
 925     /* we assume pred is positive */
 926 #ifdef ARCH_X86
 927         asm volatile (
 928                 "xorl %%edx, %%edx      \n\t"
 929                 "mul %%ecx              \n\t"
 930                 : "=d" (pred), "=a"(dummy)
 931                 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
 932         );
 933 #else
 934     pred = (pred + (scale >> 1)) / scale;
 935 #endif
 936
 937     /* prepare address for prediction update */
 938     *dc_val_ptr = &dc_val[0];
 939
 940     return pred;
 941 }
 942
 943 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
 944                    int dir)
 945 {
 946     int i;
 947     INT16 *ac_val, *ac_val1;
 948
 949     /* find prediction */
 950     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
 951     ac_val1 = ac_val;
 952     if (s->ac_pred) {
 953         if (dir == 0) {
 954             /* left prediction */
 955             ac_val -= 16;
 956             for(i=1;i<8;i++) {
 957                 block[block_permute_op(i*8)] += ac_val[i];
 958             }
 959         } else {
 960             /* top prediction */
 961             ac_val -= 16 * s->block_wrap[n];
 962             for(i=1;i<8;i++) {
 963                 block[block_permute_op(i)] += ac_val[i + 8];
 964             }
 965         }
 966     }
 967     /* left copy */
 968     for(i=1;i<8;i++)
 969         ac_val1[i] = block[block_permute_op(i * 8)];
 970     /* top copy */
 971     for(i=1;i<8;i++)
 972         ac_val1[8 + i] = block[block_permute_op(i)];
 973 }
 974
 975 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
 976                               int dir)
 977 {
 978     int i;
 979     INT16 *ac_val;
 980
 981     /* find prediction */
 982     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
 983
 984     if (dir == 0) {
 985         /* left prediction */
 986         ac_val -= 16;
 987         for(i=1;i<8;i++) {
 988             block[block_permute_op(i*8)] -= ac_val[i];
 989         }
 990     } else {
 991         /* top prediction */
 992         ac_val -= 16 * s->block_wrap[n];
 993         for(i=1;i<8;i++) {
 994             block[block_permute_op(i)] -= ac_val[i + 8];
 995         }
 996     }
 997 }
 998
 999
1000 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)
1001 {
1002     int size, v;
1003     /* find number of bits */
1004     size = 0;
1005     v = abs(level);
1006     while (v) {
1007         v >>= 1;
1008         size++;
1009     }
1010
1011     if (n < 4) {
1012         /* luminance */
1013         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1014     } else {
1015         /* chrominance */
1016         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1017     }
1018
1019     /* encode remaining bits */
1020     if (size > 0) {
1021         if (level < 0)
1022             level = (-level) ^ ((1 << size) - 1);
1023         put_bits(&s->pb, size, level);
1024         if (size > 8)
1025             put_bits(&s->pb, 1, 1);
1026     }
1027 }
1028
1029 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table)
1030 {
1031     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
1032     int code;
1033     const RLTable *rl;
1034
1035     if (s->mb_intra) {
1036         /* mpeg4 based DC predictor */
1037         mpeg4_encode_dc(s, intra_dc, n);
1038         i = 1;
1039         rl = &rl_intra;
1040     } else {
1041         i = 0;
1042         rl = &rl_inter;
1043     }
1044
1045     /* AC coefs */
1046     last_index = s->block_last_index[n];
1047     last_non_zero = i - 1;
1048     for (; i <= last_index; i++) {
1049         j = scan_table[i];
1050         level = block[j];
1051         if (level) {
1052             run = i - last_non_zero - 1;
1053             last = (i == last_index);
1054             sign = 0;
1055             slevel = level;
1056             if (level < 0) {
1057                 sign = 1;
1058                 level = -level;
1059             }
1060             code = get_rl_index(rl, last, run, level);
1061             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1062             if (code == rl->n) {
1063                 int level1, run1;
1064                 level1 = level - rl->max_level[last][run];
1065                 if (level1 < 1)
1066                     goto esc2;
1067                 code = get_rl_index(rl, last, run, level1);
1068                 if (code == rl->n) {
1069                 esc2:
1070                     put_bits(&s->pb, 1, 1);
1071                     if (level > MAX_LEVEL)
1072                         goto esc3;
1073                     run1 = run - rl->max_run[last][level] - 1;
1074                     if (run1 < 0)
1075                         goto esc3;
1076                     code = get_rl_index(rl, last, run1, level);
1077                     if (code == rl->n) {
1078                     esc3:
1079                         /* third escape */
1080                         put_bits(&s->pb, 1, 1);
1081                         put_bits(&s->pb, 1, last);
1082                         put_bits(&s->pb, 6, run);
1083                         put_bits(&s->pb, 1, 1);
1084                         put_bits(&s->pb, 12, slevel & 0xfff);
1085                         put_bits(&s->pb, 1, 1);
1086                     } else {
1087                         /* second escape */
1088                         put_bits(&s->pb, 1, 0);
1089                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1090                         put_bits(&s->pb, 1, sign);
1091                     }
1092                 } else {
1093                     /* first escape */
1094                     put_bits(&s->pb, 1, 0);
1095                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1096                     put_bits(&s->pb, 1, sign);
1097                 }
1098             } else {
1099                 put_bits(&s->pb, 1, sign);
1100             }
1101             last_non_zero = i;
1102         }
1103     }
1104 }
1105
1106
1107
1108 /***********************************************/
1109 /* decoding */
1110
1111 static VLC intra_MCBPC_vlc;
1112 static VLC inter_MCBPC_vlc;
1113 static VLC cbpy_vlc;
1114 static VLC mv_vlc;
1115 static VLC dc_lum, dc_chrom;
1116 static VLC sprite_trajectory;
1117 static VLC mb_type_b_vlc;
1118
1119 void init_rl(RLTable *rl)
1120 {
1121     INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1122     UINT8 index_run[MAX_RUN+1];
1123     int last, run, level, start, end, i;
1124
1125     /* compute max_level[], max_run[] and index_run[] */
1126     for(last=0;last<2;last++) {
1127         if (last == 0) {
1128             start = 0;
1129             end = rl->last;
1130         } else {
1131             start = rl->last;
1132             end = rl->n;
1133         }
1134
1135         memset(max_level, 0, MAX_RUN + 1);
1136         memset(max_run, 0, MAX_LEVEL + 1);
1137         memset(index_run, rl->n, MAX_RUN + 1);
1138         for(i=start;i<end;i++) {
1139             run = rl->table_run[i];
1140             level = rl->table_level[i];
1141             if (index_run[run] == rl->n)
1142                 index_run[run] = i;
1143             if (level > max_level[run])
1144                 max_level[run] = level;
1145             if (run > max_run[level])
1146                 max_run[level] = run;
1147         }
1148         rl->max_level[last] = malloc(MAX_RUN + 1);
1149         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1150         rl->max_run[last] = malloc(MAX_LEVEL + 1);
1151         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1152         rl->index_run[last] = malloc(MAX_RUN + 1);
1153         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1154     }
1155 }
1156
1157 void init_vlc_rl(RLTable *rl)
1158 {
1159     init_vlc(&rl->vlc, 9, rl->n + 1,
1160              &rl->table_vlc[0][1], 4, 2,
1161              &rl->table_vlc[0][0], 4, 2);
1162 }
1163
1164 /* init vlcs */
1165
1166 /* XXX: find a better solution to handle static init */
1167 void h263_decode_init_vlc(MpegEncContext *s)
1168 {
1169     static int done = 0;
1170
1171     if (!done) {
1172         done = 1;
1173
1174         init_vlc(&intra_MCBPC_vlc, 6, 8,
1175                  intra_MCBPC_bits, 1, 1,
1176                  intra_MCBPC_code, 1, 1);
1177         init_vlc(&inter_MCBPC_vlc, 9, 25,
1178                  inter_MCBPC_bits, 1, 1,
1179                  inter_MCBPC_code, 1, 1);
1180         init_vlc(&cbpy_vlc, 6, 16,
1181                  &cbpy_tab[0][1], 2, 1,
1182                  &cbpy_tab[0][0], 2, 1);
1183         init_vlc(&mv_vlc, 9, 33,
1184                  &mvtab[0][1], 2, 1,
1185                  &mvtab[0][0], 2, 1);
1186         init_rl(&rl_inter);
1187         init_rl(&rl_intra);
1188         init_rl(&rl_intra_aic);
1189         init_vlc_rl(&rl_inter);
1190         init_vlc_rl(&rl_intra);
1191         init_vlc_rl(&rl_intra_aic);
1192         init_vlc(&dc_lum, 9, 13,
1193                  &DCtab_lum[0][1], 2, 1,
1194                  &DCtab_lum[0][0], 2, 1);
1195         init_vlc(&dc_chrom, 9, 13,
1196                  &DCtab_chrom[0][1], 2, 1,
1197                  &DCtab_chrom[0][0], 2, 1);
1198         init_vlc(&sprite_trajectory, 9, 15,
1199                  &sprite_trajectory_tab[0][1], 4, 2,
1200                  &sprite_trajectory_tab[0][0], 4, 2);
1201         init_vlc(&mb_type_b_vlc, 4, 4,
1202                  &mb_type_b_tab[0][1], 2, 1,
1203                  &mb_type_b_tab[0][0], 2, 1);
1204     }
1205 }
1206
1207 int h263_decode_gob_header(MpegEncContext *s)
1208 {
1209     unsigned int val, gfid;
1210
1211     /* Check for GOB Start Code */
1212     val = show_bits(&s->gb, 16);
1213     if (val == 0) {
1214         /* We have a GBSC probably with GSTUFF */
1215         skip_bits(&s->gb, 16); /* Drop the zeros */
1216         while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1217 #ifdef DEBUG
1218         fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1219 #endif
1220         s->gob_number = get_bits(&s->gb, 5); /* GN */
1221         gfid = get_bits(&s->gb, 2); /* GFID */
1222         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1223 #ifdef DEBUG
1224         fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1225 #endif
1226         return 1;
1227     }
1228     return 0;
1229
1230 }
1231
1232 int h263_decode_mb(MpegEncContext *s,
1233                    DCTELEM block[6][64])
1234 {
1235     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1236     INT16 *mot_val;
1237     static INT8 quant_tab[4] = { -1, -2, 1, 2 };
1238
1239     if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
1240         if (get_bits1(&s->gb)) {
1241             /* skip mb */
1242             s->mb_intra = 0;
1243             for(i=0;i<6;i++)
1244                 s->block_last_index[i] = -1;
1245             s->mv_dir = MV_DIR_FORWARD;
1246             s->mv_type = MV_TYPE_16X16;
1247             if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
1248                 const int a= s->sprite_warping_accuracy;
1249 //                int l = (1 << (s->f_code - 1)) * 32;
1250
1251                 s->mcsel=1;
1252                 s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1253                 s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1254 /*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
1255                 else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
1256                 if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
1257                 else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
1258
1259                 s->mb_skiped = 0;
1260             }else{
1261                 s->mcsel=0;
1262                 s->mv[0][0][0] = 0;
1263                 s->mv[0][0][1] = 0;
1264                 s->mb_skiped = 1;
1265             }
1266             return 0;
1267         }
1268         cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
1269         //fprintf(stderr, "\tCBPC: %d", cbpc);
1270         if (cbpc < 0)
1271             return -1;
1272         if (cbpc > 20)
1273             cbpc+=3;
1274         else if (cbpc == 20)
1275             fprintf(stderr, "Stuffing !");
1276
1277         dquant = cbpc & 8;
1278         s->mb_intra = ((cbpc & 4) != 0);
1279         if (s->mb_intra) goto intra;
1280
1281         if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
1282             s->mcsel= get_bits1(&s->gb);
1283         else s->mcsel= 0;
1284         cbpy = get_vlc(&s->gb, &cbpy_vlc);
1285         cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
1286         if (dquant) {
1287             s->qscale += quant_tab[get_bits(&s->gb, 2)];
1288             if (s->qscale < 1)
1289                 s->qscale = 1;
1290             else if (s->qscale > 31)
1291                 s->qscale = 31;
1292         }
1293         s->mv_dir = MV_DIR_FORWARD;
1294         if ((cbpc & 16) == 0) {
1295             /* 16x16 motion prediction */
1296             s->mv_type = MV_TYPE_16X16;
1297             h263_pred_motion(s, 0, &pred_x, &pred_y);
1298             if (s->umvplus_dec)
1299                mx = h263p_decode_umotion(s, pred_x);
1300             else if(!s->mcsel)
1301                mx = h263_decode_motion(s, pred_x, s->f_code);
1302             else {
1303                const int a= s->sprite_warping_accuracy;
1304 //        int l = (1 << (s->f_code - 1)) * 32;
1305                mx= RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
1306 //        if (mx < -l) mx= -l;
1307 //        else if (mx >= l) mx= l-1;
1308             }
1309             if (mx >= 0xffff)
1310                 return -1;
1311
1312             if (s->umvplus_dec)
1313                my = h263p_decode_umotion(s, pred_y);
1314             else if(!s->mcsel)
1315                my = h263_decode_motion(s, pred_y, s->f_code);
1316             else{
1317                const int a= s->sprite_warping_accuracy;
1318 //       int l = (1 << (s->f_code - 1)) * 32;
1319                my= RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
1320 //       if (my < -l) my= -l;
1321 //       else if (my >= l) my= l-1;
1322             }
1323             if (my >= 0xffff)
1324                 return -1;
1325             s->mv[0][0][0] = mx;
1326             s->mv[0][0][1] = my;
1327             /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
1328             fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
1329             fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
1330             if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1331                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1332
1333         } else {
1334             s->mv_type = MV_TYPE_8X8;
1335             for(i=0;i<4;i++) {
1336                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1337                 if (s->umvplus_dec)
1338                   mx = h263p_decode_umotion(s, pred_x);
1339                 else
1340                   mx = h263_decode_motion(s, pred_x, s->f_code);
1341                 if (mx >= 0xffff)
1342                     return -1;
1343
1344                 if (s->umvplus_dec)
1345                   my = h263p_decode_umotion(s, pred_y);
1346                 else
1347                   my = h263_decode_motion(s, pred_y, s->f_code);
1348                 if (my >= 0xffff)
1349                     return -1;
1350                 s->mv[0][i][0] = mx;
1351                 s->mv[0][i][1] = my;
1352                 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1353                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1354                 mot_val[0] = mx;
1355                 mot_val[1] = my;
1356             }
1357         }
1358     } else if(s->pict_type==B_TYPE) {
1359         int modb1; // first bit of modb
1360         int modb2; // second bit of modb
1361         int mb_type;
1362         int time_pp;
1363         int time_pb;
1364         int xy;
1365
1366         s->mb_intra = 0; //B-frames never contain intra blocks
1367         s->mcsel=0;      //     ...               true gmc blocks
1368
1369         if(s->mb_x==0){
1370             s->last_mv[0][0][0]=
1371             s->last_mv[0][0][1]=
1372             s->last_mv[1][0][0]=
1373             s->last_mv[1][0][1]= 0;
1374         }
1375
1376         /* if we skipped it in the future P Frame than skip it now too */
1377         s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
1378
1379         if(s->mb_skiped){
1380                 /* skip mb */
1381             for(i=0;i<6;i++)
1382                 s->block_last_index[i] = -1;
1383
1384             s->mv_dir = MV_DIR_FORWARD;
1385             s->mv_type = MV_TYPE_16X16;
1386             s->mv[0][0][0] = 0;
1387             s->mv[0][0][1] = 0;
1388             s->mv[1][0][0] = 0;
1389             s->mv[1][0][1] = 0;
1390             s->last_mv[0][0][0]=
1391             s->last_mv[0][0][1]=
1392             s->last_mv[1][0][0]=
1393             s->last_mv[1][0][1]= 0;
1394             s->mb_skiped = 1;
1395             return 0;
1396         }
1397
1398         modb1= get_bits1(&s->gb);
1399         if(modb1==0){
1400             modb2= get_bits1(&s->gb);
1401             mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
1402             if(modb2==0) cbp= get_bits(&s->gb, 6);
1403             else cbp=0;
1404             if (mb_type && cbp) {
1405                 if(get_bits1(&s->gb)){
1406                     s->qscale +=get_bits1(&s->gb)*4 - 2;
1407                     if (s->qscale < 1)
1408                         s->qscale = 1;
1409                     else if (s->qscale > 31)
1410                         s->qscale = 31;
1411                 }
1412             }
1413         }else{
1414             mb_type=4; //like 0 but no vectors coded
1415             cbp=0;
1416         }
1417         s->mv_type = MV_TYPE_16X16; // we'll switch to 8x8 only if the last P frame had 8x8 for this MB and mb_type=0 here
1418         mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
1419         switch(mb_type)
1420         {
1421         case 0:
1422             mx = h263_decode_motion(s, 0, 1);
1423             my = h263_decode_motion(s, 0, 1);
1424         case 4:
1425             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1426             xy= s->block_index[0];
1427             time_pp= s->last_non_b_time[0] - s->last_non_b_time[1];
1428             time_pb= s->time - s->last_non_b_time[1];
1429 //if(time_pp>3000 )printf("%d %d  ", time_pp, time_pb);
1430             //FIXME 4MV
1431             //FIXME avoid divides
1432             s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
1433             s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
1434             s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
1435                                 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
1436             s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
1437                                 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
1438 /*            s->mv[0][0][0] =
1439             s->mv[0][0][1] =
1440             s->mv[1][0][0] =
1441             s->mv[1][0][1] = 1000;*/
1442             break;
1443         case 1:
1444             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
1445             mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1446             my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1447             s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1448             s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1449
1450             mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1451             my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1452             s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1453             s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1454             break;
1455         case 2:
1456             s->mv_dir = MV_DIR_BACKWARD;
1457             mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1458             my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1459             s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1460             s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1461             break;
1462         case 3:
1463             s->mv_dir = MV_DIR_FORWARD;
1464             mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1465             my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1466             s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1467             s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1468             break;
1469         default: return -1;
1470         }
1471     } else { /* I-Frame */
1472         cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
1473         if (cbpc < 0)
1474             return -1;
1475         dquant = cbpc & 4;
1476         s->mb_intra = 1;
1477 intra:
1478         s->ac_pred = 0;
1479         if (s->h263_pred || s->h263_aic) {
1480             s->ac_pred = get_bits1(&s->gb);
1481             if (s->ac_pred && s->h263_aic)
1482                 s->h263_aic_dir = get_bits1(&s->gb);
1483         }
1484         if (s->h263_aic) {
1485             s->y_dc_scale = 2 * s->qscale;
1486             s->c_dc_scale = 2 * s->qscale;
1487         }
1488         cbpy = get_vlc(&s->gb, &cbpy_vlc);
1489         cbp = (cbpc & 3) | (cbpy << 2);
1490         if (dquant) {
1491             s->qscale += quant_tab[get_bits(&s->gb, 2)];
1492             if (s->qscale < 1)
1493                 s->qscale = 1;
1494             else if (s->qscale > 31)
1495                 s->qscale = 31;
1496         }
1497     }
1498
1499     /* decode each block */
1500     if (s->h263_pred) {
1501         for (i = 0; i < 6; i++) {
1502             if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1503                 return -1;
1504         }
1505     } else {
1506         for (i = 0; i < 6; i++) {
1507             if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1508                 return -1;
1509         }
1510     }
1511     return 0;
1512 }
1513
1514 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
1515 {
1516     int code, val, sign, shift, l, m;
1517
1518     code = get_vlc(&s->gb, &mv_vlc);
1519     if (code < 0)
1520         return 0xffff;
1521
1522     if (code == 0)
1523         return pred;
1524     sign = get_bits1(&s->gb);
1525     shift = f_code - 1;
1526     val = (code - 1) << shift;
1527     if (shift > 0)
1528         val |= get_bits(&s->gb, shift);
1529     val++;
1530     if (sign)
1531         val = -val;
1532     val += pred;
1533
1534     /* modulo decoding */
1535     if (!s->h263_long_vectors) {
1536         l = (1 << (f_code - 1)) * 32;
1537         m = 2 * l;
1538         if (val < -l) {
1539             val += m;
1540         } else if (val >= l) {
1541             val -= m;
1542         }
1543     } else {
1544         /* horrible h263 long vector mode */
1545         if (pred < -31 && val < -63)
1546             val += 64;
1547         if (pred > 32 && val > 63)
1548             val -= 64;
1549
1550     }
1551     return val;
1552 }
1553
1554 /* Decodes RVLC of H.263+ UMV */
1555 static int h263p_decode_umotion(MpegEncContext * s, int pred)
1556 {
1557    int code = 0, sign;
1558
1559    if (get_bits1(&s->gb)) /* Motion difference = 0 */
1560       return pred;
1561
1562    code = 2 + get_bits1(&s->gb);
1563
1564    while (get_bits1(&s->gb))
1565    {
1566       code <<= 1;
1567       code += get_bits1(&s->gb);
1568    }
1569    sign = code & 1;
1570    code >>= 1;
1571
1572    code = (sign) ? (pred - code) : (pred + code);
1573 #ifdef DEBUG
1574    fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
1575 #endif
1576    return code;
1577
1578 }
1579
1580 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
1581                              int n, int coded)
1582 {
1583     int code, level, i, j, last, run;
1584     RLTable *rl = &rl_inter;
1585     const UINT8 *scan_table;
1586
1587     scan_table = zigzag_direct;
1588     if (s->h263_aic && s->mb_intra) {
1589         rl = &rl_intra_aic;
1590         i = 0;
1591         if (s->ac_pred) {
1592             if (s->h263_aic_dir)
1593                 scan_table = ff_alternate_vertical_scan; /* left */
1594             else
1595                 scan_table = ff_alternate_horizontal_scan; /* top */
1596         }
1597     } else if (s->mb_intra) {
1598         /* DC coef */
1599         if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
1600             int component, diff;
1601             component = (n <= 3 ? 0 : n - 4 + 1);
1602             level = s->last_dc[component];
1603             if (s->rv10_first_dc_coded[component]) {
1604                 diff = rv_decode_dc(s, n);
1605                 if (diff == 0xffff)
1606                     return -1;
1607                 level += diff;
1608                 level = level & 0xff; /* handle wrap round */
1609                 s->last_dc[component] = level;
1610             } else {
1611                 s->rv10_first_dc_coded[component] = 1;
1612             }
1613         } else {
1614             level = get_bits(&s->gb, 8);
1615             if (level == 255)
1616                 level = 128;
1617         }
1618         block[0] = level;
1619         i = 1;
1620     } else {
1621         i = 0;
1622     }
1623     if (!coded) {
1624         if (s->mb_intra && s->h263_aic)
1625             goto not_coded;
1626         s->block_last_index[n] = i - 1;
1627         return 0;
1628     }
1629
1630     for(;;) {
1631         code = get_vlc(&s->gb, &rl->vlc);
1632         if (code < 0)
1633             return -1;
1634         if (code == rl->n) {
1635             /* escape */
1636             last = get_bits1(&s->gb);
1637             run = get_bits(&s->gb, 6);
1638             level = (INT8)get_bits(&s->gb, 8);
1639             if (s->h263_rv10 && level == -128) {
1640                 /* XXX: should patch encoder too */
1641                 level = get_bits(&s->gb, 12);
1642                 level = (level << 20) >> 20;
1643             }
1644         } else {
1645             run = rl->table_run[code];
1646             level = rl->table_level[code];
1647             last = code >= rl->last;
1648             if (get_bits1(&s->gb))
1649                 level = -level;
1650         }
1651         i += run;
1652         if (i >= 64)
1653             return -1;
1654         j = scan_table[i];
1655         block[j] = level;
1656         if (last)
1657             break;
1658         i++;
1659     }
1660 not_coded:
1661     if (s->mb_intra && s->h263_aic) {
1662         h263_pred_acdc(s, block, n);
1663         i = 63;
1664     }
1665     s->block_last_index[n] = i;
1666     return 0;
1667 }
1668
1669 static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1670 {
1671     int level, pred, code;
1672     UINT16 *dc_val;
1673
1674     if (n < 4)
1675         code = get_vlc(&s->gb, &dc_lum);
1676     else
1677         code = get_vlc(&s->gb, &dc_chrom);
1678     if (code < 0)
1679         return -1;
1680     if (code == 0) {
1681         level = 0;
1682     } else {
1683         level = get_bits(&s->gb, code);
1684         if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
1685             level = - (level ^ ((1 << code) - 1));
1686         if (code > 8)
1687             skip_bits1(&s->gb); /* marker */
1688     }
1689
1690     pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1691     level += pred;
1692     if (level < 0)
1693         level = 0;
1694     if (n < 4) {
1695         *dc_val = level * s->y_dc_scale;
1696     } else {
1697         *dc_val = level * s->c_dc_scale;
1698     }
1699     return level;
1700 }
1701
1702 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1703                               int n, int coded)
1704 {
1705     int code, level, i, j, last, run;
1706     int dc_pred_dir;
1707     RLTable *rl;
1708     const UINT8 *scan_table;
1709
1710     if (s->mb_intra) {
1711         /* DC coef */
1712         level = mpeg4_decode_dc(s, n, &dc_pred_dir);
1713         if (level < 0)
1714             return -1;
1715         block[0] = level;
1716         i = 1;
1717         if (!coded)
1718             goto not_coded;
1719         rl = &rl_intra;
1720         if (s->ac_pred) {
1721             if (dc_pred_dir == 0)
1722                 scan_table = ff_alternate_vertical_scan; /* left */
1723             else
1724                 scan_table = ff_alternate_horizontal_scan; /* top */
1725         } else {
1726             scan_table = zigzag_direct;
1727         }
1728     } else {
1729         i = 0;
1730         if (!coded) {
1731             s->block_last_index[n] = i - 1;
1732             return 0;
1733         }
1734         rl = &rl_inter;
1735         scan_table = zigzag_direct;
1736     }
1737
1738     for(;;) {
1739         code = get_vlc(&s->gb, &rl->vlc);
1740         if (code < 0)
1741             return -1;
1742         if (code == rl->n) {
1743             /* escape */
1744             if (get_bits1(&s->gb) != 0) {
1745                 if (get_bits1(&s->gb) != 0) {
1746                     /* third escape */
1747                     last = get_bits1(&s->gb);
1748                     run = get_bits(&s->gb, 6);
1749                     get_bits1(&s->gb); /* marker */
1750                     level = get_bits(&s->gb, 12);
1751                     level = (level << 20) >> 20; /* sign extend */
1752                     skip_bits1(&s->gb); /* marker */
1753                 } else {
1754                     /* second escape */
1755                     code = get_vlc(&s->gb, &rl->vlc);
1756                     if (code < 0 || code >= rl->n)
1757                         return -1;
1758                     run = rl->table_run[code];
1759                     level = rl->table_level[code];
1760                     last = code >= rl->last;
1761                     run += rl->max_run[last][level] + 1;
1762                     if (get_bits1(&s->gb))
1763                         level = -level;
1764                 }
1765             } else {
1766                 /* first escape */
1767                 code = get_vlc(&s->gb, &rl->vlc);
1768                 if (code < 0 || code >= rl->n)
1769                     return -1;
1770                 run = rl->table_run[code];
1771                 level = rl->table_level[code];
1772                 last = code >= rl->last;
1773                 level += rl->max_level[last][run];
1774                 if (get_bits1(&s->gb))
1775                     level = -level;
1776             }
1777         } else {
1778             run = rl->table_run[code];
1779             level = rl->table_level[code];
1780             last = code >= rl->last;
1781             if (get_bits1(&s->gb))
1782                 level = -level;
1783         }
1784         i += run;
1785         if (i >= 64)
1786             return -1;
1787         j = scan_table[i];
1788         block[j] = level;
1789         i++;
1790         if (last)
1791             break;
1792     }
1793  not_coded:
1794     if (s->mb_intra) {
1795         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1796         if (s->ac_pred) {
1797             i = 64; /* XXX: not optimal */
1798         }
1799     }
1800     s->block_last_index[n] = i - 1;
1801     return 0;
1802 }
1803
1804 /* most is hardcoded. should extend to handle all h263 streams */
1805 int h263_decode_picture_header(MpegEncContext *s)
1806 {
1807     int format, width, height;
1808
1809     /* picture header */
1810     if (get_bits(&s->gb, 22) != 0x20)
1811         return -1;
1812     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
1813
1814     if (get_bits1(&s->gb) != 1)
1815         return -1;      /* marker */
1816     if (get_bits1(&s->gb) != 0)
1817         return -1;      /* h263 id */
1818     skip_bits1(&s->gb); /* split screen off */
1819     skip_bits1(&s->gb); /* camera  off */
1820     skip_bits1(&s->gb); /* freeze picture release off */
1821
1822     /* Reset GOB number */
1823     s->gob_number = 0;
1824
1825     format = get_bits(&s->gb, 3);
1826
1827     if (format != 7 && format != 6) {
1828         s->h263_plus = 0;
1829         /* H.263v1 */
1830         width = h263_format[format][0];
1831         height = h263_format[format][1];
1832         if (!width)
1833             return -1;
1834
1835         s->width = width;
1836         s->height = height;
1837         s->pict_type = I_TYPE + get_bits1(&s->gb);
1838
1839         s->unrestricted_mv = get_bits1(&s->gb);
1840         s->h263_long_vectors = s->unrestricted_mv;
1841
1842         if (get_bits1(&s->gb) != 0)
1843             return -1;  /* SAC: off */
1844         if (get_bits1(&s->gb) != 0) {
1845             s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1846         }
1847
1848         if (get_bits1(&s->gb) != 0)
1849             return -1;  /* not PB frame */
1850
1851         s->qscale = get_bits(&s->gb, 5);
1852         skip_bits1(&s->gb);     /* Continuous Presence Multipoint mode: off */
1853     } else {
1854         int ufep;
1855
1856         /* H.263v2 */
1857         s->h263_plus = 1;
1858         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
1859
1860         if (ufep == 1) {
1861             /* OPPTYPE */
1862             format = get_bits(&s->gb, 3);
1863             skip_bits(&s->gb,1); /* Custom PCF */
1864             s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
1865             skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
1866             if (get_bits1(&s->gb) != 0) {
1867                 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1868             }
1869             if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
1870                 s->h263_aic = 1;
1871             }
1872             skip_bits(&s->gb, 7);
1873             skip_bits(&s->gb, 3); /* Reserved */
1874         } else if (ufep != 0)
1875             return -1;
1876
1877         /* MPPTYPE */
1878         s->pict_type = get_bits(&s->gb, 3) + 1;
1879         if (s->pict_type != I_TYPE &&
1880             s->pict_type != P_TYPE)
1881             return -1;
1882         skip_bits(&s->gb, 2);
1883         s->no_rounding = get_bits1(&s->gb);
1884         //fprintf(stderr, "\nRTYPE: %d", s->no_rounding);
1885         skip_bits(&s->gb, 4);
1886
1887         /* Get the picture dimensions */
1888         if (ufep) {
1889             if (format == 6) {
1890                 /* Custom Picture Format (CPFMT) */
1891                 skip_bits(&s->gb, 4); /* aspect ratio */
1892                 width = (get_bits(&s->gb, 9) + 1) * 4;
1893                 skip_bits1(&s->gb);
1894                 height = get_bits(&s->gb, 9) * 4;
1895 #ifdef DEBUG
1896                 fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);
1897 #endif
1898             }
1899             else {
1900                 width = h263_format[format][0];
1901                 height = h263_format[format][1];
1902             }
1903             if ((width == 0) || (height == 0))
1904                 return -1;
1905             s->width = width;
1906             s->height = height;
1907             if (s->umvplus_dec) {
1908                 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1909             }
1910         }
1911
1912         s->qscale = get_bits(&s->gb, 5);
1913     }
1914     /* PEI */
1915     while (get_bits1(&s->gb) != 0) {
1916         skip_bits(&s->gb, 8);
1917     }
1918     s->f_code = 1;
1919     return 0;
1920 }
1921
1922 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
1923 {
1924     int i;
1925     int a= 2<<s->sprite_warping_accuracy;
1926     int rho= 3-s->sprite_warping_accuracy;
1927     int r=16/a;
1928     const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
1929     int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
1930     int sprite_ref[4][2];
1931     int virtual_ref[2][2];
1932     int w2, h2;
1933     int alpha=0, beta=0;
1934     int w= s->width;
1935     int h= s->height;
1936 //printf("SP %d\n", s->sprite_warping_accuracy);
1937     for(i=0; i<s->num_sprite_warping_points; i++){
1938         int length;
1939         int x=0, y=0;
1940
1941         length= get_vlc(&s->gb, &sprite_trajectory);
1942         if(length){
1943             x= get_bits(&s->gb, length);
1944 //printf("lx %d %d\n", length, x);
1945             if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
1946                 x = - (x ^ ((1 << length) - 1));
1947         }
1948         if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
1949
1950         length= get_vlc(&s->gb, &sprite_trajectory);
1951         if(length){
1952             y=get_bits(&s->gb, length);
1953 //printf("ly %d %d\n", length, y);
1954             if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
1955                 y = - (y ^ ((1 << length) - 1));
1956         }
1957         skip_bits1(&s->gb); /* marker bit */
1958 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
1959 //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
1960 //x=y=0;
1961         d[i][0]= x;
1962         d[i][1]= y;
1963     }
1964
1965     while((1<<alpha)<w) alpha++;
1966     while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
1967     w2= 1<<alpha;
1968     h2= 1<<beta;
1969
1970 // Note, the 4th point isnt used for GMC
1971     if(s->divx_version==500 && s->divx_build==413){
1972         sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
1973         sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
1974         sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
1975         sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
1976         sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
1977         sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
1978     } else {
1979         sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
1980         sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
1981         sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
1982         sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
1983         sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
1984         sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
1985     }
1986 /*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
1987     sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
1988
1989 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
1990 // perhaps it should be reordered to be more readable ...
1991 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
1992 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
1993     virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
1994         + RDIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
1995     virtual_ref[0][1]= 16*vop_ref[0][1]
1996         + RDIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
1997     virtual_ref[1][0]= 16*vop_ref[0][0]
1998         + RDIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
1999     virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
2000         + RDIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
2001
2002     switch(s->num_sprite_warping_points)
2003     {
2004         case 0:
2005             s->sprite_offset[0][0]= 0;
2006             s->sprite_offset[0][1]= 0;
2007             s->sprite_offset[1][0]= 0;
2008             s->sprite_offset[1][1]= 0;
2009             s->sprite_delta[0][0][0]= a;
2010             s->sprite_delta[0][0][1]= 0;
2011             s->sprite_delta[0][1][0]= 0;
2012             s->sprite_delta[0][1][1]= a;
2013             s->sprite_delta[1][0][0]= a;
2014             s->sprite_delta[1][0][1]= 0;
2015             s->sprite_delta[1][1][0]= 0;
2016             s->sprite_delta[1][1][1]= a;
2017             s->sprite_shift[0][0]= 0;
2018             s->sprite_shift[0][1]= 0;
2019             s->sprite_shift[1][0]= 0;
2020             s->sprite_shift[1][1]= 0;
2021             break;
2022         case 1: //GMC only
2023             s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
2024             s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
2025             s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
2026             s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
2027             s->sprite_delta[0][0][0]= a;
2028             s->sprite_delta[0][0][1]= 0;
2029             s->sprite_delta[0][1][0]= 0;
2030             s->sprite_delta[0][1][1]= a;
2031             s->sprite_delta[1][0][0]= a;
2032             s->sprite_delta[1][0][1]= 0;
2033             s->sprite_delta[1][1][0]= 0;
2034             s->sprite_delta[1][1][1]= a;
2035             s->sprite_shift[0][0]= 0;
2036             s->sprite_shift[0][1]= 0;
2037             s->sprite_shift[1][0]= 0;
2038             s->sprite_shift[1][1]= 0;
2039             break;
2040         case 2:
2041         case 3: //FIXME
2042             s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
2043                                                   + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
2044                                                     +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
2045             s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
2046                                                   + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
2047                                                     +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
2048             s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
2049                                  +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
2050                                  +2*w2*r*sprite_ref[0][0] - 16*w2);
2051             s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
2052                                  +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
2053                                  +2*w2*r*sprite_ref[0][1] - 16*w2);
2054             s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2055             s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);
2056             s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
2057             s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
2058             s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2059             s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
2060             s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
2061             s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
2062             s->sprite_shift[0][0]= alpha+rho;
2063             s->sprite_shift[0][1]= alpha+rho;
2064             s->sprite_shift[1][0]= alpha+rho+2;
2065             s->sprite_shift[1][1]= alpha+rho+2;
2066             break;
2067 //        case 3:
2068             break;
2069     }
2070 /*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
2071 printf("%d %d\n", s->sprite_delta[0][0][1], 0);
2072 printf("%d %d\n", s->sprite_delta[0][1][0], 0);
2073 printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
2074 printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
2075 printf("%d %d\n", s->sprite_delta[1][0][1], 0);
2076 printf("%d %d\n", s->sprite_delta[1][1][0], 0);
2077 printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
2078     /* try to simplify the situation */
2079     if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
2080        && s->sprite_delta[0][0][1] == 0
2081        && s->sprite_delta[0][1][0] == 0
2082        && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
2083        && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
2084        && s->sprite_delta[1][0][1] == 0
2085        && s->sprite_delta[1][1][0] == 0
2086        && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
2087     {
2088         s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
2089         s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
2090         s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
2091         s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
2092         s->sprite_delta[0][0][0]= a;
2093         s->sprite_delta[0][0][1]= 0;
2094         s->sprite_delta[0][1][0]= 0;
2095         s->sprite_delta[0][1][1]= a;
2096         s->sprite_delta[1][0][0]= a;
2097         s->sprite_delta[1][0][1]= 0;
2098         s->sprite_delta[1][1][0]= 0;
2099         s->sprite_delta[1][1][1]= a;
2100         s->sprite_shift[0][0]= 0;
2101         s->sprite_shift[0][1]= 0;
2102         s->sprite_shift[1][0]= 0;
2103         s->sprite_shift[1][1]= 0;
2104         s->real_sprite_warping_points=1;
2105     }
2106     else
2107         s->real_sprite_warping_points= s->num_sprite_warping_points;
2108
2109 }
2110
2111 /* decode mpeg4 VOP header */
2112 int mpeg4_decode_picture_header(MpegEncContext * s)
2113 {
2114     int time_incr, startcode, state, v;
2115
2116  redo:
2117     /* search next start code */
2118     align_get_bits(&s->gb);
2119     state = 0xff;
2120     for(;;) {
2121         v = get_bits(&s->gb, 8);
2122         if (state == 0x000001) {
2123             state = ((state << 8) | v) & 0xffffff;
2124             startcode = state;
2125             break;
2126         }
2127         state = ((state << 8) | v) & 0xffffff;
2128         if( get_bits_count(&s->gb) > s->gb.size*8-32){
2129             printf("no VOP startcode found\n");
2130             return -1;
2131         }
2132     }
2133 //printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
2134     if (startcode == 0x120) { // Video Object Layer
2135         int width, height, vo_ver_id;
2136
2137         /* vol header */
2138         skip_bits(&s->gb, 1); /* random access */
2139         skip_bits(&s->gb, 8); /* vo_type */
2140         if (get_bits1(&s->gb) != 0) { /* is_ol_id */
2141             vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
2142             skip_bits(&s->gb, 3); /* vo_priority */
2143         } else {
2144             vo_ver_id = 1;
2145         }
2146
2147         s->aspect_ratio_info= get_bits(&s->gb, 4);
2148         if(s->aspect_ratio_info == EXTENDET_PAR){
2149             skip_bits(&s->gb, 8); //par_width
2150             skip_bits(&s->gb, 8); // par_height
2151         }
2152         if(get_bits1(&s->gb)){ /* vol control parameter */
2153             printf("vol control parameter not supported\n");
2154             return -1;
2155         }
2156         s->shape = get_bits(&s->gb, 2); /* vol shape */
2157         if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
2158         if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
2159             printf("Gray shape not supported\n");
2160             skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
2161         }
2162
2163         skip_bits1(&s->gb);   /* marker */
2164
2165         s->time_increment_resolution = get_bits(&s->gb, 16);
2166         s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
2167         if (s->time_increment_bits < 1)
2168             s->time_increment_bits = 1;
2169         skip_bits1(&s->gb);   /* marker */
2170
2171         if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
2172             skip_bits(&s->gb, s->time_increment_bits);
2173         }
2174
2175         if (s->shape != BIN_ONLY_SHAPE) {
2176             if (s->shape == RECT_SHAPE) {
2177                 skip_bits1(&s->gb);   /* marker */
2178                 width = get_bits(&s->gb, 13);
2179                 skip_bits1(&s->gb);   /* marker */
2180                 height = get_bits(&s->gb, 13);
2181                 skip_bits1(&s->gb);   /* marker */
2182                 if(width && height){ /* they should be non zero but who knows ... */
2183                     s->width = width;
2184                     s->height = height;
2185 //                    printf("%d %d\n", width, height);
2186                 }
2187             }
2188
2189             if(get_bits1(&s->gb)) printf("interlaced not supported\n");   /* interlaced */
2190             if(!get_bits1(&s->gb)) printf("OBMC not supported\n");   /* OBMC Disable */
2191             if (vo_ver_id == 1) {
2192                 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
2193             } else {
2194                 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
2195             }
2196             if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
2197             if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
2198                 if(s->vol_sprite_usage==STATIC_SPRITE){
2199                     s->sprite_width = get_bits(&s->gb, 13);
2200                     skip_bits1(&s->gb); /* marker */
2201                     s->sprite_height= get_bits(&s->gb, 13);
2202                     skip_bits1(&s->gb); /* marker */
2203                     s->sprite_left  = get_bits(&s->gb, 13);
2204                     skip_bits1(&s->gb); /* marker */
2205                     s->sprite_top   = get_bits(&s->gb, 13);
2206                     skip_bits1(&s->gb); /* marker */
2207                 }
2208                 s->num_sprite_warping_points= get_bits(&s->gb, 6);
2209                 s->sprite_warping_accuracy = get_bits(&s->gb, 2);
2210                 s->sprite_brightness_change= get_bits1(&s->gb);
2211                 if(s->vol_sprite_usage==STATIC_SPRITE)
2212                     s->low_latency_sprite= get_bits1(&s->gb);
2213             }
2214             // FIXME sadct disable bit if verid!=1 && shape not rect
2215
2216             if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
2217                 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
2218                 if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
2219             } else {
2220                 s->quant_precision = 5;
2221             }
2222
2223             // FIXME a bunch of grayscale shape things
2224             if(get_bits1(&s->gb)) printf("Quant-Type not supported\n");  /* vol_quant_type */ //FIXME
2225             if(vo_ver_id != 1)
2226                  s->quarter_sample= get_bits1(&s->gb);
2227             else s->quarter_sample=0;
2228
2229             if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
2230 #if 0
2231             if(get_bits1(&s->gb)) printf("resync disable\n");
2232 #else
2233             skip_bits1(&s->gb);   /* resync_marker_disabled */
2234 #endif
2235             s->data_partioning= get_bits1(&s->gb);
2236             if(s->data_partioning){
2237                 printf("data partitioning not supported\n");
2238                 skip_bits1(&s->gb); // reversible vlc
2239             }
2240
2241             if(vo_ver_id != 1) {
2242                 s->new_pred= get_bits1(&s->gb);
2243                 if(s->new_pred){
2244                     printf("new pred not supported\n");
2245                     skip_bits(&s->gb, 2); /* requested upstream message type */
2246                     skip_bits1(&s->gb); /* newpred segment type */
2247                 }
2248                 s->reduced_res_vop= get_bits1(&s->gb);
2249                 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
2250             }
2251             else{
2252                 s->new_pred=0;
2253                 s->reduced_res_vop= 0;
2254             }
2255
2256             s->scalability= get_bits1(&s->gb);
2257             if (s->scalability) {
2258                 printf("bad scalability!!!\n");
2259                 return -1;
2260             }
2261         }
2262 //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
2263         goto redo;
2264     } else if (startcode == 0x1b2) { //userdata
2265         char buf[256];
2266         int i;
2267         int e;
2268         int ver, build;
2269
2270 //printf("user Data %X\n", show_bits(&s->gb, 32));
2271         buf[0]= show_bits(&s->gb, 8);
2272         for(i=1; i<256; i++){
2273             buf[i]= show_bits(&s->gb, 16)&0xFF;
2274             if(buf[i]==0) break;
2275             skip_bits(&s->gb, 8);
2276         }
2277         buf[255]=0;
2278         e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
2279         if(e==2){
2280             s->divx_version= ver;
2281             s->divx_build= build;
2282             if(s->picture_number==0){
2283                 printf("This file was encoded with DivX%d Build%d\n", ver, build);
2284                 if(ver==500 && build==413){ //most likely all version are indeed totally buggy but i dunno for sure ...
2285                     printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
2286                 }else{
2287                     printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
2288                            "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
2289                 }
2290             }
2291         }
2292 //printf("User Data: %s\n", buf);
2293         goto redo;
2294     } else if (startcode != 0x1b6) { //VOP
2295         goto redo;
2296     }
2297
2298     s->pict_type = get_bits(&s->gb, 2) + 1;     /* pict type: I = 0 , P = 1 */
2299 //printf("pic: %d\n", s->pict_type);
2300     time_incr=0;
2301     while (get_bits1(&s->gb) != 0)
2302         time_incr++;
2303
2304     check_marker(&s->gb, "before time_increment");
2305     s->time_increment= get_bits(&s->gb, s->time_increment_bits);
2306     if(s->pict_type!=B_TYPE){
2307         s->time_base+= time_incr;
2308         s->last_non_b_time[1]= s->last_non_b_time[0];
2309         s->last_non_b_time[0]= s->time_base*s->time_increment_resolution + s->time_increment;
2310     }else{
2311         s->time= (s->last_non_b_time[1]/s->time_increment_resolution + time_incr)*s->time_increment_resolution;
2312         s->time+= s->time_increment;
2313     }
2314
2315     if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
2316         printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
2317         for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
2318             if(get_bits1(&s->gb)) break;
2319         }
2320         printf("my guess is %d bits ;)\n",s->time_increment_bits);
2321     }
2322     /* vop coded */
2323     if (get_bits1(&s->gb) != 1)
2324         goto redo;
2325 //printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
2326 //s->time, s->last_non_b_time[0], s->last_non_b_time[1]);
2327     if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
2328                           || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
2329         /* rounding type for motion estimation */
2330         s->no_rounding = get_bits1(&s->gb);
2331     } else {
2332         s->no_rounding = 0;
2333     }
2334 //FIXME reduced res stuff
2335
2336      if (s->shape != RECT_SHAPE) {
2337          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
2338              int width, height, hor_spat_ref, ver_spat_ref;
2339
2340              width = get_bits(&s->gb, 13);
2341              skip_bits1(&s->gb);   /* marker */
2342              height = get_bits(&s->gb, 13);
2343              skip_bits1(&s->gb);   /* marker */
2344              hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
2345              skip_bits1(&s->gb);   /* marker */
2346              ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
2347          }
2348          skip_bits1(&s->gb); /* change_CR_disable */
2349
2350          if (get_bits1(&s->gb) != 0) {
2351              skip_bits(&s->gb, 8); /* constant_alpha_value */
2352          }
2353      }
2354 //FIXME complexity estimation stuff
2355
2356      if (s->shape != BIN_ONLY_SHAPE) {
2357          skip_bits(&s->gb, 3); /* intra dc VLC threshold */
2358          //FIXME interlaced specific bits
2359      }
2360
2361      if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
2362          if(s->num_sprite_warping_points){
2363              mpeg4_decode_sprite_trajectory(s);
2364          }
2365          if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
2366          if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
2367      }
2368
2369      if (s->shape != BIN_ONLY_SHAPE) {
2370          /* note: we do not use quant_precision to avoid problem if no
2371             MPEG4 vol header as it is found on some old opendivx
2372             movies */
2373          s->qscale = get_bits(&s->gb, 5);
2374          if(s->qscale==0){
2375              printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
2376              return -1; // makes no sense to continue, as there is nothing left from the image then
2377          }
2378
2379          if (s->pict_type != I_TYPE) {
2380              s->f_code = get_bits(&s->gb, 3);   /* fcode_for */
2381              if(s->f_code==0){
2382                  printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
2383                  return -1; // makes no sense to continue, as the MV decoding will break very quickly
2384              }
2385          }
2386          if (s->pict_type == B_TYPE) {
2387              s->b_code = get_bits(&s->gb, 3);
2388 //printf("b-code %d\n", s->b_code);
2389          }
2390 //printf("quant:%d fcode:%d\n", s->qscale, s->f_code);
2391
2392          if(!s->scalability){
2393              if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
2394                  skip_bits1(&s->gb); // vop shape coding type
2395              }
2396          }
2397      }
2398      s->picture_number++; // better than pic number==0 allways ;)
2399      return 0;
2400 }
2401
2402 /* don't understand why they choose a different header ! */
2403 int intel_h263_decode_picture_header(MpegEncContext *s)
2404 {
2405     int format;
2406
2407     /* picture header */
2408     if (get_bits(&s->gb, 22) != 0x20)
2409         return -1;
2410     skip_bits(&s->gb, 8); /* picture timestamp */
2411
2412     if (get_bits1(&s->gb) != 1)
2413         return -1;      /* marker */
2414     if (get_bits1(&s->gb) != 0)
2415         return -1;      /* h263 id */
2416     skip_bits1(&s->gb); /* split screen off */
2417     skip_bits1(&s->gb); /* camera  off */
2418     skip_bits1(&s->gb); /* freeze picture release off */
2419
2420     format = get_bits(&s->gb, 3);
2421     if (format != 7)
2422         return -1;
2423
2424     s->h263_plus = 0;
2425
2426     s->pict_type = I_TYPE + get_bits1(&s->gb);
2427
2428     s->unrestricted_mv = get_bits1(&s->gb);
2429     s->h263_long_vectors = s->unrestricted_mv;
2430
2431     if (get_bits1(&s->gb) != 0)
2432         return -1;      /* SAC: off */
2433     if (get_bits1(&s->gb) != 0)
2434         return -1;      /* advanced prediction mode: off */
2435     if (get_bits1(&s->gb) != 0)
2436         return -1;      /* not PB frame */
2437
2438     /* skip unknown header garbage */
2439     skip_bits(&s->gb, 41);
2440
2441     s->qscale = get_bits(&s->gb, 5);
2442     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
2443
2444     /* PEI */
2445     while (get_bits1(&s->gb) != 0) {
2446         skip_bits(&s->gb, 8);
2447     }
2448     s->f_code = 1;
2449     return 0;
2450 }
2451