motion vector vissualization for mpeg1/2

mpeg1/2 cleanup/bugfix
error resilience bugfix

Originally committed as revision 1911 to svn://svn.ffmpeg.org/ffmpeg/trunk

4 files changed, 150 insertions, 131 deletions

diff --git a/libavcodec/error_resilience.c b/libavcodec/error_resilience.c
index 6a940ed0aa..4ac92bfd29 100644
--- a/libavcodec/error_resilience.c
+++ b/libavcodec/error_resilience.c
@@ -733,7 +733,7 @@ void ff_er_frame_end(MpegEncContext *s){
         for(i=s->mb_num-2; i>=s->mb_width+100; i--){ //FIXME +100 hack
             const int mb_xy= s->mb_index2xy[i];
             int error1= s->error_status_table[mb_xy  ];
-            int error2= s->error_status_table[mb_xy+1];
+            int error2= s->error_status_table[s->mb_index2xy[i+1]];
         
             if(error1&VP_START)
                 end_ok=1;
diff --git a/libavcodec/h263dec.c b/libavcodec/h263dec.c
index 5ba0e16291..efc43cd67c 100644
--- a/libavcodec/h263dec.c
+++ b/libavcodec/h263dec.c
@@ -377,75 +377,6 @@ static int h263_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
     return END_NOT_FOUND;
 }
 
-/**
- * draws an line from (ex, ey) -> (sx, sy).
- * @param w width of the image
- * @param h height of the image
- * @param stride stride/linesize of the image
- * @param color color of the arrow
- */
-static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
-    int t, x, y, f;
-    
-    ex= clip(ex, 0, w-1);
-    ey= clip(ey, 0, h-1);
-    
-    buf[sy*stride + sx]+= color;
-    
-    if(ABS(ex - sx) > ABS(ey - sy)){
-        if(sx > ex){
-            t=sx; sx=ex; ex=t;
-            t=sy; sy=ey; ey=t;
-        }
-        buf+= sx + sy*stride;
-        ex-= sx;
-        f= ((ey-sy)<<16)/ex;
-        for(x= 0; x <= ex; x++){
-            y= ((x*f) + (1<<15))>>16;
-            buf[y*stride + x]+= color;
-        }
-    }else{
-        if(sy > ey){
-            t=sx; sx=ex; ex=t;
-            t=sy; sy=ey; ey=t;
-        }
-        buf+= sx + sy*stride;
-        ey-= sy;
-        if(ey) f= ((ex-sx)<<16)/ey;
-        else   f= 0;
-        for(y= 0; y <= ey; y++){
-            x= ((y*f) + (1<<15))>>16;
-            buf[y*stride + x]+= color;
-        }
-    }
-}
-
-/**
- * draws an arrow from (ex, ey) -> (sx, sy).
- * @param w width of the image
- * @param h height of the image
- * @param stride stride/linesize of the image
- * @param color color of the arrow
- */
-static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
-    int dx= ex - sx;
-    int dy= ey - sy;
-    
-    if(dx*dx + dy*dy > 3*3){
-        int rx=  dx + dy;
-        int ry= -dx + dy;
-        int length= ff_sqrt((rx*rx + ry*ry)<<8);
-        
-        //FIXME subpixel accuracy
-        rx= ROUNDED_DIV(rx*3<<4, length);
-        ry= ROUNDED_DIV(ry*3<<4, length);
-        
-        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
-        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
-    }
-    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
-}
-
 int ff_h263_decode_frame(AVCodecContext *avctx, 
                              void *data, int *data_size,
                              uint8_t *buf, int buf_size)
@@ -740,39 +671,8 @@ retry:
 
     MPV_frame_end(s);
 
-    if((avctx->debug&FF_DEBUG_VIS_MV) && s->last_picture_ptr){
-        const int shift= 1 + s->quarter_sample;
-        int mb_y;
-        uint8_t *ptr= s->last_picture.data[0];
-        s->low_delay=0; //needed to see the vectors without trashing the buffers
-
-        for(mb_y=0; mb_y<s->mb_height; mb_y++){
-            int mb_x;
-            for(mb_x=0; mb_x<s->mb_width; mb_x++){
-                const int mb_index= mb_x + mb_y*s->mb_stride;
-                if(IS_8X8(s->current_picture.mb_type[mb_index])){
-                    int i;
-                    for(i=0; i<4; i++){
-                        int sx= mb_x*16 + 4 + 8*(i&1);
-                        int sy= mb_y*16 + 4 + 8*(i>>1);
-                        int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
-                        int mx= (s->motion_val[xy][0]>>shift) + sx;
-                        int my= (s->motion_val[xy][1]>>shift) + sy;
-                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
-                    }
-                }else{
-                    int sx= mb_x*16 + 8;
-                    int sy= mb_y*16 + 8;
-                    int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
-                    int mx= (s->motion_val[xy][0]>>shift) + sx;
-                    int my= (s->motion_val[xy][1]>>shift) + sy;
-                    draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
-                }
-                s->mbskip_table[mb_index]=0;
-            }
-        }
-    }
-
+assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
+assert(s->current_picture.pict_type == s->pict_type);
     if(s->pict_type==B_TYPE || s->low_delay){
         *pict= *(AVFrame*)&s->current_picture;
         ff_print_debug_info(s, s->current_picture_ptr);
diff --git a/libavcodec/mpeg12.c b/libavcodec/mpeg12.c
index cf38ac74f2..a519fd9207 100644
--- a/libavcodec/mpeg12.c
+++ b/libavcodec/mpeg12.c
@@ -1770,18 +1770,15 @@ static void mpeg_decode_extension(AVCodecContext *avctx,
     }
 }
 
-#define DECODE_SLICE_MB_ADDR_ERROR -3 //we faild decoding the mb_x/y info
 #define DECODE_SLICE_FATAL_ERROR -2
 #define DECODE_SLICE_ERROR -1
 #define DECODE_SLICE_OK 0
-#define DECODE_SLICE_EOP 1
 
 /**
  * decodes a slice.
  * @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br>
  *         DECODE_SLICE_ERROR if the slice is damaged<br>
  *         DECODE_SLICE_OK if this slice is ok<br>
- *         DECODE_SLICE_EOP if the end of the picture is reached
  */
 static int mpeg_decode_slice(AVCodecContext *avctx, 
                               AVFrame *pict,
@@ -1793,10 +1790,13 @@ static int mpeg_decode_slice(AVCodecContext *avctx,
     int ret;
     const int field_pic= s->picture_structure != PICT_FRAME;
 
+    s->resync_mb_x= s->mb_x = 
+    s->resync_mb_y= s->mb_y = -1;
+    
     start_code = (start_code - 1) & 0xff;
     if (start_code >= s->mb_height){
         fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s->mb_height);
-        return DECODE_SLICE_MB_ADDR_ERROR;
+        return -1;
     }
     
     ff_mpeg1_clean_buffers(s);
@@ -1856,7 +1856,7 @@ static int mpeg_decode_slice(AVCodecContext *avctx,
     s->qscale = get_qscale(s);
     if(s->qscale == 0){
         fprintf(stderr, "qscale == 0\n");
-        return DECODE_SLICE_MB_ADDR_ERROR;
+        return -1;
     }
     
     /* extra slice info */
@@ -1870,7 +1870,7 @@ static int mpeg_decode_slice(AVCodecContext *avctx,
         int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
         if (code < 0){
             fprintf(stderr, "first mb_incr damaged\n");
-            return DECODE_SLICE_MB_ADDR_ERROR;
+            return -1;
         }
         if (code >= 33) {
             if (code == 33) {
@@ -1901,7 +1901,9 @@ static int mpeg_decode_slice(AVCodecContext *avctx,
             const int xy = s->mb_x*2 + 1 + (s->mb_y*2 +1)*wrap;
             int motion_x, motion_y;
 
-            if (s->mb_intra || s->mv_type == MV_TYPE_16X16) {
+            if (s->mb_intra) {
+                motion_x = motion_y = 0;
+            }else if (s->mv_type == MV_TYPE_16X16) {
                 motion_x = s->mv[0][0][0];
                 motion_y = s->mv[0][0][1];
             } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
@@ -1963,20 +1965,26 @@ static int mpeg_decode_slice(AVCodecContext *avctx,
         }
         if(s->mb_y<<field_pic >= s->mb_height){
             fprintf(stderr, "slice too long\n");
-            return DECODE_SLICE_ERROR;
+            return -1;
         }
     }
-eos: //end of slice
+eos: // end of slice
+    *buf += get_bits_count(&s->gb)/8 - 1;
 //printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
-    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
+    return 0;
+}
 
-    emms_c();
-    
-    *buf += get_bits_count(&s->gb)/8 - 1;
-    
-//intf("%d %d %d %d\n", s->mb_y, s->mb_height, s->pict_type, s->picture_number);
+/**
+ * handles slice ends.
+ * @return 1 if it seems to be the last slice of 
+ */
+static int slice_end(AVCodecContext *avctx, AVFrame *pict)
+{
+    Mpeg1Context *s1 = avctx->priv_data;
+    MpegEncContext *s = &s1->mpeg_enc_ctx;
+       
     /* end of slice reached */
-    if (s->mb_y<<field_pic == s->mb_height && !s->first_field) {
+    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
         /* end of image */
 
         if(s->mpeg2){
@@ -2000,9 +2008,9 @@ eos: //end of slice
                  ff_print_debug_info(s, s->last_picture_ptr);
             }
         }
-        return DECODE_SLICE_EOP;
+        return 1;
     } else {
-        return DECODE_SLICE_OK;
+        return 0;
     }
 }
 
@@ -2234,7 +2242,10 @@ static int mpeg_decode_frame(AVCodecContext *avctx,
         /* find start next code */
         start_code = find_start_code(&buf_ptr, buf_end);
         if (start_code < 0){
-//            printf("missing end of picture\n");
+            if (slice_end(avctx, picture)) {
+                if(s2->last_picture_ptr) //FIXME merge with the stuff in mpeg_decode_slice
+                    *data_size = sizeof(AVPicture);
+            }
             return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
         }
 
@@ -2274,17 +2285,14 @@ static int mpeg_decode_frame(AVCodecContext *avctx,
 
                         ret = mpeg_decode_slice(avctx, picture,
                                                 start_code, &buf_ptr, input_size);
+                        emms_c();
 
-                        if (ret == DECODE_SLICE_EOP) {
-                            if(s2->last_picture_ptr) //FIXME merge with the stuff in mpeg_decode_slice
-                                *data_size = sizeof(AVPicture);
-                            return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
-                        }else if(ret < 0){
-                            if(ret == DECODE_SLICE_ERROR)
+                        if(ret < 0){
+                            if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
                                 ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, AC_ERROR|DC_ERROR|MV_ERROR);
-                                
-                            fprintf(stderr,"Error while decoding slice\n");
-			    if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
+                            if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
+                        }else{
+                            ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, AC_END|DC_END|MV_END);
                         }
                     }
                     break;
diff --git a/libavcodec/mpegvideo.c b/libavcodec/mpegvideo.c
index 47f6146f25..2cf986798b 100644
--- a/libavcodec/mpegvideo.c
+++ b/libavcodec/mpegvideo.c
@@ -1064,6 +1064,84 @@ void MPV_frame_end(MpegEncContext *s)
 }
 
 /**
+ * draws an line from (ex, ey) -> (sx, sy).
+ * @param w width of the image
+ * @param h height of the image
+ * @param stride stride/linesize of the image
+ * @param color color of the arrow
+ */
+static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
+    int t, x, y, f;
+    
+    sx= clip(sx, 0, w-1);
+    sy= clip(sy, 0, h-1);
+    ex= clip(ex, 0, w-1);
+    ey= clip(ey, 0, h-1);
+    
+    buf[sy*stride + sx]+= color;
+    
+    if(ABS(ex - sx) > ABS(ey - sy)){
+        if(sx > ex){
+            t=sx; sx=ex; ex=t;
+            t=sy; sy=ey; ey=t;
+        }
+        buf+= sx + sy*stride;
+        ex-= sx;
+        f= ((ey-sy)<<16)/ex;
+        for(x= 0; x <= ex; x++){
+            y= ((x*f) + (1<<15))>>16;
+            buf[y*stride + x]+= color;
+        }
+    }else{
+        if(sy > ey){
+            t=sx; sx=ex; ex=t;
+            t=sy; sy=ey; ey=t;
+        }
+        buf+= sx + sy*stride;
+        ey-= sy;
+        if(ey) f= ((ex-sx)<<16)/ey;
+        else   f= 0;
+        for(y= 0; y <= ey; y++){
+            x= ((y*f) + (1<<15))>>16;
+            buf[y*stride + x]+= color;
+        }
+    }
+}
+
+/**
+ * draws an arrow from (ex, ey) -> (sx, sy).
+ * @param w width of the image
+ * @param h height of the image
+ * @param stride stride/linesize of the image
+ * @param color color of the arrow
+ */
+static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
+    int dx,dy;
+
+    sx= clip(sx, -100, w+100);
+    sy= clip(sy, -100, h+100);
+    ex= clip(ex, -100, w+100);
+    ey= clip(ey, -100, h+100);
+    
+    dx= ex - sx;
+    dy= ey - sy;
+    
+    if(dx*dx + dy*dy > 3*3){
+        int rx=  dx + dy;
+        int ry= -dx + dy;
+        int length= ff_sqrt((rx*rx + ry*ry)<<8);
+        
+        //FIXME subpixel accuracy
+        rx= ROUNDED_DIV(rx*3<<4, length);
+        ry= ROUNDED_DIV(ry*3<<4, length);
+        
+        draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
+        draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
+    }
+    draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
+}
+
+/**
  * prints debuging info for the given picture.
  */
 void ff_print_debug_info(MpegEncContext *s, Picture *pict){
@@ -1137,6 +1215,39 @@ void ff_print_debug_info(MpegEncContext *s, Picture *pict){
             printf("\n");
         }
     }
+    
+    if((s->avctx->debug&FF_DEBUG_VIS_MV) && s->motion_val){
+        const int shift= 1 + s->quarter_sample;
+        int mb_y;
+        uint8_t *ptr= pict->data[0];
+        s->low_delay=0; //needed to see the vectors without trashing the buffers
+
+        for(mb_y=0; mb_y<s->mb_height; mb_y++){
+            int mb_x;
+            for(mb_x=0; mb_x<s->mb_width; mb_x++){
+                const int mb_index= mb_x + mb_y*s->mb_stride;
+                if(IS_8X8(s->current_picture.mb_type[mb_index])){
+                    int i;
+                    for(i=0; i<4; i++){
+                        int sx= mb_x*16 + 4 + 8*(i&1);
+                        int sy= mb_y*16 + 4 + 8*(i>>1);
+                        int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
+                        int mx= (s->motion_val[xy][0]>>shift) + sx;
+                        int my= (s->motion_val[xy][1]>>shift) + sy;
+                        draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
+                    }
+                }else{
+                    int sx= mb_x*16 + 8;
+                    int sy= mb_y*16 + 8;
+                    int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
+                    int mx= (s->motion_val[xy][0]>>shift) + sx;
+                    int my= (s->motion_val[xy][1]>>shift) + sy;
+                    draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
+                }
+                s->mbskip_table[mb_index]=0;
+            }
+        }
+    }
 }
 
 #ifdef CONFIG_ENCODERS