h263dec.c 25.1 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1
/*
Michael Niedermayer's avatar
Michael Niedermayer committed
2
 * H.263 decoder
Fabrice Bellard's avatar
Fabrice Bellard committed
3
 * Copyright (c) 2001 Fabrice Bellard.
Fabrice Bellard's avatar
Fabrice Bellard committed
4
 *
Fabrice Bellard's avatar
Fabrice Bellard committed
5 6 7 8
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
9
 *
Fabrice Bellard's avatar
Fabrice Bellard committed
10
 * This library is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Fabrice Bellard's avatar
Fabrice Bellard committed
12 13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
14
 *
Fabrice Bellard's avatar
Fabrice Bellard committed
15 16 17
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
Fabrice Bellard's avatar
Fabrice Bellard committed
18
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
19 20 21 22 23 24
 
/**
 * @file h263dec.c
 * H.263 decoder.
 */
 
Fabrice Bellard's avatar
Fabrice Bellard committed
25
#include "avcodec.h"
26
#include "dsputil.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
27 28 29
#include "mpegvideo.h"

//#define DEBUG
30 31 32 33 34 35 36 37 38 39 40 41
//#define PRINT_FRAME_TIME
#ifdef PRINT_FRAME_TIME
static inline long long rdtsc()
{
	long long l;
	asm volatile(	"rdtsc\n\t"
		: "=A" (l)
	);
//	printf("%d\n", int(l/1000));
	return l;
}
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
42

Michael Niedermayer's avatar
Michael Niedermayer committed
43
int ff_h263_decode_init(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
44 45
{
    MpegEncContext *s = avctx->priv_data;
46

Fabrice Bellard's avatar
Fabrice Bellard committed
47
    s->avctx = avctx;
Fabrice Bellard's avatar
Fabrice Bellard committed
48 49 50 51
    s->out_format = FMT_H263;

    s->width = avctx->width;
    s->height = avctx->height;
52
    s->workaround_bugs= avctx->workaround_bugs;
Fabrice Bellard's avatar
Fabrice Bellard committed
53

54 55 56 57
    // set defaults
    s->quant_precision=5;
    s->progressive_sequence=1;
    s->decode_mb= ff_h263_decode_mb;
Michael Niedermayer's avatar
Michael Niedermayer committed
58
    s->low_delay= 1;
59
    avctx->pix_fmt= PIX_FMT_YUV420P;
60

Fabrice Bellard's avatar
Fabrice Bellard committed
61 62 63
    /* select sub codec */
    switch(avctx->codec->id) {
    case CODEC_ID_H263:
64
        s->gob_number = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
65
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
66
    case CODEC_ID_MPEG4:
Fabrice Bellard's avatar
Fabrice Bellard committed
67 68
        s->time_increment_bits = 4; /* default value for broken headers */
        s->h263_pred = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
69
        s->low_delay = 0; //default, might be overriden in the vol header during header parsing
Fabrice Bellard's avatar
Fabrice Bellard committed
70
        break;
71
    case CODEC_ID_MSMPEG4V1:
Fabrice Bellard's avatar
Fabrice Bellard committed
72 73
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
74 75 76 77 78 79 80 81 82 83 84
        s->msmpeg4_version=1;
        break;
    case CODEC_ID_MSMPEG4V2:
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->msmpeg4_version=2;
        break;
    case CODEC_ID_MSMPEG4V3:
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->msmpeg4_version=3;
Fabrice Bellard's avatar
Fabrice Bellard committed
85
        break;
86 87 88 89 90
    case CODEC_ID_WMV1:
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->msmpeg4_version=4;
        break;
91 92 93 94 95
    case CODEC_ID_WMV2:
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->msmpeg4_version=5;
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
96 97 98
    case CODEC_ID_H263I:
        s->h263_intel = 1;
        break;
99 100 101
    case CODEC_ID_FLV1:
        s->h263_flv = 1;
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
102 103 104
    default:
        return -1;
    }
105
    s->codec_id= avctx->codec->id;
106

Fabrice Bellard's avatar
Fabrice Bellard committed
107
    /* for h263, we allocate the images after having read the header */
108
    if (avctx->codec->id != CODEC_ID_H263 && avctx->codec->id != CODEC_ID_MPEG4)
109 110
        if (MPV_common_init(s) < 0)
            return -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
111 112

    if (s->h263_msmpeg4)
113
        ff_msmpeg4_decode_init(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
114 115 116 117 118 119
    else
        h263_decode_init_vlc(s);
    
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
120
int ff_h263_decode_end(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
121 122 123 124 125 126 127
{
    MpegEncContext *s = avctx->priv_data;

    MPV_common_end(s);
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
128 129 130 131 132
/**
 * retunrs the number of bytes consumed for building the current frame
 */
static int get_consumed_bytes(MpegEncContext *s, int buf_size){
    int pos= (get_bits_count(&s->gb)+7)>>3;
133
    
134
    if(s->divx_packed){
Michael Niedermayer's avatar
Michael Niedermayer committed
135 136
        //we would have to scan through the whole buf to handle the weird reordering ...
        return buf_size; 
137 138 139 140
    }else if(s->flags&CODEC_FLAG_TRUNCATED){
        pos -= s->parse_context.last_index;
        if(pos<0) pos=0; // padding is not really read so this might be -1
        return pos;
Michael Niedermayer's avatar
Michael Niedermayer committed
141 142
    }else{
        if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
143
        if(pos+10>buf_size) pos=buf_size; // oops ;)
Michael Niedermayer's avatar
Michael Niedermayer committed
144 145 146 147 148

        return pos;
    }
}

149
static int decode_slice(MpegEncContext *s){
150
    const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
    s->last_resync_gb= s->gb;
    s->first_slice_line= 1;
        
    s->resync_mb_x= s->mb_x;
    s->resync_mb_y= s->mb_y;

    s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
    s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
    
    if(s->partitioned_frame){
        const int qscale= s->qscale;

        if(s->codec_id==CODEC_ID_MPEG4){
            if(ff_mpeg4_decode_partitions(s) < 0)
                return -1; 
        }
        
Fabrice Bellard's avatar
Fabrice Bellard committed
168
        /* restore variables which were modified */
169 170 171 172 173 174 175 176 177 178 179 180
        s->first_slice_line=1;
        s->mb_x= s->resync_mb_x;
        s->mb_y= s->resync_mb_y;
        s->qscale= qscale;
        s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
        s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
    }

    for(; s->mb_y < s->mb_height; s->mb_y++) {
        /* per-row end of slice checks */
        if(s->msmpeg4_version){
            if(s->resync_mb_y + s->slice_height == s->mb_y){
181 182
                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);

183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
                return 0;
            }
        }
        
        if(s->msmpeg4_version==1){
            s->last_dc[0]=
            s->last_dc[1]=
            s->last_dc[2]= 128;
        }
    
        ff_init_block_index(s);
        for(; s->mb_x < s->mb_width; s->mb_x++) {
            int ret;

            ff_update_block_index(s);

            if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
                s->first_slice_line=0; 
            }

            /* DCT & quantize */
204
	    s->dsp.clear_blocks(s->block[0]);
205 206 207
            
            s->mv_dir = MV_DIR_FORWARD;
            s->mv_type = MV_TYPE_16X16;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
208
//            s->mb_skiped = 0;
209 210 211
//printf("%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
            ret= s->decode_mb(s, s->block);

212 213 214
            if (s->pict_type!=B_TYPE)
                ff_h263_update_motion_val(s);

215
            if(ret<0){
216
                const int xy= s->mb_x + s->mb_y*s->mb_stride;
217
                if(ret==SLICE_END){
218 219
                    MPV_decode_mb(s, s->block);

220
//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));
221
                    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);
222 223 224

                    s->padding_bug_score--;
                        
225 226
                    if(++s->mb_x >= s->mb_width){
                        s->mb_x=0;
227
                        ff_draw_horiz_band(s, s->mb_y*16, 16);
228 229 230 231 232
                        s->mb_y++;
                    }
                    return 0; 
                }else if(ret==SLICE_NOEND){
                    fprintf(stderr,"Slice mismatch at MB: %d\n", xy);
233
                    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);
234 235 236
                    return -1;
                }
                fprintf(stderr,"Error at MB: %d\n", xy);
237
                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);
238 239 240
    
                return -1;
            }
241 242

            MPV_decode_mb(s, s->block);
243 244
        }
        
245
        ff_draw_horiz_band(s, s->mb_y*16, 16);
246 247 248 249 250 251
        
        s->mb_x= 0;
    }
    
    assert(s->mb_x==0 && s->mb_y==s->mb_height);

252 253 254
    /* try to detect the padding bug */
    if(      s->codec_id==CODEC_ID_MPEG4
       &&   (s->workaround_bugs&FF_BUG_AUTODETECT) 
255 256
       &&    s->gb.size_in_bits - get_bits_count(&s->gb) >=0
       &&    s->gb.size_in_bits - get_bits_count(&s->gb) < 48
257
//       &&   !s->resync_marker
258 259 260
       &&   !s->data_partitioning){
        
        const int bits_count= get_bits_count(&s->gb);
261
        const int bits_left = s->gb.size_in_bits - bits_count;
262
        
263 264 265
        if(bits_left==0){
            s->padding_bug_score+=16;
        }else if(bits_left>8){
266
            s->padding_bug_score++;
267
        } else if(bits_left != 1){
268 269
            int v= show_bits(&s->gb, 8);
            v|= 0x7F >> (7-(bits_count&7));
270

271 272 273 274
            if(v==0x7F)
                s->padding_bug_score--;
            else
                s->padding_bug_score++;            
275
        }                          
276 277
    }

278
    // handle formats which dont have unique end markers
279
    if(s->msmpeg4_version || (s->workaround_bugs&FF_BUG_NO_PADDING)){ //FIXME perhaps solve this more cleanly
280
        int left= s->gb.size_in_bits - get_bits_count(&s->gb);
281 282 283 284 285 286 287
        int max_extra=7;
        
        /* no markers in M$ crap */
        if(s->msmpeg4_version && s->pict_type==I_TYPE)
            max_extra+= 17;
        
        /* buggy padding but the frame should still end approximately at the bitstream end */
288
        if((s->workaround_bugs&FF_BUG_NO_PADDING) && s->error_resilience>=3)
289
            max_extra+= 48;
290
        else if((s->workaround_bugs&FF_BUG_NO_PADDING))
291 292 293 294 295 296 297 298
            max_extra+= 256*256*256*64;
        
        if(left>max_extra){
            fprintf(stderr, "discarding %d junk bits at end, next would be %X\n", left, show_bits(&s->gb, 24));
        }
        else if(left<0){
            fprintf(stderr, "overreading %d bits\n", -left);
        }else
299
            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);
300 301 302
        
        return 0;
    }
303

304
    fprintf(stderr, "slice end not reached but screenspace end (%d left %06X, score= %d)\n", 
305
            s->gb.size_in_bits - get_bits_count(&s->gb),
306
            show_bits(&s->gb, 24), s->padding_bug_score);
307 308 309
            
    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);

310 311 312
    return -1;
}

313 314 315 316
/**
 * finds the end of the current frame in the bitstream.
 * @return the position of the first byte of the next frame, or -1
 */
317
static int mpeg4_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
    ParseContext *pc= &s->parse_context;
    int vop_found, i;
    uint32_t state;
    
    vop_found= pc->frame_start_found;
    state= pc->state;
    
    i=0;
    if(!vop_found){
        for(i=0; i<buf_size; i++){
            state= (state<<8) | buf[i];
            if(state == 0x1B6){
                i++;
                vop_found=1;
                break;
            }
        }
    }
336 337 338

    if(vop_found){    
      for(; i<buf_size; i++){
339 340 341 342 343 344
        state= (state<<8) | buf[i];
        if((state&0xFFFFFF00) == 0x100){
            pc->frame_start_found=0;
            pc->state=-1; 
            return i-3;
        }
345
      }
346 347 348
    }
    pc->frame_start_found= vop_found;
    pc->state= state;
Michael Niedermayer's avatar
tired  
Michael Niedermayer committed
349
    return END_NOT_FOUND;
350 351
}

352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
static int h263_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
    ParseContext *pc= &s->parse_context;
    int vop_found, i;
    uint32_t state;
    
    vop_found= pc->frame_start_found;
    state= pc->state;
    
    i=0;
    if(!vop_found){
        for(i=0; i<buf_size; i++){
            state= (state<<8) | buf[i];
            if(state>>(32-22) == 0x20){
                i++;
                vop_found=1;
                break;
            }
        }
    }

    if(vop_found){    
      for(; i<buf_size; i++){
        state= (state<<8) | buf[i];
        if(state>>(32-22) == 0x20){
            pc->frame_start_found=0;
            pc->state=-1; 
            return i-3;
        }
      }
    }
    pc->frame_start_found= vop_found;
    pc->state= state;
    
    return END_NOT_FOUND;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
388
int ff_h263_decode_frame(AVCodecContext *avctx, 
Fabrice Bellard's avatar
Fabrice Bellard committed
389
                             void *data, int *data_size,
390
                             uint8_t *buf, int buf_size)
Fabrice Bellard's avatar
Fabrice Bellard committed
391 392
{
    MpegEncContext *s = avctx->priv_data;
Fabrice Bellard's avatar
Fabrice Bellard committed
393
    int ret;
Michael Niedermayer's avatar
Michael Niedermayer committed
394
    AVFrame *pict = data; 
Michael Niedermayer's avatar
Michael Niedermayer committed
395 396
    float new_aspect;
    
397 398 399
#ifdef PRINT_FRAME_TIME
uint64_t time= rdtsc();
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
400 401 402 403
#ifdef DEBUG
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
    printf("bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
404
    s->flags= avctx->flags;
405

Michael Niedermayer's avatar
Michael Niedermayer committed
406
    *data_size = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
407 408

    /* no supplementary picture */
Fabrice Bellard's avatar
Fabrice Bellard committed
409
    if (buf_size == 0) {
Michael Niedermayer's avatar
Michael Niedermayer committed
410 411 412 413 414 415 416 417
        /* special case for last picture */
        if (s->low_delay==0 && s->next_picture_ptr) {
            *pict= *(AVFrame*)s->next_picture_ptr;
            s->next_picture_ptr= NULL;

            *data_size = sizeof(AVFrame);
        }

Fabrice Bellard's avatar
Fabrice Bellard committed
418 419
        return 0;
    }
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
420

421 422 423 424 425
    if(s->flags&CODEC_FLAG_TRUNCATED){
        int next;
        
        if(s->codec_id==CODEC_ID_MPEG4){
            next= mpeg4_find_frame_end(s, buf, buf_size);
426 427
        }else if(s->codec_id==CODEC_ID_H263){
            next= h263_find_frame_end(s, buf, buf_size);
428 429 430 431
        }else{
            fprintf(stderr, "this codec doesnt support truncated bitstreams\n");
            return -1;
        }
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
432 433
        
        if( ff_combine_frame(s, next, &buf, &buf_size) < 0 )
434 435
            return buf_size;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
436

437 438
retry:
    
439
    if(s->bitstream_buffer_size && buf_size<20){ //divx 5.01+ frame reorder
440
        init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8);
Michael Niedermayer's avatar
Michael Niedermayer committed
441
    }else
442
        init_get_bits(&s->gb, buf, buf_size*8);
443
    s->bitstream_buffer_size=0;
Fabrice Bellard's avatar
Fabrice Bellard committed
444

445
    if (!s->context_initialized) {
446
        if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
447 448
            return -1;
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
449
      
Fabrice Bellard's avatar
Fabrice Bellard committed
450
    /* let's go :-) */
Michael Niedermayer's avatar
Michael Niedermayer committed
451 452 453
    if (s->msmpeg4_version==5) {
        ret= ff_wmv2_decode_picture_header(s);
    } else if (s->msmpeg4_version) {
Fabrice Bellard's avatar
Fabrice Bellard committed
454 455
        ret = msmpeg4_decode_picture_header(s);
    } else if (s->h263_pred) {
456 457 458
        if(s->avctx->extradata_size && s->picture_number==0){
            GetBitContext gb;
            
459
            init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8);
460 461 462 463
            ret = ff_mpeg4_decode_picture_header(s, &gb);
        }
        ret = ff_mpeg4_decode_picture_header(s, &s->gb);

464 465
        if(s->flags& CODEC_FLAG_LOW_DELAY)
            s->low_delay=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
466 467
    } else if (s->h263_intel) {
        ret = intel_h263_decode_picture_header(s);
468 469
    } else if (s->h263_flv) {
        ret = flv_h263_decode_picture_header(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
470 471
    } else {
        ret = h263_decode_picture_header(s);
472
    }
473 474 475 476 477 478 479 480 481
    
    if(ret==FRAME_SKIPED) return get_consumed_bytes(s, buf_size);

    /* skip if the header was thrashed */
    if (ret < 0){
        fprintf(stderr, "header damaged\n");
        return -1;
    }
    
Michael Niedermayer's avatar
Michael Niedermayer committed
482
    avctx->has_b_frames= !s->low_delay;
483 484
    
    if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
485 486
        if(s->avctx->stream_codec_tag == ff_get_fourcc("XVID") || 
           s->avctx->codec_tag == ff_get_fourcc("XVID") || s->avctx->codec_tag == ff_get_fourcc("XVIX"))
487
            s->xvid_build= -1;
488
#if 0
489 490 491
        if(s->avctx->codec_tag == ff_get_fourcc("DIVX") && s->vo_type==0 && s->vol_control_parameters==1
           && s->padding_bug_score > 0 && s->low_delay) // XVID with modified fourcc 
            s->xvid_build= -1;
492 493
#endif
    }
494

495
    if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
496 497 498
        if(s->avctx->codec_tag == ff_get_fourcc("DIVX") && s->vo_type==0 && s->vol_control_parameters==0)
            s->divx_version= 400; //divx 4
    }
499 500

    if(s->workaround_bugs&FF_BUG_AUTODETECT){
501 502 503
        s->workaround_bugs &= ~FF_BUG_NO_PADDING;
        
        if(s->padding_bug_score > -2 && !s->data_partitioning && (s->divx_version || !s->resync_marker))
504 505
            s->workaround_bugs |=  FF_BUG_NO_PADDING;

506
        if(s->avctx->codec_tag == ff_get_fourcc("XVIX")) 
507
            s->workaround_bugs|= FF_BUG_XVID_ILACE;
508

509
        if(s->avctx->codec_tag == ff_get_fourcc("UMP4")){
510 511
            s->workaround_bugs|= FF_BUG_UMP4;
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
512

513
        if(s->divx_version>=500){
Michael Niedermayer's avatar
Michael Niedermayer committed
514 515
            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
516

Michael Niedermayer's avatar
Michael Niedermayer committed
517 518 519 520
        if(s->divx_version>502){
            s->workaround_bugs|= FF_BUG_QPEL_CHROMA2;
        }

521 522 523
        if(s->xvid_build && s->xvid_build<=3)
            s->padding_bug_score= 256*256*256*64;
        
Michael Niedermayer's avatar
Michael Niedermayer committed
524 525 526
        if(s->xvid_build && s->xvid_build<=1)
            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;

527 528 529
        if(s->xvid_build && s->xvid_build<=12)
            s->workaround_bugs|= FF_BUG_EDGE;

Michael Niedermayer's avatar
Michael Niedermayer committed
530 531 532 533 534 535 536 537
#define SET_QPEL_FUNC(postfix1, postfix2) \
    s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\
    s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\
    s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;

        if(s->lavc_build && s->lavc_build<4653)
            s->workaround_bugs|= FF_BUG_STD_QPEL;
        
538 539 540
        if(s->lavc_build && s->lavc_build<4655)
            s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;

Michael Niedermayer's avatar
10l ?  
Michael Niedermayer committed
541
        if(s->lavc_build && s->lavc_build<4670){
542 543 544
            s->workaround_bugs|= FF_BUG_EDGE;
        }

545 546
        if(s->divx_version)
            s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
547
//printf("padding_bug_score: %d\n", s->padding_bug_score);
548 549
        if(s->divx_version==501 && s->divx_build==20020416)
            s->padding_bug_score= 256*256*256*64;
550

551
        if(s->divx_version && s->divx_version<500){
552 553
            s->workaround_bugs|= FF_BUG_EDGE;
        }
554
        
555
#if 0
556
        if(s->divx_version==500)
557
            s->padding_bug_score= 256*256*256*64;
558 559 560 561 562 563 564 565 566 567

        /* very ugly XVID padding bug detection FIXME/XXX solve this differently
         * lets hope this at least works
         */
        if(   s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0
           && s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)
            s->workaround_bugs|= FF_BUG_NO_PADDING;
        
        if(s->lavc_build && s->lavc_build<4609) //FIXME not sure about the version num but a 4609 file seems ok
            s->workaround_bugs|= FF_BUG_NO_PADDING;
568
#endif
569 570
    }
    
Michael Niedermayer's avatar
Michael Niedermayer committed
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
    if(s->workaround_bugs& FF_BUG_STD_QPEL){
        SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)
        SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)
    }
586

587 588 589 590 591
    if(avctx->debug & FF_DEBUG_BUGS)
        printf("bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n", 
               s->workaround_bugs, s->lavc_build, s->xvid_build, s->divx_version, s->divx_build,
               s->divx_packed ? "p" : "");
    
592 593 594 595
#if 0 // dump bits per frame / qp / complexity
{
    static FILE *f=NULL;
    if(!f) f=fopen("rate_qp_cplx.txt", "w");
596
    fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale);
597 598
}
#endif
599
       
600
        /* After H263 & mpeg4 header decode we have the height, width,*/
601 602 603
        /* and other parameters. So then we could init the picture   */
        /* FIXME: By the way H263 decoder is evolving it should have */
        /* an H263EncContext                                         */
Michael Niedermayer's avatar
Michael Niedermayer committed
604
    if(s->aspected_height)
Michael Niedermayer's avatar
Michael Niedermayer committed
605
        new_aspect= s->aspected_width*s->width / (float)(s->height*s->aspected_height);
Michael Niedermayer's avatar
Michael Niedermayer committed
606 607
    else
        new_aspect=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
608
    
609
    if (   s->width != avctx->width || s->height != avctx->height 
Michael Niedermayer's avatar
Michael Niedermayer committed
610
        || ABS(new_aspect - avctx->aspect_ratio) > 0.001) {
611 612 613
        /* H.263 could change picture size any time */
        MPV_common_end(s);
    }
614
    if (!s->context_initialized) {
Michael Niedermayer's avatar
10l  
Michael Niedermayer committed
615 616
        avctx->width = s->width;
        avctx->height = s->height;
Michael Niedermayer's avatar
Michael Niedermayer committed
617
        avctx->aspect_ratio= new_aspect;
618

619
        goto retry;
Fabrice Bellard's avatar
Fabrice Bellard committed
620
    }
621 622 623

    if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P))
        s->gob_index = ff_h263_get_gob_height(s);
624
    
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
625 626 627
    // for hurry_up==5
    s->current_picture.pict_type= s->pict_type;
    s->current_picture.key_frame= s->pict_type == I_TYPE;
628

Michael Niedermayer's avatar
Michael Niedermayer committed
629
    /* skip b frames if we dont have reference frames */
630
    if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);
631
    /* skip b frames if we are in a hurry */
632
    if(avctx->hurry_up && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);
633
    /* skip everything if we are in a hurry>=5 */
634
    if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);
635 636 637
    
    if(s->next_p_frame_damaged){
        if(s->pict_type==B_TYPE)
Michael Niedermayer's avatar
Michael Niedermayer committed
638
            return get_consumed_bytes(s, buf_size);
639 640 641 642
        else
            s->next_p_frame_damaged=0;
    }

643 644
    if(MPV_frame_start(s, avctx) < 0)
        return -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
645 646 647 648 649

#ifdef DEBUG
    printf("qscale=%d\n", s->qscale);
#endif

650
    ff_er_frame_start(s);
651
    
Michael Niedermayer's avatar
Michael Niedermayer committed
652 653 654 655 656 657 658
    //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type
    //which isnt available before MPV_frame_start()
    if (s->msmpeg4_version==5){
        if(ff_wmv2_decode_secondary_picture_header(s) < 0)
            return -1;
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
659
    /* decode each macroblock */
660 661 662 663
    s->mb_x=0; 
    s->mb_y=0;
    
    decode_slice(s);
Michael Niedermayer's avatar
Michael Niedermayer committed
664
    while(s->mb_y<s->mb_height){
665
        if(s->msmpeg4_version){
Michael Niedermayer's avatar
Michael Niedermayer committed
666
            if(s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits)
667 668 669 670
                break;
        }else{
            if(ff_h263_resync(s)<0)
                break;
671 672
        }
        
Michael Niedermayer's avatar
Michael Niedermayer committed
673
        if(s->msmpeg4_version<4 && s->h263_pred)
674
            ff_mpeg4_clean_buffers(s);
675

676
        decode_slice(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
677
    }
678

679
    if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE)
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
680 681 682
        if(msmpeg4_decode_ext_header(s, buf_size) < 0){
            s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
683 684
    
    /* divx 5.01+ bistream reorder stuff */
685
    if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_packed){
686 687
        int current_pos= get_bits_count(&s->gb)>>3;

Michael Niedermayer's avatar
Michael Niedermayer committed
688 689
        if(   buf_size - current_pos > 5 
           && buf_size - current_pos < BITSTREAM_BUFFER_SIZE){
690 691
            int i;
            int startcode_found=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
692
            for(i=current_pos; i<buf_size-3; i++){
693 694 695 696 697 698 699 700 701 702 703 704
                if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){
                    startcode_found=1;
                    break;
                }
            }
            if(startcode_found){
                memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos);
                s->bitstream_buffer_size= buf_size - current_pos;
            }
        }
    }

705
    ff_er_frame_end(s);
706

Fabrice Bellard's avatar
Fabrice Bellard committed
707
    MPV_frame_end(s);
Michael Niedermayer's avatar
Michael Niedermayer committed
708

709 710
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
assert(s->current_picture.pict_type == s->pict_type);
Michael Niedermayer's avatar
Michael Niedermayer committed
711
    if(s->pict_type==B_TYPE || s->low_delay){
Michael Niedermayer's avatar
Michael Niedermayer committed
712
        *pict= *(AVFrame*)&s->current_picture;
713
        ff_print_debug_info(s, s->current_picture_ptr);
Michael Niedermayer's avatar
Michael Niedermayer committed
714
    } else {
Michael Niedermayer's avatar
Michael Niedermayer committed
715
        *pict= *(AVFrame*)&s->last_picture;
716
        ff_print_debug_info(s, s->last_picture_ptr);
Michael Niedermayer's avatar
Michael Niedermayer committed
717
    }
718

719 720 721 722
    /* Return the Picture timestamp as the frame number */
    /* we substract 1 because it is added on utils.c    */
    avctx->frame_number = s->picture_number - 1;

Michael Niedermayer's avatar
Michael Niedermayer committed
723
    /* dont output the last pic after seeking */
724
    if(s->last_picture_ptr || s->low_delay)
Michael Niedermayer's avatar
Michael Niedermayer committed
725
        *data_size = sizeof(AVFrame);
726 727 728
#ifdef PRINT_FRAME_TIME
printf("%Ld\n", rdtsc()-time);
#endif
729

Michael Niedermayer's avatar
Michael Niedermayer committed
730
    return get_consumed_bytes(s, buf_size);
Fabrice Bellard's avatar
Fabrice Bellard committed
731 732
}

733 734 735 736 737 738
static const AVOption mpeg4_decoptions[] =
{
    AVOPTION_SUB(avoptions_workaround_bug),
    AVOPTION_END()
};

Fabrice Bellard's avatar
Fabrice Bellard committed
739 740
AVCodec mpeg4_decoder = {
    "mpeg4",
Fabrice Bellard's avatar
Fabrice Bellard committed
741
    CODEC_TYPE_VIDEO,
Fabrice Bellard's avatar
Fabrice Bellard committed
742
    CODEC_ID_MPEG4,
Fabrice Bellard's avatar
Fabrice Bellard committed
743
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
744
    ff_h263_decode_init,
Fabrice Bellard's avatar
Fabrice Bellard committed
745
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
746 747
    ff_h263_decode_end,
    ff_h263_decode_frame,
748
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
749
    .options = mpeg4_decoptions,
Michael Niedermayer's avatar
Michael Niedermayer committed
750
    .flush= ff_mpeg_flush,
Fabrice Bellard's avatar
Fabrice Bellard committed
751 752 753 754 755 756 757
};

AVCodec h263_decoder = {
    "h263",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263,
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
758
    ff_h263_decode_init,
Fabrice Bellard's avatar
Fabrice Bellard committed
759
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
760 761
    ff_h263_decode_end,
    ff_h263_decode_frame,
762
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
Michael Niedermayer's avatar
Michael Niedermayer committed
763
    .flush= ff_mpeg_flush,
Fabrice Bellard's avatar
Fabrice Bellard committed
764 765
};

766 767 768 769 770
AVCodec msmpeg4v1_decoder = {
    "msmpeg4v1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V1,
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
771
    ff_h263_decode_init,
772
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
773 774
    ff_h263_decode_end,
    ff_h263_decode_frame,
775
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
776
    mpeg4_decoptions,
777 778 779 780 781 782 783
};

AVCodec msmpeg4v2_decoder = {
    "msmpeg4v2",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V2,
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
784
    ff_h263_decode_init,
785
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
786 787
    ff_h263_decode_end,
    ff_h263_decode_frame,
788
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
789
    mpeg4_decoptions,
790 791 792
};

AVCodec msmpeg4v3_decoder = {
Fabrice Bellard's avatar
Fabrice Bellard committed
793 794
    "msmpeg4",
    CODEC_TYPE_VIDEO,
795
    CODEC_ID_MSMPEG4V3,
Fabrice Bellard's avatar
Fabrice Bellard committed
796
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
797
    ff_h263_decode_init,
Fabrice Bellard's avatar
Fabrice Bellard committed
798
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
799 800
    ff_h263_decode_end,
    ff_h263_decode_frame,
801
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
802
    .options = mpeg4_decoptions,
Fabrice Bellard's avatar
Fabrice Bellard committed
803 804
};

805 806 807 808 809
AVCodec wmv1_decoder = {
    "wmv1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_WMV1,
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
810
    ff_h263_decode_init,
811
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
812 813
    ff_h263_decode_end,
    ff_h263_decode_frame,
814
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
815
    mpeg4_decoptions,
816 817
};

Fabrice Bellard's avatar
Fabrice Bellard committed
818 819 820 821 822
AVCodec h263i_decoder = {
    "h263i",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263I,
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
823
    ff_h263_decode_init,
Fabrice Bellard's avatar
Fabrice Bellard committed
824
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
825 826
    ff_h263_decode_end,
    ff_h263_decode_frame,
827
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
828
    mpeg4_decoptions,
Fabrice Bellard's avatar
Fabrice Bellard committed
829 830
};

831 832 833 834 835 836 837 838 839 840 841
AVCodec flv_decoder = {
    "flv",
    CODEC_TYPE_VIDEO,
    CODEC_ID_FLV1,
    sizeof(MpegEncContext),
    ff_h263_decode_init,
    NULL,
    ff_h263_decode_end,
    ff_h263_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1
};