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