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
//#define PRINT_FRAME_TIME
Fabrice Bellard's avatar
Fabrice Bellard committed
31

Michael Niedermayer's avatar
Michael Niedermayer committed
32
int ff_h263_decode_init(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
33 34
{
    MpegEncContext *s = avctx->priv_data;
35

Fabrice Bellard's avatar
Fabrice Bellard committed
36
    s->avctx = avctx;
Fabrice Bellard's avatar
Fabrice Bellard committed
37 38 39 40
    s->out_format = FMT_H263;

    s->width = avctx->width;
    s->height = avctx->height;
41
    s->workaround_bugs= avctx->workaround_bugs;
Fabrice Bellard's avatar
Fabrice Bellard committed
42

43 44 45 46
    // set defaults
    s->quant_precision=5;
    s->progressive_sequence=1;
    s->decode_mb= ff_h263_decode_mb;
Michael Niedermayer's avatar
Michael Niedermayer committed
47
    s->low_delay= 1;
48
    avctx->pix_fmt= PIX_FMT_YUV420P;
49
    s->unrestricted_mv= 1;
50

Fabrice Bellard's avatar
Fabrice Bellard committed
51 52 53
    /* select sub codec */
    switch(avctx->codec->id) {
    case CODEC_ID_H263:
54
        s->gob_number = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
55
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
56
    case CODEC_ID_MPEG4:
Fabrice Bellard's avatar
Fabrice Bellard committed
57 58
        s->time_increment_bits = 4; /* default value for broken headers */
        s->h263_pred = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
59
        s->low_delay = 0; //default, might be overriden in the vol header during header parsing
Fabrice Bellard's avatar
Fabrice Bellard committed
60
        break;
61
    case CODEC_ID_MSMPEG4V1:
Fabrice Bellard's avatar
Fabrice Bellard committed
62 63
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
64 65 66 67 68 69 70 71 72 73 74
        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
75
        break;
76 77 78 79 80
    case CODEC_ID_WMV1:
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->msmpeg4_version=4;
        break;
81 82 83 84 85
    case CODEC_ID_WMV2:
        s->h263_msmpeg4 = 1;
        s->h263_pred = 1;
        s->msmpeg4_version=5;
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
86 87 88
    case CODEC_ID_H263I:
        s->h263_intel = 1;
        break;
89 90 91
    case CODEC_ID_FLV1:
        s->h263_flv = 1;
        break;
Fabrice Bellard's avatar
Fabrice Bellard committed
92 93 94
    default:
        return -1;
    }
95
    s->codec_id= avctx->codec->id;
96

Fabrice Bellard's avatar
Fabrice Bellard committed
97
    /* for h263, we allocate the images after having read the header */
98
    if (avctx->codec->id != CODEC_ID_H263 && avctx->codec->id != CODEC_ID_MPEG4)
99 100
        if (MPV_common_init(s) < 0)
            return -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
101 102

    if (s->h263_msmpeg4)
103
        ff_msmpeg4_decode_init(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
104 105 106 107 108 109
    else
        h263_decode_init_vlc(s);
    
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
110
int ff_h263_decode_end(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
111 112 113 114 115 116 117
{
    MpegEncContext *s = avctx->priv_data;

    MPV_common_end(s);
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
118 119 120 121 122
/**
 * 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;
123
    
124
    if(s->divx_packed){
Michael Niedermayer's avatar
Michael Niedermayer committed
125 126
        //we would have to scan through the whole buf to handle the weird reordering ...
        return buf_size; 
127 128 129 130
    }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
131 132
    }else{
        if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
133
        if(pos+10>buf_size) pos=buf_size; // oops ;)
Michael Niedermayer's avatar
Michael Niedermayer committed
134 135 136 137 138

        return pos;
    }
}

139
static int decode_slice(MpegEncContext *s){
140
    const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
    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
158
        /* restore variables which were modified */
159 160 161 162 163 164 165 166 167 168 169 170
        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){
171 172
                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);

173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
                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 */
194
	    s->dsp.clear_blocks(s->block[0]);
195 196 197
            
            s->mv_dir = MV_DIR_FORWARD;
            s->mv_type = MV_TYPE_16X16;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
198
//            s->mb_skiped = 0;
199 200 201
//printf("%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
            ret= s->decode_mb(s, s->block);

202 203 204
            if (s->pict_type!=B_TYPE)
                ff_h263_update_motion_val(s);

205
            if(ret<0){
206
                const int xy= s->mb_x + s->mb_y*s->mb_stride;
207
                if(ret==SLICE_END){
208 209
                    MPV_decode_mb(s, s->block);

210
//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));
211
                    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);
212 213 214

                    s->padding_bug_score--;
                        
215 216
                    if(++s->mb_x >= s->mb_width){
                        s->mb_x=0;
217
                        ff_draw_horiz_band(s, s->mb_y*16, 16);
218 219 220 221 222
                        s->mb_y++;
                    }
                    return 0; 
                }else if(ret==SLICE_NOEND){
                    fprintf(stderr,"Slice mismatch at MB: %d\n", xy);
223
                    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);
224 225 226
                    return -1;
                }
                fprintf(stderr,"Error at MB: %d\n", xy);
227
                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);
228 229 230
    
                return -1;
            }
231 232

            MPV_decode_mb(s, s->block);
233 234
        }
        
235
        ff_draw_horiz_band(s, s->mb_y*16, 16);
236 237 238 239 240 241
        
        s->mb_x= 0;
    }
    
    assert(s->mb_x==0 && s->mb_y==s->mb_height);

242 243 244
    /* try to detect the padding bug */
    if(      s->codec_id==CODEC_ID_MPEG4
       &&   (s->workaround_bugs&FF_BUG_AUTODETECT) 
245 246
       &&    s->gb.size_in_bits - get_bits_count(&s->gb) >=0
       &&    s->gb.size_in_bits - get_bits_count(&s->gb) < 48
247
//       &&   !s->resync_marker
248 249 250
       &&   !s->data_partitioning){
        
        const int bits_count= get_bits_count(&s->gb);
251
        const int bits_left = s->gb.size_in_bits - bits_count;
252
        
253 254 255
        if(bits_left==0){
            s->padding_bug_score+=16;
        }else if(bits_left>8){
256
            s->padding_bug_score++;
257
        } else if(bits_left != 1){
258 259
            int v= show_bits(&s->gb, 8);
            v|= 0x7F >> (7-(bits_count&7));
260

261 262 263 264
            if(v==0x7F)
                s->padding_bug_score--;
            else
                s->padding_bug_score++;            
265
        }                          
266 267
    }

268
    // handle formats which dont have unique end markers
269
    if(s->msmpeg4_version || (s->workaround_bugs&FF_BUG_NO_PADDING)){ //FIXME perhaps solve this more cleanly
270
        int left= s->gb.size_in_bits - get_bits_count(&s->gb);
271 272 273 274 275 276 277
        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 */
278
        if((s->workaround_bugs&FF_BUG_NO_PADDING) && s->error_resilience>=3)
279
            max_extra+= 48;
280
        else if((s->workaround_bugs&FF_BUG_NO_PADDING))
281 282 283 284 285 286 287 288
            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
289
            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);
290 291 292
        
        return 0;
    }
293

294
    fprintf(stderr, "slice end not reached but screenspace end (%d left %06X, score= %d)\n", 
295
            s->gb.size_in_bits - get_bits_count(&s->gb),
296
            show_bits(&s->gb, 24), s->padding_bug_score);
297 298 299
            
    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);

300 301 302
    return -1;
}

303 304 305 306
/**
 * finds the end of the current frame in the bitstream.
 * @return the position of the first byte of the next frame, or -1
 */
307
static int mpeg4_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
    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;
            }
        }
    }
326 327 328

    if(vop_found){    
      for(; i<buf_size; i++){
329 330 331 332 333 334
        state= (state<<8) | buf[i];
        if((state&0xFFFFFF00) == 0x100){
            pc->frame_start_found=0;
            pc->state=-1; 
            return i-3;
        }
335
      }
336 337 338
    }
    pc->frame_start_found= vop_found;
    pc->state= state;
Michael Niedermayer's avatar
tired  
Michael Niedermayer committed
339
    return END_NOT_FOUND;
340 341
}

342 343 344 345 346 347 348 349 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
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
378
int ff_h263_decode_frame(AVCodecContext *avctx, 
Fabrice Bellard's avatar
Fabrice Bellard committed
379
                             void *data, int *data_size,
380
                             uint8_t *buf, int buf_size)
Fabrice Bellard's avatar
Fabrice Bellard committed
381 382
{
    MpegEncContext *s = avctx->priv_data;
Fabrice Bellard's avatar
Fabrice Bellard committed
383
    int ret;
Michael Niedermayer's avatar
Michael Niedermayer committed
384
    AVFrame *pict = data; 
Michael Niedermayer's avatar
Michael Niedermayer committed
385
    
386 387 388
#ifdef PRINT_FRAME_TIME
uint64_t time= rdtsc();
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
389 390 391 392
#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
393
    s->flags= avctx->flags;
394

Michael Niedermayer's avatar
Michael Niedermayer committed
395
    *data_size = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
396 397

    /* no supplementary picture */
Fabrice Bellard's avatar
Fabrice Bellard committed
398
    if (buf_size == 0) {
Michael Niedermayer's avatar
Michael Niedermayer committed
399 400 401 402 403 404 405 406
        /* 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
407 408
        return 0;
    }
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
409

410 411 412 413 414
    if(s->flags&CODEC_FLAG_TRUNCATED){
        int next;
        
        if(s->codec_id==CODEC_ID_MPEG4){
            next= mpeg4_find_frame_end(s, buf, buf_size);
415 416
        }else if(s->codec_id==CODEC_ID_H263){
            next= h263_find_frame_end(s, buf, buf_size);
417 418 419 420
        }else{
            fprintf(stderr, "this codec doesnt support truncated bitstreams\n");
            return -1;
        }
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
421 422
        
        if( ff_combine_frame(s, next, &buf, &buf_size) < 0 )
423 424
            return buf_size;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
425

426 427
retry:
    
428
    if(s->bitstream_buffer_size && buf_size<20){ //divx 5.01+ frame reorder
429
        init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8);
Michael Niedermayer's avatar
Michael Niedermayer committed
430
    }else
431
        init_get_bits(&s->gb, buf, buf_size*8);
432
    s->bitstream_buffer_size=0;
Fabrice Bellard's avatar
Fabrice Bellard committed
433

434
    if (!s->context_initialized) {
435
        if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
436 437
            return -1;
    }
438 439 440 441 442 443
    
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
        int i= ff_find_unused_picture(s, 0);
        s->current_picture_ptr= &s->picture[i];
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
444
      
Fabrice Bellard's avatar
Fabrice Bellard committed
445
    /* let's go :-) */
Michael Niedermayer's avatar
Michael Niedermayer committed
446 447 448
    if (s->msmpeg4_version==5) {
        ret= ff_wmv2_decode_picture_header(s);
    } else if (s->msmpeg4_version) {
Fabrice Bellard's avatar
Fabrice Bellard committed
449 450
        ret = msmpeg4_decode_picture_header(s);
    } else if (s->h263_pred) {
451 452 453
        if(s->avctx->extradata_size && s->picture_number==0){
            GetBitContext gb;
            
454
            init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8);
455 456 457 458
            ret = ff_mpeg4_decode_picture_header(s, &gb);
        }
        ret = ff_mpeg4_decode_picture_header(s, &s->gb);

459 460
        if(s->flags& CODEC_FLAG_LOW_DELAY)
            s->low_delay=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
461 462
    } else if (s->h263_intel) {
        ret = intel_h263_decode_picture_header(s);
463 464
    } else if (s->h263_flv) {
        ret = flv_h263_decode_picture_header(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
465 466
    } else {
        ret = h263_decode_picture_header(s);
467
    }
468 469 470 471 472 473 474 475 476
    
    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
477
    avctx->has_b_frames= !s->low_delay;
478 479
    
    if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
480 481
        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"))
482
            s->xvid_build= -1;
483
#if 0
484 485 486
        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;
487 488
#endif
    }
489

490
    if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
491 492 493
        if(s->avctx->codec_tag == ff_get_fourcc("DIVX") && s->vo_type==0 && s->vol_control_parameters==0)
            s->divx_version= 400; //divx 4
    }
494 495

    if(s->workaround_bugs&FF_BUG_AUTODETECT){
496 497 498
        s->workaround_bugs &= ~FF_BUG_NO_PADDING;
        
        if(s->padding_bug_score > -2 && !s->data_partitioning && (s->divx_version || !s->resync_marker))
499 500
            s->workaround_bugs |=  FF_BUG_NO_PADDING;

501
        if(s->avctx->codec_tag == ff_get_fourcc("XVIX")) 
502
            s->workaround_bugs|= FF_BUG_XVID_ILACE;
503

504
        if(s->avctx->codec_tag == ff_get_fourcc("UMP4")){
505 506
            s->workaround_bugs|= FF_BUG_UMP4;
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
507

508
        if(s->divx_version>=500){
Michael Niedermayer's avatar
Michael Niedermayer committed
509 510
            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
511

Michael Niedermayer's avatar
Michael Niedermayer committed
512 513 514 515
        if(s->divx_version>502){
            s->workaround_bugs|= FF_BUG_QPEL_CHROMA2;
        }

516 517 518
        if(s->xvid_build && s->xvid_build<=3)
            s->padding_bug_score= 256*256*256*64;
        
Michael Niedermayer's avatar
Michael Niedermayer committed
519 520 521
        if(s->xvid_build && s->xvid_build<=1)
            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;

522 523 524
        if(s->xvid_build && s->xvid_build<=12)
            s->workaround_bugs|= FF_BUG_EDGE;

Michael Niedermayer's avatar
Michael Niedermayer committed
525 526 527 528 529 530 531 532
#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;
        
533 534 535
        if(s->lavc_build && s->lavc_build<4655)
            s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;

Michael Niedermayer's avatar
10l ?  
Michael Niedermayer committed
536
        if(s->lavc_build && s->lavc_build<4670){
537 538 539
            s->workaround_bugs|= FF_BUG_EDGE;
        }

540 541
        if(s->divx_version)
            s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
542
//printf("padding_bug_score: %d\n", s->padding_bug_score);
543 544
        if(s->divx_version==501 && s->divx_build==20020416)
            s->padding_bug_score= 256*256*256*64;
545

546
        if(s->divx_version && s->divx_version<500){
547 548
            s->workaround_bugs|= FF_BUG_EDGE;
        }
549
        
550
#if 0
551
        if(s->divx_version==500)
552
            s->padding_bug_score= 256*256*256*64;
553 554 555 556 557 558 559 560 561 562

        /* 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;
563
#endif
564 565
    }
    
Michael Niedermayer's avatar
Michael Niedermayer committed
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
    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)
    }
581

582 583 584 585 586
    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" : "");
    
587 588 589 590
#if 0 // dump bits per frame / qp / complexity
{
    static FILE *f=NULL;
    if(!f) f=fopen("rate_qp_cplx.txt", "w");
591
    fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale);
592 593
}
#endif
594
       
595
        /* After H263 & mpeg4 header decode we have the height, width,*/
596 597 598
        /* 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
599
    
Michael Niedermayer's avatar
Michael Niedermayer committed
600
    if (   s->width != avctx->width || s->height != avctx->height) {
601
        /* H.263 could change picture size any time */
602 603
        ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat
        s->parse_context.buffer=0;
604
        MPV_common_end(s);
605
        s->parse_context= pc;
606
    }
607
    if (!s->context_initialized) {
Michael Niedermayer's avatar
10l  
Michael Niedermayer committed
608 609
        avctx->width = s->width;
        avctx->height = s->height;
610

611
        goto retry;
Fabrice Bellard's avatar
Fabrice Bellard committed
612
    }
613 614 615

    if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P))
        s->gob_index = ff_h263_get_gob_height(s);
616
    
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
617 618 619
    // for hurry_up==5
    s->current_picture.pict_type= s->pict_type;
    s->current_picture.key_frame= s->pict_type == I_TYPE;
620

Michael Niedermayer's avatar
Michael Niedermayer committed
621
    /* skip b frames if we dont have reference frames */
622
    if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);
623
    /* skip b frames if we are in a hurry */
624
    if(avctx->hurry_up && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);
625
    /* skip everything if we are in a hurry>=5 */
626
    if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);
627 628 629
    
    if(s->next_p_frame_damaged){
        if(s->pict_type==B_TYPE)
Michael Niedermayer's avatar
Michael Niedermayer committed
630
            return get_consumed_bytes(s, buf_size);
631 632 633 634
        else
            s->next_p_frame_damaged=0;
    }

635 636
    if(MPV_frame_start(s, avctx) < 0)
        return -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
637 638 639 640 641

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

642
    ff_er_frame_start(s);
643
    
Michael Niedermayer's avatar
Michael Niedermayer committed
644 645 646 647 648 649 650
    //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
651
    /* decode each macroblock */
652 653 654 655
    s->mb_x=0; 
    s->mb_y=0;
    
    decode_slice(s);
Michael Niedermayer's avatar
Michael Niedermayer committed
656
    while(s->mb_y<s->mb_height){
657
        if(s->msmpeg4_version){
Michael Niedermayer's avatar
Michael Niedermayer committed
658
            if(s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits)
659 660 661 662
                break;
        }else{
            if(ff_h263_resync(s)<0)
                break;
663 664
        }
        
Michael Niedermayer's avatar
Michael Niedermayer committed
665
        if(s->msmpeg4_version<4 && s->h263_pred)
666
            ff_mpeg4_clean_buffers(s);
667

668
        decode_slice(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
669
    }
670

671
    if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE)
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
672 673 674
        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
675 676
    
    /* divx 5.01+ bistream reorder stuff */
677
    if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_packed){
678 679
        int current_pos= get_bits_count(&s->gb)>>3;

Michael Niedermayer's avatar
Michael Niedermayer committed
680 681
        if(   buf_size - current_pos > 5 
           && buf_size - current_pos < BITSTREAM_BUFFER_SIZE){
682 683
            int i;
            int startcode_found=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
684
            for(i=current_pos; i<buf_size-3; i++){
685 686 687 688 689 690 691 692 693 694 695 696
                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;
            }
        }
    }

697
    ff_er_frame_end(s);
698

Fabrice Bellard's avatar
Fabrice Bellard committed
699
    MPV_frame_end(s);
Michael Niedermayer's avatar
Michael Niedermayer committed
700

701 702
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
703
    if(s->pict_type==B_TYPE || s->low_delay){
Michael Niedermayer's avatar
Michael Niedermayer committed
704
        *pict= *(AVFrame*)&s->current_picture;
705
        ff_print_debug_info(s, s->current_picture_ptr);
Michael Niedermayer's avatar
Michael Niedermayer committed
706
    } else {
Michael Niedermayer's avatar
Michael Niedermayer committed
707
        *pict= *(AVFrame*)&s->last_picture;
708
        ff_print_debug_info(s, s->last_picture_ptr);
Michael Niedermayer's avatar
Michael Niedermayer committed
709
    }
710

711 712 713 714
    /* 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
715
    /* dont output the last pic after seeking */
716
    if(s->last_picture_ptr || s->low_delay)
Michael Niedermayer's avatar
Michael Niedermayer committed
717
        *data_size = sizeof(AVFrame);
718 719 720
#ifdef PRINT_FRAME_TIME
printf("%Ld\n", rdtsc()-time);
#endif
721

Michael Niedermayer's avatar
Michael Niedermayer committed
722
    return get_consumed_bytes(s, buf_size);
Fabrice Bellard's avatar
Fabrice Bellard committed
723 724
}

725 726 727 728 729 730
static const AVOption mpeg4_decoptions[] =
{
    AVOPTION_SUB(avoptions_workaround_bug),
    AVOPTION_END()
};

Fabrice Bellard's avatar
Fabrice Bellard committed
731 732
AVCodec mpeg4_decoder = {
    "mpeg4",
Fabrice Bellard's avatar
Fabrice Bellard committed
733
    CODEC_TYPE_VIDEO,
Fabrice Bellard's avatar
Fabrice Bellard committed
734
    CODEC_ID_MPEG4,
Fabrice Bellard's avatar
Fabrice Bellard committed
735
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
736
    ff_h263_decode_init,
Fabrice Bellard's avatar
Fabrice Bellard committed
737
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
738 739
    ff_h263_decode_end,
    ff_h263_decode_frame,
740
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
741
    .options = mpeg4_decoptions,
Michael Niedermayer's avatar
Michael Niedermayer committed
742
    .flush= ff_mpeg_flush,
Fabrice Bellard's avatar
Fabrice Bellard committed
743 744 745 746 747 748 749
};

AVCodec h263_decoder = {
    "h263",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263,
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
750
    ff_h263_decode_init,
Fabrice Bellard's avatar
Fabrice Bellard committed
751
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
752 753
    ff_h263_decode_end,
    ff_h263_decode_frame,
754
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
Michael Niedermayer's avatar
Michael Niedermayer committed
755
    .flush= ff_mpeg_flush,
Fabrice Bellard's avatar
Fabrice Bellard committed
756 757
};

758 759 760 761 762
AVCodec msmpeg4v1_decoder = {
    "msmpeg4v1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V1,
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
763
    ff_h263_decode_init,
764
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
765 766
    ff_h263_decode_end,
    ff_h263_decode_frame,
767
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
768
    mpeg4_decoptions,
769 770 771 772 773 774 775
};

AVCodec msmpeg4v2_decoder = {
    "msmpeg4v2",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MSMPEG4V2,
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
776
    ff_h263_decode_init,
777
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
778 779
    ff_h263_decode_end,
    ff_h263_decode_frame,
780
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
781
    mpeg4_decoptions,
782 783 784
};

AVCodec msmpeg4v3_decoder = {
Fabrice Bellard's avatar
Fabrice Bellard committed
785 786
    "msmpeg4",
    CODEC_TYPE_VIDEO,
787
    CODEC_ID_MSMPEG4V3,
Fabrice Bellard's avatar
Fabrice Bellard committed
788
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
789
    ff_h263_decode_init,
Fabrice Bellard's avatar
Fabrice Bellard committed
790
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
791 792
    ff_h263_decode_end,
    ff_h263_decode_frame,
793
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
794
    .options = mpeg4_decoptions,
Fabrice Bellard's avatar
Fabrice Bellard committed
795 796
};

797 798 799 800 801
AVCodec wmv1_decoder = {
    "wmv1",
    CODEC_TYPE_VIDEO,
    CODEC_ID_WMV1,
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
802
    ff_h263_decode_init,
803
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
804 805
    ff_h263_decode_end,
    ff_h263_decode_frame,
806
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
807
    mpeg4_decoptions,
808 809
};

Fabrice Bellard's avatar
Fabrice Bellard committed
810 811 812 813 814
AVCodec h263i_decoder = {
    "h263i",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263I,
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
815
    ff_h263_decode_init,
Fabrice Bellard's avatar
Fabrice Bellard committed
816
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
817 818
    ff_h263_decode_end,
    ff_h263_decode_frame,
819
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
820
    mpeg4_decoptions,
Fabrice Bellard's avatar
Fabrice Bellard committed
821 822
};

823 824 825 826 827 828 829 830 831 832 833
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
};