error resilience cleanup (its faster too...)
[ffmpeg.git] / libavcodec / h263dec.c
1 /*
2  * H.263 decoder
3  * Copyright (c) 2001 Fabrice Bellard.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19  
20 /**
21  * @file h263dec.c
22  * H.263 decoder.
23  */
24  
25 #include "avcodec.h"
26 #include "dsputil.h"
27 #include "mpegvideo.h"
28
29 //#define DEBUG
30 //#define PRINT_FRAME_TIME
31 #ifdef PRINT_FRAME_TIME
32 static inline long long rdtsc()
33 {
34         long long l;
35         asm volatile(   "rdtsc\n\t"
36                 : "=A" (l)
37         );
38 //      printf("%d\n", int(l/1000));
39         return l;
40 }
41 #endif
42
43 int ff_h263_decode_init(AVCodecContext *avctx)
44 {
45     MpegEncContext *s = avctx->priv_data;
46
47     s->avctx = avctx;
48     s->out_format = FMT_H263;
49
50     s->width = avctx->width;
51     s->height = avctx->height;
52     s->workaround_bugs= avctx->workaround_bugs;
53
54     // set defaults
55     s->quant_precision=5;
56     s->progressive_sequence=1;
57     s->decode_mb= ff_h263_decode_mb;
58     s->low_delay= 1;
59     avctx->pix_fmt= PIX_FMT_YUV420P;
60
61     /* select sub codec */
62     switch(avctx->codec->id) {
63     case CODEC_ID_H263:
64         s->gob_number = 0;
65         break;
66     case CODEC_ID_MPEG4:
67         s->time_increment_bits = 4; /* default value for broken headers */
68         s->h263_pred = 1;
69         s->low_delay = 0; //default, might be overriden in the vol header during header parsing
70         break;
71     case CODEC_ID_MSMPEG4V1:
72         s->h263_msmpeg4 = 1;
73         s->h263_pred = 1;
74         s->msmpeg4_version=1;
75         break;
76     case CODEC_ID_MSMPEG4V2:
77         s->h263_msmpeg4 = 1;
78         s->h263_pred = 1;
79         s->msmpeg4_version=2;
80         break;
81     case CODEC_ID_MSMPEG4V3:
82         s->h263_msmpeg4 = 1;
83         s->h263_pred = 1;
84         s->msmpeg4_version=3;
85         break;
86     case CODEC_ID_WMV1:
87         s->h263_msmpeg4 = 1;
88         s->h263_pred = 1;
89         s->msmpeg4_version=4;
90         break;
91     case CODEC_ID_WMV2:
92         s->h263_msmpeg4 = 1;
93         s->h263_pred = 1;
94         s->msmpeg4_version=5;
95         break;
96     case CODEC_ID_H263I:
97         s->h263_intel = 1;
98         break;
99     default:
100         return -1;
101     }
102     s->codec_id= avctx->codec->id;
103
104     /* for h263, we allocate the images after having read the header */
105     if (avctx->codec->id != CODEC_ID_H263 && avctx->codec->id != CODEC_ID_MPEG4)
106         if (MPV_common_init(s) < 0)
107             return -1;
108
109     if (s->h263_msmpeg4)
110         ff_msmpeg4_decode_init(s);
111     else
112         h263_decode_init_vlc(s);
113     
114     return 0;
115 }
116
117 int ff_h263_decode_end(AVCodecContext *avctx)
118 {
119     MpegEncContext *s = avctx->priv_data;
120
121     MPV_common_end(s);
122     return 0;
123 }
124
125 /**
126  * retunrs the number of bytes consumed for building the current frame
127  */
128 static int get_consumed_bytes(MpegEncContext *s, int buf_size){
129     int pos= (get_bits_count(&s->gb)+7)>>3;
130     
131     if(s->divx_version>=500){
132         //we would have to scan through the whole buf to handle the weird reordering ...
133         return buf_size; 
134     }else if(s->flags&CODEC_FLAG_TRUNCATED){
135         pos -= s->parse_context.last_index;
136         if(pos<0) pos=0; // padding is not really read so this might be -1
137         return pos;
138     }else{
139         if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
140         if(pos+10>buf_size) pos=buf_size; // oops ;)
141
142         return pos;
143     }
144 }
145
146 static int decode_slice(MpegEncContext *s){
147     const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
148     s->last_resync_gb= s->gb;
149     s->first_slice_line= 1;
150         
151     s->resync_mb_x= s->mb_x;
152     s->resync_mb_y= s->mb_y;
153
154     s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
155     s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
156     
157     if(s->partitioned_frame){
158         const int qscale= s->qscale;
159
160         if(s->codec_id==CODEC_ID_MPEG4){
161             if(ff_mpeg4_decode_partitions(s) < 0)
162                 return -1; 
163         }
164         
165         /* restore variables which where modified */
166         s->first_slice_line=1;
167         s->mb_x= s->resync_mb_x;
168         s->mb_y= s->resync_mb_y;
169         s->qscale= qscale;
170         s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
171         s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
172     }
173
174     for(; s->mb_y < s->mb_height; s->mb_y++) {
175         /* per-row end of slice checks */
176         if(s->msmpeg4_version){
177             if(s->resync_mb_y + s->slice_height == s->mb_y){
178                 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);
179
180                 return 0;
181             }
182         }
183         
184         if(s->msmpeg4_version==1){
185             s->last_dc[0]=
186             s->last_dc[1]=
187             s->last_dc[2]= 128;
188         }
189     
190         ff_init_block_index(s);
191         for(; s->mb_x < s->mb_width; s->mb_x++) {
192             int ret;
193
194             ff_update_block_index(s);
195
196             if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
197                 s->first_slice_line=0; 
198             }
199
200             /* DCT & quantize */
201             s->dsp.clear_blocks(s->block[0]);
202             
203             s->mv_dir = MV_DIR_FORWARD;
204             s->mv_type = MV_TYPE_16X16;
205 //            s->mb_skiped = 0;
206 //printf("%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
207             ret= s->decode_mb(s, s->block);
208             
209             MPV_decode_mb(s, s->block);
210
211             if(ret<0){
212                 const int xy= s->mb_x + s->mb_y*s->mb_width;
213                 if(ret==SLICE_END){
214 //printf("%d %d %d %06X\n", s->mb_x, s->mb_y, s->gb.size*8 - get_bits_count(&s->gb), show_bits(&s->gb, 24));
215                     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
216
217                     s->padding_bug_score--;
218                         
219                     if(++s->mb_x >= s->mb_width){
220                         s->mb_x=0;
221                         ff_draw_horiz_band(s, s->mb_y*16, 16);
222                         s->mb_y++;
223                     }
224                     return 0; 
225                 }else if(ret==SLICE_NOEND){
226                     fprintf(stderr,"Slice mismatch at MB: %d\n", xy);
227                     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)&part_mask);
228                     return -1;
229                 }
230                 fprintf(stderr,"Error at MB: %d\n", xy);
231                 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
232     
233                 return -1;
234             }
235         }
236         
237         ff_draw_horiz_band(s, s->mb_y*16, 16);
238         
239         s->mb_x= 0;
240     }
241     
242     assert(s->mb_x==0 && s->mb_y==s->mb_height);
243
244     /* try to detect the padding bug */
245     if(      s->codec_id==CODEC_ID_MPEG4
246        &&   (s->workaround_bugs&FF_BUG_AUTODETECT) 
247        &&    s->gb.size_in_bits - get_bits_count(&s->gb) >=0
248        &&    s->gb.size_in_bits - get_bits_count(&s->gb) < 48
249 //       &&   !s->resync_marker
250        &&   !s->data_partitioning){
251         
252         const int bits_count= get_bits_count(&s->gb);
253         const int bits_left = s->gb.size_in_bits - bits_count;
254         
255         if(bits_left==0){
256             s->padding_bug_score+=16;
257         }else if(bits_left>8){
258             s->padding_bug_score++;
259         } else if(bits_left != 1){
260             int v= show_bits(&s->gb, 8);
261             v|= 0x7F >> (7-(bits_count&7));
262
263             if(v==0x7F)
264                 s->padding_bug_score--;
265             else
266                 s->padding_bug_score++;            
267         }                          
268     }
269
270     // handle formats which dont have unique end markers
271     if(s->msmpeg4_version || (s->workaround_bugs&FF_BUG_NO_PADDING)){ //FIXME perhaps solve this more cleanly
272         int left= s->gb.size_in_bits - get_bits_count(&s->gb);
273         int max_extra=7;
274         
275         /* no markers in M$ crap */
276         if(s->msmpeg4_version && s->pict_type==I_TYPE)
277             max_extra+= 17;
278         
279         /* buggy padding but the frame should still end approximately at the bitstream end */
280         if((s->workaround_bugs&FF_BUG_NO_PADDING) && s->error_resilience>=3)
281             max_extra+= 48;
282         else if((s->workaround_bugs&FF_BUG_NO_PADDING))
283             max_extra+= 256*256*256*64;
284         
285         if(left>max_extra){
286             fprintf(stderr, "discarding %d junk bits at end, next would be %X\n", left, show_bits(&s->gb, 24));
287         }
288         else if(left<0){
289             fprintf(stderr, "overreading %d bits\n", -left);
290         }else
291             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);
292         
293         return 0;
294     }
295
296     fprintf(stderr, "slice end not reached but screenspace end (%d left %06X)\n", 
297             s->gb.size_in_bits - get_bits_count(&s->gb),
298             show_bits(&s->gb, 24));
299             
300     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
301
302     return -1;
303 }
304
305 /**
306  * finds the end of the current frame in the bitstream.
307  * @return the position of the first byte of the next frame, or -1
308  */
309 static int mpeg4_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
310     ParseContext *pc= &s->parse_context;
311     int vop_found, i;
312     uint32_t state;
313     
314     vop_found= pc->frame_start_found;
315     state= pc->state;
316     
317     i=0;
318     if(!vop_found){
319         for(i=0; i<buf_size; i++){
320             state= (state<<8) | buf[i];
321             if(state == 0x1B6){
322                 i++;
323                 vop_found=1;
324                 break;
325             }
326         }
327     }
328     
329     for(; i<buf_size; i++){
330         state= (state<<8) | buf[i];
331         if((state&0xFFFFFF00) == 0x100){
332             pc->frame_start_found=0;
333             pc->state=-1; 
334             return i-3;
335         }
336     }
337     pc->frame_start_found= vop_found;
338     pc->state= state;
339     return -1;
340 }
341
342 /**
343  * draws an line from (ex, ey) -> (sx, sy).
344  * @param w width of the image
345  * @param h height of the image
346  * @param stride stride/linesize of the image
347  * @param color color of the arrow
348  */
349 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
350     int t, x, y, f;
351     
352     ex= clip(ex, 0, w-1);
353     ey= clip(ey, 0, h-1);
354     
355     buf[sy*stride + sx]+= color;
356     
357     if(ABS(ex - sx) > ABS(ey - sy)){
358         if(sx > ex){
359             t=sx; sx=ex; ex=t;
360             t=sy; sy=ey; ey=t;
361         }
362         buf+= sx + sy*stride;
363         ex-= sx;
364         f= ((ey-sy)<<16)/ex;
365         for(x= 0; x <= ex; x++){
366             y= ((x*f) + (1<<15))>>16;
367             buf[y*stride + x]+= color;
368         }
369     }else{
370         if(sy > ey){
371             t=sx; sx=ex; ex=t;
372             t=sy; sy=ey; ey=t;
373         }
374         buf+= sx + sy*stride;
375         ey-= sy;
376         if(ey) f= ((ex-sx)<<16)/ey;
377         else   f= 0;
378         for(y= 0; y <= ey; y++){
379             x= ((y*f) + (1<<15))>>16;
380             buf[y*stride + x]+= color;
381         }
382     }
383 }
384
385 /**
386  * draws an arrow from (ex, ey) -> (sx, sy).
387  * @param w width of the image
388  * @param h height of the image
389  * @param stride stride/linesize of the image
390  * @param color color of the arrow
391  */
392 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 
393     int dx= ex - sx;
394     int dy= ey - sy;
395     
396     if(dx*dx + dy*dy > 3*3){
397         int rx=  dx + dy;
398         int ry= -dx + dy;
399         int length= ff_sqrt((rx*rx + ry*ry)<<8);
400         
401         //FIXME subpixel accuracy
402         rx= ROUNDED_DIV(rx*3<<4, length);
403         ry= ROUNDED_DIV(ry*3<<4, length);
404         
405         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
406         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
407     }
408     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
409 }
410
411 int ff_h263_decode_frame(AVCodecContext *avctx, 
412                              void *data, int *data_size,
413                              uint8_t *buf, int buf_size)
414 {
415     MpegEncContext *s = avctx->priv_data;
416     int ret,i;
417     AVFrame *pict = data; 
418     float new_aspect;
419     
420 #ifdef PRINT_FRAME_TIME
421 uint64_t time= rdtsc();
422 #endif
423 #ifdef DEBUG
424     printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
425     printf("bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
426 #endif
427     s->flags= avctx->flags;
428
429     *data_size = 0;
430    
431    /* no supplementary picture */
432     if (buf_size == 0) {
433         return 0;
434     }
435
436     if(s->flags&CODEC_FLAG_TRUNCATED){
437         int next;
438         
439         if(s->codec_id==CODEC_ID_MPEG4){
440             next= mpeg4_find_frame_end(s, buf, buf_size);
441         }else{
442             fprintf(stderr, "this codec doesnt support truncated bitstreams\n");
443             return -1;
444         }
445         
446         if( ff_combine_frame(s, next, &buf, &buf_size) < 0 )
447             return buf_size;
448     }
449
450 retry:
451     
452     if(s->bitstream_buffer_size && buf_size<20){ //divx 5.01+ frame reorder
453         init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8);
454     }else
455         init_get_bits(&s->gb, buf, buf_size*8);
456     s->bitstream_buffer_size=0;
457
458     if (!s->context_initialized) {
459         if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
460             return -1;
461     }
462       
463     /* let's go :-) */
464     if (s->msmpeg4_version==5) {
465         ret= ff_wmv2_decode_picture_header(s);
466     } else if (s->msmpeg4_version) {
467         ret = msmpeg4_decode_picture_header(s);
468     } else if (s->h263_pred) {
469         if(s->avctx->extradata_size && s->picture_number==0){
470             GetBitContext gb;
471             
472             init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8);
473             ret = ff_mpeg4_decode_picture_header(s, &gb);
474         }
475         ret = ff_mpeg4_decode_picture_header(s, &s->gb);
476
477         if(s->flags& CODEC_FLAG_LOW_DELAY)
478             s->low_delay=1;
479     } else if (s->h263_intel) {
480         ret = intel_h263_decode_picture_header(s);
481     } else {
482         ret = h263_decode_picture_header(s);
483     }
484     avctx->has_b_frames= !s->low_delay;
485
486     if(s->workaround_bugs&FF_BUG_AUTODETECT){
487         if(s->padding_bug_score > -2 && !s->data_partitioning)
488             s->workaround_bugs |=  FF_BUG_NO_PADDING;
489         else
490             s->workaround_bugs &= ~FF_BUG_NO_PADDING;
491
492         if(s->avctx->codec_tag == ff_get_fourcc("XVIX")) 
493             s->workaround_bugs|= FF_BUG_XVID_ILACE;
494 #if 0
495         if(s->avctx->codec_tag == ff_get_fourcc("MP4S")) 
496             s->workaround_bugs|= FF_BUG_AC_VLC;
497         
498         if(s->avctx->codec_tag == ff_get_fourcc("M4S2")) 
499             s->workaround_bugs|= FF_BUG_AC_VLC;
500 #endif
501         if(s->avctx->codec_tag == ff_get_fourcc("UMP4")){
502             s->workaround_bugs|= FF_BUG_UMP4;
503             s->workaround_bugs|= FF_BUG_AC_VLC;
504         }
505
506         if(s->divx_version){
507             s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
508         }
509
510         if(s->divx_version>502){
511             s->workaround_bugs|= FF_BUG_QPEL_CHROMA2;
512         }
513
514         if(s->avctx->codec_tag == ff_get_fourcc("XVID") && s->xvid_build==0)
515             s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
516         
517         if(s->avctx->codec_tag == ff_get_fourcc("XVID") && s->xvid_build==0)
518             s->padding_bug_score= 256*256*256*64;
519         
520         if(s->xvid_build && s->xvid_build<=3)
521             s->padding_bug_score= 256*256*256*64;
522         
523         if(s->xvid_build && s->xvid_build<=1)
524             s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
525
526 #define SET_QPEL_FUNC(postfix1, postfix2) \
527     s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\
528     s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\
529     s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
530
531         if(s->lavc_build && s->lavc_build<4653)
532             s->workaround_bugs|= FF_BUG_STD_QPEL;
533         
534         if(s->lavc_build && s->lavc_build<4655)
535             s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
536
537         if(s->divx_version)
538             s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
539 //printf("padding_bug_score: %d\n", s->padding_bug_score);
540         if(s->divx_version==501 && s->divx_build==20020416)
541             s->padding_bug_score= 256*256*256*64;
542
543         if(s->divx_version>=500){
544             s->workaround_bugs|= FF_BUG_EDGE;
545         }
546
547 #if 0
548         if(s->divx_version==500)
549             s->padding_bug_score= 256*256*256*64;
550
551         /* very ugly XVID padding bug detection FIXME/XXX solve this differently
552          * lets hope this at least works
553          */
554         if(   s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0
555            && s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)
556             s->workaround_bugs|= FF_BUG_NO_PADDING;
557         
558         if(s->lavc_build && s->lavc_build<4609) //FIXME not sure about the version num but a 4609 file seems ok
559             s->workaround_bugs|= FF_BUG_NO_PADDING;
560 #endif
561     }
562     
563     if(s->workaround_bugs& FF_BUG_STD_QPEL){
564         SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)
565         SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)
566         SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)
567         SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)
568         SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)
569         SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)
570
571         SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)
572         SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)
573         SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)
574         SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)
575         SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)
576         SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)
577     }
578
579 #if 0 // dump bits per frame / qp / complexity
580 {
581     static FILE *f=NULL;
582     if(!f) f=fopen("rate_qp_cplx.txt", "w");
583     fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale);
584 }
585 #endif
586        
587         /* After H263 & mpeg4 header decode we have the height, width,*/
588         /* and other parameters. So then we could init the picture   */
589         /* FIXME: By the way H263 decoder is evolving it should have */
590         /* an H263EncContext                                         */
591     if(s->aspected_height)
592         new_aspect= s->aspected_width*s->width / (float)(s->height*s->aspected_height);
593     else
594         new_aspect=0;
595     
596     if (   s->width != avctx->width || s->height != avctx->height 
597         || ABS(new_aspect - avctx->aspect_ratio) > 0.001) {
598         /* H.263 could change picture size any time */
599         MPV_common_end(s);
600     }
601     if (!s->context_initialized) {
602         avctx->width = s->width;
603         avctx->height = s->height;
604         avctx->aspect_ratio= new_aspect;
605
606         goto retry;
607     }
608
609     if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P))
610         s->gob_index = ff_h263_get_gob_height(s);
611
612     if(ret==FRAME_SKIPED) return get_consumed_bytes(s, buf_size);
613     /* skip if the header was thrashed */
614     if (ret < 0){
615         fprintf(stderr, "header damaged\n");
616         return -1;
617     }
618     
619     // for hurry_up==5
620     s->current_picture.pict_type= s->pict_type;
621     s->current_picture.key_frame= s->pict_type == I_TYPE;
622
623     /* skip b frames if we dont have reference frames */
624     if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);
625     /* skip b frames if we are in a hurry */
626     if(avctx->hurry_up && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);
627     /* skip everything if we are in a hurry>=5 */
628     if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);
629     
630     if(s->next_p_frame_damaged){
631         if(s->pict_type==B_TYPE)
632             return get_consumed_bytes(s, buf_size);
633         else
634             s->next_p_frame_damaged=0;
635     }
636
637     if(MPV_frame_start(s, avctx) < 0)
638         return -1;
639
640 #ifdef DEBUG
641     printf("qscale=%d\n", s->qscale);
642 #endif
643
644     ff_er_frame_start(s);
645     
646     /* decode each macroblock */
647     s->block_wrap[0]=
648     s->block_wrap[1]=
649     s->block_wrap[2]=
650     s->block_wrap[3]= s->mb_width*2 + 2;
651     s->block_wrap[4]=
652     s->block_wrap[5]= s->mb_width + 2;
653     s->mb_x=0; 
654     s->mb_y=0;
655     
656     decode_slice(s);
657     while(s->mb_y<s->mb_height && s->gb.size_in_bits - get_bits_count(&s->gb)>16){
658         if(s->msmpeg4_version){
659             if(s->mb_x!=0 || (s->mb_y%s->slice_height)!=0)
660                 break;
661         }else{
662             if(ff_h263_resync(s)<0)
663                 break;
664         }
665         
666         if(s->msmpeg4_version<4 && s->h263_pred)
667             ff_mpeg4_clean_buffers(s);
668
669         decode_slice(s);
670     }
671
672     if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE)
673         if(msmpeg4_decode_ext_header(s, buf_size) < 0){
674             s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;
675         }
676     
677     /* divx 5.01+ bistream reorder stuff */
678     if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_version>=500){
679         int current_pos= get_bits_count(&s->gb)>>3;
680
681         if(   buf_size - current_pos > 5 
682            && buf_size - current_pos < BITSTREAM_BUFFER_SIZE){
683             int i;
684             int startcode_found=0;
685             for(i=current_pos; i<buf_size-3; i++){
686                 if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){
687                     startcode_found=1;
688                     break;
689                 }
690             }
691             if(startcode_found){
692                 memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos);
693                 s->bitstream_buffer_size= buf_size - current_pos;
694             }
695         }
696     }
697
698     ff_er_frame_end(s);
699
700     MPV_frame_end(s);
701
702     if((avctx->debug&FF_DEBUG_VIS_MV) && s->last_picture_ptr){
703         const int shift= 1 + s->quarter_sample;
704         int mb_y;
705         uint8_t *ptr= s->last_picture.data[0];
706         s->low_delay=0; //needed to see the vectors without trashing the buffers
707
708         for(mb_y=0; mb_y<s->mb_height; mb_y++){
709             int mb_x;
710             for(mb_x=0; mb_x<s->mb_width; mb_x++){
711                 const int mb_index= mb_x + mb_y*s->mb_width;
712                 if(s->co_located_type_table[mb_index] == MV_TYPE_8X8){
713                     int i;
714                     for(i=0; i<4; i++){
715                         int sx= mb_x*16 + 4 + 8*(i&1);
716                         int sy= mb_y*16 + 4 + 8*(i>>1);
717                         int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
718                         int mx= (s->motion_val[xy][0]>>shift) + sx;
719                         int my= (s->motion_val[xy][1]>>shift) + sy;
720                         draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
721                     }
722                 }else{
723                     int sx= mb_x*16 + 8;
724                     int sy= mb_y*16 + 8;
725                     int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
726                     int mx= (s->motion_val[xy][0]>>shift) + sx;
727                     int my= (s->motion_val[xy][1]>>shift) + sy;
728                     draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
729                 }
730                 s->mbskip_table[mb_index]=0;
731             }
732         }
733     }
734
735
736     if(s->pict_type==B_TYPE || s->low_delay){
737         *pict= *(AVFrame*)&s->current_picture;
738     } else {
739         *pict= *(AVFrame*)&s->last_picture;
740     }
741
742     if(avctx->debug&FF_DEBUG_QP){
743         int8_t *qtab= pict->qscale_table;
744         int x,y;
745         
746         for(y=0; y<s->mb_height; y++){
747             for(x=0; x<s->mb_width; x++){
748                 printf("%2d ", qtab[x + y*s->mb_width]);
749             }
750             printf("\n");
751         }
752         printf("\n");
753     }
754
755     /* Return the Picture timestamp as the frame number */
756     /* we substract 1 because it is added on utils.c    */
757     avctx->frame_number = s->picture_number - 1;
758
759     /* dont output the last pic after seeking */
760     if(s->last_picture_ptr || s->low_delay)
761         *data_size = sizeof(AVFrame);
762 #ifdef PRINT_FRAME_TIME
763 printf("%Ld\n", rdtsc()-time);
764 #endif
765     return get_consumed_bytes(s, buf_size);
766 }
767
768 static const AVOption mpeg4_decoptions[] =
769 {
770     AVOPTION_SUB(avoptions_workaround_bug),
771     AVOPTION_END()
772 };
773
774 AVCodec mpeg4_decoder = {
775     "mpeg4",
776     CODEC_TYPE_VIDEO,
777     CODEC_ID_MPEG4,
778     sizeof(MpegEncContext),
779     ff_h263_decode_init,
780     NULL,
781     ff_h263_decode_end,
782     ff_h263_decode_frame,
783     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
784     .options = mpeg4_decoptions,
785 };
786
787 AVCodec h263_decoder = {
788     "h263",
789     CODEC_TYPE_VIDEO,
790     CODEC_ID_H263,
791     sizeof(MpegEncContext),
792     ff_h263_decode_init,
793     NULL,
794     ff_h263_decode_end,
795     ff_h263_decode_frame,
796     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
797 };
798
799 AVCodec msmpeg4v1_decoder = {
800     "msmpeg4v1",
801     CODEC_TYPE_VIDEO,
802     CODEC_ID_MSMPEG4V1,
803     sizeof(MpegEncContext),
804     ff_h263_decode_init,
805     NULL,
806     ff_h263_decode_end,
807     ff_h263_decode_frame,
808     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
809     mpeg4_decoptions,
810 };
811
812 AVCodec msmpeg4v2_decoder = {
813     "msmpeg4v2",
814     CODEC_TYPE_VIDEO,
815     CODEC_ID_MSMPEG4V2,
816     sizeof(MpegEncContext),
817     ff_h263_decode_init,
818     NULL,
819     ff_h263_decode_end,
820     ff_h263_decode_frame,
821     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
822     mpeg4_decoptions,
823 };
824
825 AVCodec msmpeg4v3_decoder = {
826     "msmpeg4",
827     CODEC_TYPE_VIDEO,
828     CODEC_ID_MSMPEG4V3,
829     sizeof(MpegEncContext),
830     ff_h263_decode_init,
831     NULL,
832     ff_h263_decode_end,
833     ff_h263_decode_frame,
834     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
835     .options = mpeg4_decoptions,
836 };
837
838 AVCodec wmv1_decoder = {
839     "wmv1",
840     CODEC_TYPE_VIDEO,
841     CODEC_ID_WMV1,
842     sizeof(MpegEncContext),
843     ff_h263_decode_init,
844     NULL,
845     ff_h263_decode_end,
846     ff_h263_decode_frame,
847     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
848     mpeg4_decoptions,
849 };
850
851 AVCodec h263i_decoder = {
852     "h263i",
853     CODEC_TYPE_VIDEO,
854     CODEC_ID_H263I,
855     sizeof(MpegEncContext),
856     ff_h263_decode_init,
857     NULL,
858     ff_h263_decode_end,
859     ff_h263_decode_frame,
860     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
861     mpeg4_decoptions,
862 };
863