updated ffmpeg to the latest ffmpeg-cvs, hopefully this will handle divx5 files

CVS patchset: 1558
CVS date: 2002/03/12 00:40:52

1 files changed, 577 insertions, 88 deletions

diff --git a/src/libffmpeg/libavcodec/h263.c b/src/libffmpeg/libavcodec/h263.c
index da694411f..79b74631d 100644
--- a/src/libffmpeg/libavcodec/h263.c
+++ b/src/libffmpeg/libavcodec/h263.c
@@ -25,6 +25,10 @@
 #include "h263data.h"
 #include "mpeg4data.h"
 
+//rounded divison & shift
+#define RDIV(a,b) ((a) > 0 ? ((a)+((b)>>1))/(b) : ((a)-((b)>>1))/(b))
+#define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
+
 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
 			      int n);
 static void h263_encode_motion(MpegEncContext * s, int val);
@@ -62,8 +66,13 @@ void h263_encode_picture_header(MpegEncContext * s, int picture_number)
     int format;
 
     align_put_bits(&s->pb);
-    put_bits(&s->pb, 22, 0x20);
-    put_bits(&s->pb, 8, ((s->picture_number * 30 * FRAME_RATE_BASE) / 
+
+    /* Update the pointer to last GOB */
+    s->ptr_lastgob = pbBufPtr(&s->pb);
+    s->gob_number = 0;
+
+    put_bits(&s->pb, 22, 0x20); /* PSC */
+    put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / 
                          s->frame_rate) & 0xff);
 
     put_bits(&s->pb, 1, 1);	/* marker */
@@ -147,26 +156,40 @@ int h263_encode_gob_header(MpegEncContext * s, int mb_line)
     /* Check to see if we need to put a new GBSC */
     /* for RTP packetization                    */
     if (s->rtp_mode) {
-        pdif = s->pb.buf_ptr - s->ptr_lastgob;
+        pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
         if (pdif >= s->rtp_payload_size) {
             /* Bad luck, packet must be cut before */
             align_put_bits(&s->pb);
-            s->ptr_lastgob = s->pb.buf_ptr;
+            flush_put_bits(&s->pb);
+            /* Call the RTP callback to send the last GOB */
+            if (s->rtp_callback) {
+                pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
+                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
+            }
+            s->ptr_lastgob = pbBufPtr(&s->pb);
             put_bits(&s->pb, 17, 1); /* GBSC */
-            s->gob_number = mb_line;
+            s->gob_number = mb_line / s->gob_index;
             put_bits(&s->pb, 5, s->gob_number); /* GN */
-            put_bits(&s->pb, 2, 1); /* GFID */
+            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
             put_bits(&s->pb, 5, s->qscale); /* GQUANT */
+            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
             return pdif;
        } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
            /* Cut the packet before we can't */
            align_put_bits(&s->pb);
-           s->ptr_lastgob = s->pb.buf_ptr;
+           flush_put_bits(&s->pb);
+           /* Call the RTP callback to send the last GOB */
+           if (s->rtp_callback) {
+               pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
+               s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
+           }
+           s->ptr_lastgob = pbBufPtr(&s->pb);
            put_bits(&s->pb, 17, 1); /* GBSC */
-           s->gob_number = mb_line;
+           s->gob_number = mb_line / s->gob_index;
            put_bits(&s->pb, 5, s->gob_number); /* GN */
-           put_bits(&s->pb, 2, 1); /* GFID */
+           put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
            put_bits(&s->pb, 5, s->qscale); /* GQUANT */
+           //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
            return pdif;
        }
    }
@@ -254,19 +277,101 @@ void h263_encode_mb(MpegEncContext * s,
     }
 }
 
+
+void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
+{
+    int x, y, wrap, a, c, pred_dc, scale, i;
+    INT16 *dc_val, *ac_val, *ac_val1;
+
+    /* find prediction */
+    if (n < 4) {
+        x = 2 * s->mb_x + 1 + (n & 1);
+        y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
+        wrap = s->mb_width * 2 + 2;
+        dc_val = s->dc_val[0];
+        ac_val = s->ac_val[0][0];
+        scale = s->y_dc_scale;
+    } else {
+        x = s->mb_x + 1;
+        y = s->mb_y + 1;
+        wrap = s->mb_width + 2;
+        dc_val = s->dc_val[n - 4 + 1];
+        ac_val = s->ac_val[n - 4 + 1][0];
+        scale = s->c_dc_scale;
+    }
+    
+    ac_val += ((y) * wrap + (x)) * 16;
+    ac_val1 = ac_val;
+    
+    /* B C
+     * A X 
+     */
+    a = dc_val[(x - 1) + (y) * wrap];
+    c = dc_val[(x) + (y - 1) * wrap];
+    
+    pred_dc = 1024;
+    if (s->ac_pred) {
+        if (s->h263_aic_dir) {
+            /* left prediction */
+            if (a != 1024) {
+                ac_val -= 16;
+                for(i=1;i<8;i++) {
+                    block[block_permute_op(i*8)] += ac_val[i];
+                }
+                pred_dc = a;
+            }
+        } else {
+            /* top prediction */
+            if (c != 1024) {
+                ac_val -= 16 * wrap;
+                for(i=1;i<8;i++) {
+                    block[block_permute_op(i)] += ac_val[i + 8];
+                }
+                pred_dc = c;
+            }
+        }
+    } else {
+        /* just DC prediction */
+        if (a != 1024 && c != 1024)
+            pred_dc = (a + c) >> 1;
+        else if (a != 1024)
+            pred_dc = a;
+        else
+            pred_dc = c;
+    }
+    
+    /* we assume pred is positive */
+    block[0]=block[0]*scale + pred_dc;
+    
+    if (block[0] < 0)
+        block[0] = 0;
+    else if (!(block[0] & 1))
+        block[0]++;
+    
+    /* Update AC/DC tables */
+    dc_val[(x) + (y) * wrap] = block[0];
+    
+    /* left copy */
+    for(i=1;i<8;i++)
+        ac_val1[i] = block[block_permute_op(i * 8)];
+    /* top copy */
+    for(i=1;i<8;i++)
+        ac_val1[8 + i] = block[block_permute_op(i)];
+}
+
+
 static inline int mid_pred(int a, int b, int c)
 {
     int vmin, vmax;
-    vmin = a;
+    vmax = vmin = a;
     if (b < vmin)
         vmin = b;
+    else
+	vmax = b;
+
     if (c < vmin)
         vmin = c;
-
-    vmax = a;
-    if (b > vmax)
-        vmax = b;
-    if (c > vmax)
+    else if (c > vmax)
         vmax = c;
 
     return a + b + c - vmin - vmax;
@@ -275,38 +380,39 @@ static inline int mid_pred(int a, int b, int c)
 INT16 *h263_pred_motion(MpegEncContext * s, int block, 
                         int *px, int *py)
 {
-    int x, y, wrap;
+    int xy, y, wrap;
     INT16 *A, *B, *C, *mot_val;
 
-    x = 2 * s->mb_x + 1 + (block & 1);
-    y = 2 * s->mb_y + 1 + ((block >> 1) & 1);
     wrap = 2 * s->mb_width + 2;
+    y = xy = 2 * s->mb_y + 1 + ((block >> 1) & 1); // y
+    xy *= wrap; // y * wrap
+    xy += 2 * s->mb_x + 1 + (block & 1); // x + y * wrap
 
-    mot_val = s->motion_val[(x) + (y) * wrap];
+    mot_val = s->motion_val[xy];
 
     /* special case for first line */
     if (y == 1 || s->first_slice_line || s->first_gob_line) {
-        A = s->motion_val[(x-1) + (y) * wrap];
+        A = s->motion_val[xy - 1];
         *px = A[0];
         *py = A[1];
     } else {
         switch(block) {
         default:
         case 0:
-            A = s->motion_val[(x-1) + (y) * wrap];
-            B = s->motion_val[(x) + (y-1) * wrap];
-            C = s->motion_val[(x+2) + (y-1) * wrap];
+            A = s->motion_val[xy - 1];
+            B = s->motion_val[xy - wrap];
+            C = s->motion_val[xy + 2 - wrap];
             break;
         case 1:
         case 2:
-            A = s->motion_val[(x-1) + (y) * wrap];
-            B = s->motion_val[(x) + (y-1) * wrap];
-            C = s->motion_val[(x+1) + (y-1) * wrap];
+            A = s->motion_val[xy - 1];
+            B = s->motion_val[xy - wrap];
+            C = s->motion_val[xy + 1 - wrap];
             break;
         case 3:
-            A = s->motion_val[(x-1) + (y) * wrap];
-            B = s->motion_val[(x-1) + (y-1) * wrap];
-            C = s->motion_val[(x) + (y-1) * wrap];
+            A = s->motion_val[xy - 1];
+            B = s->motion_val[xy - 1 - wrap];
+            C = s->motion_val[xy - wrap];
             break;
         }
         *px = mid_pred(A[0], B[0], C[0]);
@@ -413,20 +519,25 @@ static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
     RLTable *rl = &rl_inter;
 
     if (s->mb_intra) {
-	/* DC coef */
-	level = block[0];
+        /* DC coef */
+	    level = block[0];
         /* 255 cannot be represented, so we clamp */
         if (level > 254) {
             level = 254;
             block[0] = 254;
         }
-	if (level == 128)
-	    put_bits(&s->pb, 8, 0xff);
-	else
-	    put_bits(&s->pb, 8, level & 0xff);
-	i = 1;
+        /* 0 cannot be represented also */
+        else if (!level) {
+            level = 1;
+            block[0] = 1;
+        }
+	    if (level == 128)
+	        put_bits(&s->pb, 8, 0xff);
+	    else
+	        put_bits(&s->pb, 8, level & 0xff);
+	    i = 1;
     } else {
-	i = 0;
+	    i = 0;
     }
 
     /* AC coefs */
@@ -465,7 +576,8 @@ void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
 {
     align_put_bits(&s->pb);
 
-    put_bits(&s->pb, 32, 0x1B6);	/* vop header */
+    put_bits(&s->pb, 16, 0);	        /* vop header */
+    put_bits(&s->pb, 16, 0x1B6);	/* vop header */
     put_bits(&s->pb, 2, s->pict_type - 1);	/* pict type: I = 0 , P = 1 */
     /* XXX: time base + 1 not always correct */
     put_bits(&s->pb, 1, 1);
@@ -513,20 +625,22 @@ void h263_dc_scale(MpegEncContext * s)
 
 static int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
 {
-    int a, b, c, x, y, wrap, pred, scale;
+    int a, b, c, xy, wrap, pred, scale;
     UINT16 *dc_val;
 
     /* find prediction */
     if (n < 4) {
-	x = 2 * s->mb_x + 1 + (n & 1);
-	y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
 	wrap = s->mb_width * 2 + 2;
+	xy = 2 * s->mb_y + 1 + ((n & 2) >> 1);
+        xy *= wrap;
+	xy += 2 * s->mb_x + 1 + (n & 1);
 	dc_val = s->dc_val[0];
 	scale = s->y_dc_scale;
     } else {
-	x = s->mb_x + 1;
-	y = s->mb_y + 1;
 	wrap = s->mb_width + 2;
+	xy = s->mb_y + 1;
+	xy *= wrap;
+	xy += s->mb_x + 1;
 	dc_val = s->dc_val[n - 4 + 1];
 	scale = s->c_dc_scale;
     }
@@ -534,9 +648,9 @@ static int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *di
     /* B C
      * A X 
      */
-    a = dc_val[(x - 1) + (y) * wrap];
-    b = dc_val[(x - 1) + (y - 1) * wrap];
-    c = dc_val[(x) + (y - 1) * wrap];
+    a = dc_val[xy - 1];
+    b = dc_val[xy - 1 - wrap];
+    c = dc_val[xy - wrap];
 
     if (abs(a - b) < abs(b - c)) {
 	pred = c;
@@ -549,7 +663,7 @@ static int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *di
     pred = (pred + (scale >> 1)) / scale;
 
     /* prepare address for prediction update */
-    *dc_val_ptr = &dc_val[(x) + (y) * wrap];
+    *dc_val_ptr = &dc_val[xy];
 
     return pred;
 }
@@ -724,6 +838,7 @@ static VLC inter_MCBPC_vlc;
 static VLC cbpy_vlc;
 static VLC mv_vlc;
 static VLC dc_lum, dc_chrom;
+static VLC sprite_trajectory;
 
 void init_rl(RLTable *rl)
 {
@@ -794,14 +909,19 @@ void h263_decode_init_vlc(MpegEncContext *s)
                  &mvtab[0][0], 2, 1);
         init_rl(&rl_inter);
         init_rl(&rl_intra);
+        init_rl(&rl_intra_aic);
         init_vlc_rl(&rl_inter);
         init_vlc_rl(&rl_intra);
+        init_vlc_rl(&rl_intra_aic);
         init_vlc(&dc_lum, 9, 13,
                  &DCtab_lum[0][1], 2, 1,
                  &DCtab_lum[0][0], 2, 1);
         init_vlc(&dc_chrom, 9, 13,
                  &DCtab_chrom[0][1], 2, 1,
                  &DCtab_chrom[0][0], 2, 1);
+        init_vlc(&sprite_trajectory, 9, 15,
+                 &sprite_trajectory_tab[0][1], 4, 2,
+                 &sprite_trajectory_tab[0][0], 4, 2);
     }
 }
 
@@ -822,7 +942,7 @@ int h263_decode_gob_header(MpegEncContext *s)
         gfid = get_bits(&s->gb, 2); /* GFID */
         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
 #ifdef DEBUG
-        fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", gn, gfid, s->qscale);
+        fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
 #endif
         return 1;
     }
@@ -837,7 +957,7 @@ int h263_decode_mb(MpegEncContext *s,
     INT16 *mot_val;
     static INT8 quant_tab[4] = { -1, -2, 1, 2 };
     
-    if (s->pict_type == P_TYPE) {
+    if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
         if (get_bits1(&s->gb)) {
             /* skip mb */
             s->mb_intra = 0;
@@ -845,9 +965,25 @@ int h263_decode_mb(MpegEncContext *s,
                 s->block_last_index[i] = -1;
             s->mv_dir = MV_DIR_FORWARD;
             s->mv_type = MV_TYPE_16X16;
-            s->mv[0][0][0] = 0;
-            s->mv[0][0][1] = 0;
-            s->mb_skiped = 1;
+            if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
+                const int a= s->sprite_warping_accuracy;
+//                int l = (1 << (s->f_code - 1)) * 32;
+
+                s->mcsel=1;
+                s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
+                s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
+/*                if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
+                else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
+                if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
+                else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
+
+                s->mb_skiped = 0;
+            }else{
+                s->mcsel=0;
+                s->mv[0][0][0] = 0;
+                s->mv[0][0][1] = 0;
+                s->mb_skiped = 1;
+            }
             return 0;
         }
         cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
@@ -870,6 +1006,9 @@ int h263_decode_mb(MpegEncContext *s,
     }
 
     if (!s->mb_intra) {
+        if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
+            s->mcsel= get_bits1(&s->gb);
+        else s->mcsel= 0;
         cbpy = get_vlc(&s->gb, &cbpy_vlc);
         cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
         if (dquant) {
@@ -886,15 +1025,29 @@ int h263_decode_mb(MpegEncContext *s,
             h263_pred_motion(s, 0, &pred_x, &pred_y);
             if (s->umvplus_dec)
                mx = h263p_decode_umotion(s, pred_x);
-            else
+            else if(!s->mcsel)
                mx = h263_decode_motion(s, pred_x);
+            else {
+               const int a= s->sprite_warping_accuracy;
+//        int l = (1 << (s->f_code - 1)) * 32;
+               mx= RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
+//        if (mx < -l) mx= -l;
+//        else if (mx >= l) mx= l-1;
+            }
             if (mx >= 0xffff)
                 return -1;
             
             if (s->umvplus_dec)
                my = h263p_decode_umotion(s, pred_y);
-            else    
+            else if(!s->mcsel)
                my = h263_decode_motion(s, pred_y);
+            else{
+               const int a= s->sprite_warping_accuracy;
+//       int l = (1 << (s->f_code - 1)) * 32;
+               my= RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
+//       if (my < -l) my= -l;
+//       else if (my >= l) my= l-1;
+            }
             if (my >= 0xffff)
                 return -1;
             s->mv[0][0][0] = mx;
@@ -932,8 +1085,14 @@ int h263_decode_mb(MpegEncContext *s,
         }
     } else {
         s->ac_pred = 0;
-	    if (s->h263_pred) {
+        if (s->h263_pred || s->h263_aic) {
             s->ac_pred = get_bits1(&s->gb);
+            if (s->ac_pred && s->h263_aic)
+                s->h263_aic_dir = get_bits1(&s->gb);
+        }
+        if (s->h263_aic) {
+            s->y_dc_scale = 2 * s->qscale;
+            s->c_dc_scale = 2 * s->qscale;
         }
         cbpy = get_vlc(&s->gb, &cbpy_vlc);
         cbp = (cbpc & 3) | (cbpy << 2);
@@ -1032,9 +1191,20 @@ static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
 {
     int code, level, i, j, last, run;
     RLTable *rl = &rl_inter;
+    const UINT8 *scan_table;
 
-    if (s->mb_intra) {
-	/* DC coef */
+    scan_table = zigzag_direct;
+    if (s->h263_aic && s->mb_intra) {
+        rl = &rl_intra_aic;
+        i = 0;
+        if (s->ac_pred) {
+            if (s->h263_aic_dir) 
+                scan_table = ff_alternate_vertical_scan; /* left */
+            else
+                scan_table = ff_alternate_horizontal_scan; /* top */
+        }
+    } else if (s->mb_intra) {
+        /* DC coef */
         if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
             int component, diff;
             component = (n <= 3 ? 0 : n - 4 + 1);
@@ -1055,11 +1225,13 @@ static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
                 level = 128;
         }
         block[0] = level;
-	i = 1;
+        i = 1;
     } else {
-	i = 0;
+        i = 0;
     }
     if (!coded) {
+        if (s->mb_intra && s->h263_aic)
+            goto not_coded;
         s->block_last_index[n] = i - 1;
         return 0;
     }
@@ -1088,12 +1260,17 @@ static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
         i += run;
         if (i >= 64)
             return -1;
-	j = zigzag_direct[i];
+        j = scan_table[i];
         block[j] = level;
         if (last)
             break;
         i++;
     }
+not_coded:    
+    if (s->mb_intra && s->h263_aic) {
+        h263_pred_acdc(s, block, n);
+        i = 64;
+    }
     s->block_last_index[n] = i;
     return 0;
 }
@@ -1241,8 +1418,8 @@ int h263_decode_picture_header(MpegEncContext *s)
     /* picture header */
     if (get_bits(&s->gb, 22) != 0x20)
         return -1;
-    skip_bits(&s->gb, 8); /* picture timestamp */
-
+    s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
+    
     if (get_bits1(&s->gb) != 1)
         return -1;	/* marker */
     if (get_bits1(&s->gb) != 0)
@@ -1298,7 +1475,10 @@ int h263_decode_picture_header(MpegEncContext *s)
             if (get_bits1(&s->gb) != 0) {
                 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
             }
-            skip_bits(&s->gb, 8);
+            if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
+                s->h263_aic = 1;
+            }
+            skip_bits(&s->gb, 7);
             skip_bits(&s->gb, 3); /* Reserved */
         } else if (ufep != 0)
             return -1;
@@ -1308,7 +1488,10 @@ int h263_decode_picture_header(MpegEncContext *s)
         if (s->pict_type != I_TYPE &&
             s->pict_type != P_TYPE)
             return -1;
-        skip_bits(&s->gb, 7);
+        skip_bits(&s->gb, 2);
+        s->no_rounding = get_bits1(&s->gb);
+        //fprintf(stderr, "\nRTYPE: %d", s->no_rounding);
+        skip_bits(&s->gb, 4);
         
         /* Get the picture dimensions */
         if (ufep) {
@@ -1345,6 +1528,196 @@ int h263_decode_picture_header(MpegEncContext *s)
     return 0;
 }
 
+static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
+{
+    int i;
+    int a= 2<<s->sprite_warping_accuracy;
+    int rho= 3-s->sprite_warping_accuracy;
+    int r=16/a;
+    const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
+    int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
+    int sprite_ref[4][2];
+    int virtual_ref[2][2];
+    int w2, h2;
+    int alpha=0, beta=0;
+    int w= s->width;
+    int h= s->height;
+//printf("SP %d\n", s->sprite_warping_accuracy);
+    for(i=0; i<s->num_sprite_warping_points; i++){
+        int length;
+        int x=0, y=0;
+
+        length= get_vlc(&s->gb, &sprite_trajectory);
+        if(length){
+            x= get_bits(&s->gb, length);
+//printf("lx %d %d\n", length, x);
+            if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
+                x = - (x ^ ((1 << length) - 1));
+        }
+        if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
+        
+        length= get_vlc(&s->gb, &sprite_trajectory);
+        if(length){
+            y=get_bits(&s->gb, length);
+//printf("ly %d %d\n", length, y);
+            if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
+                y = - (y ^ ((1 << length) - 1));
+        }
+        skip_bits1(&s->gb); /* marker bit */
+//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
+//if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
+//x=y=0;
+        d[i][0]= x;
+        d[i][1]= y;
+    }
+
+    while((1<<alpha)<w) alpha++;
+    while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
+    w2= 1<<alpha;
+    h2= 1<<beta;
+
+// Note, the 4th point isnt used for GMC
+/*
+    sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
+    sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
+    sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
+    sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
+    sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
+    sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
+*/
+//FIXME DIVX5 vs. mpeg4 ?
+    sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
+    sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
+    sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
+    sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
+    sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
+    sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
+/*    sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
+    sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
+    
+// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
+// perhaps it should be reordered to be more readable ...
+// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
+// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
+    virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
+        + 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);
+    virtual_ref[0][1]= 16*vop_ref[0][1] 
+        + 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);
+    virtual_ref[1][0]= 16*vop_ref[0][0] 
+        + 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);
+    virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
+        + 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);
+
+    switch(s->num_sprite_warping_points)
+    {
+        case 0:
+            s->sprite_offset[0][0]= 0;
+            s->sprite_offset[0][1]= 0;
+            s->sprite_offset[1][0]= 0;
+            s->sprite_offset[1][1]= 0;
+            s->sprite_delta[0][0][0]= a;
+            s->sprite_delta[0][0][1]= 0;
+            s->sprite_delta[0][1][0]= 0;
+            s->sprite_delta[0][1][1]= a;
+            s->sprite_delta[1][0][0]= a;
+            s->sprite_delta[1][0][1]= 0;
+            s->sprite_delta[1][1][0]= 0;
+            s->sprite_delta[1][1][1]= a;
+            s->sprite_shift[0][0]= 0;
+            s->sprite_shift[0][1]= 0;
+            s->sprite_shift[1][0]= 0;
+            s->sprite_shift[1][1]= 0;
+            break;
+        case 1: //GMC only
+            s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
+            s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
+            s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
+            s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
+            s->sprite_delta[0][0][0]= a;
+            s->sprite_delta[0][0][1]= 0;
+            s->sprite_delta[0][1][0]= 0;
+            s->sprite_delta[0][1][1]= a;
+            s->sprite_delta[1][0][0]= a;
+            s->sprite_delta[1][0][1]= 0;
+            s->sprite_delta[1][1][0]= 0;
+            s->sprite_delta[1][1][1]= a;
+            s->sprite_shift[0][0]= 0;
+            s->sprite_shift[0][1]= 0;
+            s->sprite_shift[1][0]= 0;
+            s->sprite_shift[1][1]= 0;
+            break;
+        case 2:
+        case 3: //FIXME
+            s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
+                                                  + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
+                                                    +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
+            s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
+                                                  + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
+                                                    +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
+            s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
+                                 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
+                                 +2*w2*r*sprite_ref[0][0] - 16*w2);
+            s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 
+                                 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
+                                 +2*w2*r*sprite_ref[0][1] - 16*w2);
+            s->sprite_delta[0][0][0]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
+            s->sprite_delta[0][0][1]=   ( r*sprite_ref[0][1] - virtual_ref[0][1]);
+            s->sprite_delta[0][1][0]=   (-r*sprite_ref[0][1] + virtual_ref[0][1]);
+            s->sprite_delta[0][1][1]=   (-r*sprite_ref[0][0] + virtual_ref[0][0]);
+            s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
+            s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
+            s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
+            s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
+            s->sprite_shift[0][0]= alpha+rho;
+            s->sprite_shift[0][1]= alpha+rho;
+            s->sprite_shift[1][0]= alpha+rho+2;
+            s->sprite_shift[1][1]= alpha+rho+2;
+            break;
+//        case 3:
+            break;
+    }
+/*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
+printf("%d %d\n", s->sprite_delta[0][0][1], 0);
+printf("%d %d\n", s->sprite_delta[0][1][0], 0);
+printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
+printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
+printf("%d %d\n", s->sprite_delta[1][0][1], 0);
+printf("%d %d\n", s->sprite_delta[1][1][0], 0);
+printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
+    /* try to simplify the situation */ 
+    if(   s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
+       && s->sprite_delta[0][0][1] == 0
+       && s->sprite_delta[0][1][0] == 0
+       && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
+       && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
+       && s->sprite_delta[1][0][1] == 0
+       && s->sprite_delta[1][1][0] == 0
+       && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
+    {
+        s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
+        s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
+        s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
+        s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
+        s->sprite_delta[0][0][0]= a;
+        s->sprite_delta[0][0][1]= 0;
+        s->sprite_delta[0][1][0]= 0;
+        s->sprite_delta[0][1][1]= a;
+        s->sprite_delta[1][0][0]= a;
+        s->sprite_delta[1][0][1]= 0;
+        s->sprite_delta[1][1][0]= 0;
+        s->sprite_delta[1][1][1]= a;
+        s->sprite_shift[0][0]= 0;
+        s->sprite_shift[0][1]= 0;
+        s->sprite_shift[1][0]= 0;
+        s->sprite_shift[1][1]= 0;
+        s->real_sprite_warping_points=1;
+    }
+    else
+        s->real_sprite_warping_points= s->num_sprite_warping_points;
+
+//FIXME convert stuff if accurace != 3
+}
+
 /* decode mpeg4 VOP header */
 int mpeg4_decode_picture_header(MpegEncContext * s)
 {
@@ -1366,8 +1739,8 @@ int mpeg4_decode_picture_header(MpegEncContext * s)
         if (state == 0)
             return -1;
     }
-
-    if (startcode == 0x120) {
+//printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
+    if (startcode == 0x120) { // Video Object Layer
         int time_increment_resolution, width, height, vo_ver_id;
 
         /* vol header */
@@ -1380,9 +1753,21 @@ int mpeg4_decode_picture_header(MpegEncContext * s)
             vo_ver_id = 1;
         }
         
-        skip_bits(&s->gb, 4); /* aspect_ratio_info */
-        skip_bits1(&s->gb); /* vol control parameter */
+        s->aspect_ratio_info= get_bits(&s->gb, 4);
+	if(s->aspect_ratio_info == EXTENDET_PAR){
+            skip_bits(&s->gb, 8); //par_width
+            skip_bits(&s->gb, 8); // par_height
+        }
+        if(get_bits1(&s->gb)){ /* vol control parameter */
+            printf("vol control parameter not supported\n");
+            return -1;   
+        }
         s->shape = get_bits(&s->gb, 2); /* vol shape */
+        if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
+            printf("Gray shape not supported\n");
+            skip_bits(&s->gb, 4);  //video_object_layer_shape_extension
+        }
+
         skip_bits1(&s->gb);   /* marker */
         
         time_increment_resolution = get_bits(&s->gb, 16);
@@ -1395,8 +1780,8 @@ int mpeg4_decode_picture_header(MpegEncContext * s)
             skip_bits(&s->gb, s->time_increment_bits);
         }
 
-        if (s->shape != 2) {
-            if (s->shape == 0) {
+        if (s->shape != BIN_ONLY_SHAPE) {
+            if (s->shape == RECT_SHAPE) {
                 skip_bits1(&s->gb);   /* marker */
                 width = get_bits(&s->gb, 13);
                 skip_bits1(&s->gb);   /* marker */
@@ -1405,12 +1790,32 @@ int mpeg4_decode_picture_header(MpegEncContext * s)
             }
             
             skip_bits1(&s->gb);   /* interlaced */
-            skip_bits1(&s->gb);   /* OBMC */
+            if(!get_bits1(&s->gb)) printf("OBMC not supported\n");   /* OBMC Disable */
             if (vo_ver_id == 1) {
                 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
             } else {
                 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
             }
+            if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
+            if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
+                if(s->vol_sprite_usage==STATIC_SPRITE){
+                    s->sprite_width = get_bits(&s->gb, 13);
+                    skip_bits1(&s->gb); /* marker */
+                    s->sprite_height= get_bits(&s->gb, 13);
+                    skip_bits1(&s->gb); /* marker */
+                    s->sprite_left  = get_bits(&s->gb, 13);
+                    skip_bits1(&s->gb); /* marker */
+                    s->sprite_top   = get_bits(&s->gb, 13);
+                    skip_bits1(&s->gb); /* marker */
+                }
+                s->num_sprite_warping_points= get_bits(&s->gb, 6);
+                s->sprite_warping_accuracy = get_bits(&s->gb, 2);
+                s->sprite_brightness_change= get_bits1(&s->gb);
+                if(s->vol_sprite_usage==STATIC_SPRITE)
+                    s->low_latency_sprite= get_bits1(&s->gb);            
+            }
+            // FIXME sadct disable bit if verid!=1 && shape not rect
+            
             if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
                 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
                 skip_bits(&s->gb, 4); /* bits_per_pixel */
@@ -1418,26 +1823,88 @@ int mpeg4_decode_picture_header(MpegEncContext * s)
                 s->quant_precision = 5;
             }
             
-            skip_bits1(&s->gb);   /* vol_quant_type */
-            skip_bits1(&s->gb);   /* vol_quarter_pixel */
+            // FIXME a bunch of grayscale shape things
+            if(get_bits1(&s->gb)) printf("Quant-Type not supported\n");  /* vol_quant_type */ //FIXME
+            if(vo_ver_id != 1)
+                 s->quarter_sample= get_bits1(&s->gb);
+            else s->quarter_sample=0;
+#if 0
+            if(get_bits1(&s->gb)) printf("Complexity est disabled\n");
+            if(get_bits1(&s->gb)) printf("resync disable\n");
+#else
             skip_bits1(&s->gb);   /* complexity_estimation_disabled */
             skip_bits1(&s->gb);   /* resync_marker_disabled */
-            skip_bits1(&s->gb);   /* data_partioning_enabled */
-            if (get_bits1(&s->gb) != 0) { /* scalability */
+#endif
+            s->data_partioning= get_bits1(&s->gb);
+            if(s->data_partioning){
+                printf("data partitioning not supported\n");
+                skip_bits1(&s->gb); // reversible vlc
+            }
+            
+            if(vo_ver_id != 1) {
+                s->new_pred= get_bits1(&s->gb);
+                if(s->new_pred){
+                    printf("new pred not supported\n");
+                    skip_bits(&s->gb, 2); /* requested upstream message type */
+                    skip_bits1(&s->gb); /* newpred segment type */
+                }
+                s->reduced_res_vop= get_bits1(&s->gb);
+                if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
+            }
+            else{
+                s->new_pred=0;
+                s->reduced_res_vop= 0;
+            }
+
+            s->scalability= get_bits1(&s->gb);
+            if (s->scalability) {
                 printf("bad scalability!!!\n");
                 return -1;
             }
         }
+//printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
+        goto redo;
+    } else if (startcode == 0x1b2) { //userdata
+        char buf[256];
+        int i;
+        int e;
+        int ver, build;
+
+//printf("user Data %X\n", show_bits(&s->gb, 32));
+        buf[0]= show_bits(&s->gb, 8);
+        for(i=1; i<256; i++){
+            buf[i]= show_bits(&s->gb, 16)&0xFF;
+            if(buf[i]==0) break;
+            skip_bits(&s->gb, 8);
+        }
+        buf[255]=0;
+        e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
+        if(e==2){
+            s->divx_version= ver;
+            s->divx_build= build;
+            if(s->picture_number==0){
+                printf("This file was encoded with DivX%d Build%d\n", ver, build);
+                if(ver==500 && build==413){ //most likely all version are indeed totally buggy but i dunno for sure ...
+                    printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
+                }else{
+                    printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
+                           "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
+                }
+            }
+        }
+//printf("User Data: %s\n", buf);
         goto redo;
-    } else if (startcode != 0x1b6) {
+    } else if (startcode != 0x1b6) { //VOP
         goto redo;
     }
 
     s->pict_type = get_bits(&s->gb, 2) + 1;	/* pict type: I = 0 , P = 1 */
-    if (s->pict_type != I_TYPE &&
-        s->pict_type != P_TYPE)
-        return -1;
-    
+    if(s->pict_type == B_TYPE)
+    {
+        printf("B-VOP\n");
+	return -1;
+    }
+ 
     /* XXX: parse time base */
     time_incr = 0;
     while (get_bits1(&s->gb) != 0) 
@@ -1450,14 +1917,16 @@ int mpeg4_decode_picture_header(MpegEncContext * s)
     if (get_bits1(&s->gb) != 1)
         goto redo;
     
-    if (s->shape != 2 && s->pict_type == P_TYPE) {
+    if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
+                          || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
         /* rounding type for motion estimation */
 	s->no_rounding = get_bits1(&s->gb);
     } else {
 	s->no_rounding = 0;
     }
-    
-     if (s->shape != 0) {
+//FIXME reduced res stuff
+
+     if (s->shape != RECT_SHAPE) {
          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
              int width, height, hor_spat_ref, ver_spat_ref;
  
@@ -1475,10 +1944,22 @@ int mpeg4_decode_picture_header(MpegEncContext * s)
              skip_bits(&s->gb, 8); /* constant_alpha_value */
          }
      }
-
-     if (s->shape != 2) {
+//FIXME complexity estimation stuff
+     
+     if (s->shape != BIN_ONLY_SHAPE) {
          skip_bits(&s->gb, 3); /* intra dc VLC threshold */
-  
+         //FIXME interlaced specific bits
+     }
+
+     if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
+         if(s->num_sprite_warping_points){
+             mpeg4_decode_sprite_trajectory(s);
+         }
+         if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
+         if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
+     }
+
+     if (s->shape != BIN_ONLY_SHAPE) {
          /* note: we do not use quant_precision to avoid problem if no
             MPEG4 vol header as it is found on some old opendivx
             movies */
@@ -1487,10 +1968,18 @@ int mpeg4_decode_picture_header(MpegEncContext * s)
          if (s->pict_type != I_TYPE) {
              s->f_code = get_bits(&s->gb, 3);	/* fcode_for */
          }
-         if (s->shape && (s->pict_type != I_TYPE)) {
-             skip_bits1(&s->gb); // vop shape coding type
+         if (s->pict_type == B_TYPE) {
+             s->b_code = get_bits(&s->gb, 3);
+         }
+//printf("quant:%d fcode:%d\n", s->qscale, s->f_code);
+         if(!s->scalability){
+             if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
+                 skip_bits1(&s->gb); // vop shape coding type
+             }
          }
      }
+//printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
+     s->picture_number++; // better than pic number==0 allways ;)
      return 0;
 }