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

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

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

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

    MPV_common_end(s);
    return 0;
}

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

        return pos;
    }
}

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

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

204 205 206
            if (s->pict_type!=B_TYPE)
                ff_h263_update_motion_val(s);

207
            if(ret<0){
208
                const int xy= s->mb_x + s->mb_y*s->mb_stride;
209
                if(ret==SLICE_END){
210
                    MPV_decode_mb(s, s->block);
Michael Niedermayer's avatar
Michael Niedermayer committed
211 212
                    if(s->loop_filter)
                        ff_h263_loop_filter(s);
213

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 218

                    s->padding_bug_score--;
                        
219 220
                    if(++s->mb_x >= s->mb_width){
                        s->mb_x=0;
221
                        ff_draw_horiz_band(s, s->mb_y*16, 16);
222 223 224 225
                        s->mb_y++;
                    }
                    return 0; 
                }else if(ret==SLICE_NOEND){
226
                    av_log(s->avctx, AV_LOG_ERROR, "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 229
                    return -1;
                }
230
                av_log(s->avctx, AV_LOG_ERROR, "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 234
    
                return -1;
            }
235 236

            MPV_decode_mb(s, s->block);
Michael Niedermayer's avatar
Michael Niedermayer committed
237 238
            if(s->loop_filter)
                ff_h263_loop_filter(s);
239 240
        }
        
241
        ff_draw_horiz_band(s, s->mb_y*16, 16);
242 243 244 245 246 247
        
        s->mb_x= 0;
    }
    
    assert(s->mb_x==0 && s->mb_y==s->mb_height);

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

267 268 269 270
            if(v==0x7F)
                s->padding_bug_score--;
            else
                s->padding_bug_score++;            
271
        }                          
272 273
    }

274
    // handle formats which dont have unique end markers
275
    if(s->msmpeg4_version || (s->workaround_bugs&FF_BUG_NO_PADDING)){ //FIXME perhaps solve this more cleanly
276
        int left= s->gb.size_in_bits - get_bits_count(&s->gb);
277 278 279 280 281 282 283
        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 */
284
        if((s->workaround_bugs&FF_BUG_NO_PADDING) && s->error_resilience>=3)
285
            max_extra+= 48;
286
        else if((s->workaround_bugs&FF_BUG_NO_PADDING))
287 288 289
            max_extra+= 256*256*256*64;
        
        if(left>max_extra){
290
            av_log(s->avctx, AV_LOG_ERROR, "discarding %d junk bits at end, next would be %X\n", left, show_bits(&s->gb, 24));
291 292
        }
        else if(left<0){
293
            av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);
294
        }else
295
            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);
296 297 298
        
        return 0;
    }
299

300
    av_log(s->avctx, AV_LOG_ERROR, "slice end not reached but screenspace end (%d left %06X, score= %d)\n", 
301
            s->gb.size_in_bits - get_bits_count(&s->gb),
302
            show_bits(&s->gb, 24), s->padding_bug_score);
303 304 305
            
    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);

306 307 308
    return -1;
}

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

    if(vop_found){    
      for(; i<buf_size; i++){
335 336 337 338 339 340
        state= (state<<8) | buf[i];
        if((state&0xFFFFFF00) == 0x100){
            pc->frame_start_found=0;
            pc->state=-1; 
            return i-3;
        }
341
      }
342 343 344
    }
    pc->frame_start_found= vop_found;
    pc->state= state;
Michael Niedermayer's avatar
tired  
Michael Niedermayer committed
345
    return END_NOT_FOUND;
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 378 379 380 381 382 383
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
384
int ff_h263_decode_frame(AVCodecContext *avctx, 
Fabrice Bellard's avatar
Fabrice Bellard committed
385
                             void *data, int *data_size,
386
                             uint8_t *buf, int buf_size)
Fabrice Bellard's avatar
Fabrice Bellard committed
387 388
{
    MpegEncContext *s = avctx->priv_data;
Fabrice Bellard's avatar
Fabrice Bellard committed
389
    int ret;
Michael Niedermayer's avatar
Michael Niedermayer committed
390
    AVFrame *pict = data; 
Michael Niedermayer's avatar
Michael Niedermayer committed
391
    
392 393 394
#ifdef PRINT_FRAME_TIME
uint64_t time= rdtsc();
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
395 396 397 398
#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
399
    s->flags= avctx->flags;
400

Michael Niedermayer's avatar
Michael Niedermayer committed
401
    *data_size = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
402 403

    /* no supplementary picture */
Fabrice Bellard's avatar
Fabrice Bellard committed
404
    if (buf_size == 0) {
Michael Niedermayer's avatar
Michael Niedermayer committed
405 406 407 408 409 410 411 412
        /* 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
413 414
        return 0;
    }
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
415

416 417 418 419 420
    if(s->flags&CODEC_FLAG_TRUNCATED){
        int next;
        
        if(s->codec_id==CODEC_ID_MPEG4){
            next= mpeg4_find_frame_end(s, buf, buf_size);
421 422
        }else if(s->codec_id==CODEC_ID_H263){
            next= h263_find_frame_end(s, buf, buf_size);
423
        }else{
424
            av_log(s->avctx, AV_LOG_ERROR, "this codec doesnt support truncated bitstreams\n");
425 426
            return -1;
        }
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
427 428
        
        if( ff_combine_frame(s, next, &buf, &buf_size) < 0 )
429 430
            return buf_size;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
431

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

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

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

    /* skip if the header was thrashed */
    if (ret < 0){
479
        av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
480 481 482
        return -1;
    }
    
Michael Niedermayer's avatar
Michael Niedermayer committed
483
    avctx->has_b_frames= !s->low_delay;
484 485
    
    if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
486 487
        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"))
488
            s->xvid_build= -1;
489
#if 0
490 491 492
        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;
493 494
#endif
    }
495

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

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

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

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

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

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

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

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

Michael Niedermayer's avatar
Michael Niedermayer committed
531 532 533 534 535 536 537 538
#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;
        
539 540 541
        if(s->lavc_build && s->lavc_build<4655)
            s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;

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

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

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

        /* 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;
569
#endif
570 571
    }
    
Michael Niedermayer's avatar
Michael Niedermayer committed
572 573 574 575 576 577 578 579 580 581 582 583 584 585 586
    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)
    }
587

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

617
        goto retry;
Fabrice Bellard's avatar
Fabrice Bellard committed
618
    }
619 620 621

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

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

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

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

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

674
        decode_slice(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
675
    }
676

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

Michael Niedermayer's avatar
Michael Niedermayer committed
686 687
        if(   buf_size - current_pos > 5 
           && buf_size - current_pos < BITSTREAM_BUFFER_SIZE){
688 689
            int i;
            int startcode_found=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
690
            for(i=current_pos; i<buf_size-3; i++){
691 692 693 694 695 696 697 698 699 700 701 702
                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;
            }
        }
    }

703
    ff_er_frame_end(s);
704

Fabrice Bellard's avatar
Fabrice Bellard committed
705
    MPV_frame_end(s);
Michael Niedermayer's avatar
Michael Niedermayer committed
706

707 708
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
709
    if(s->pict_type==B_TYPE || s->low_delay){
Michael Niedermayer's avatar
Michael Niedermayer committed
710
        *pict= *(AVFrame*)&s->current_picture;
711
        ff_print_debug_info(s, s->current_picture_ptr);
Michael Niedermayer's avatar
Michael Niedermayer committed
712
    } else {
Michael Niedermayer's avatar
Michael Niedermayer committed
713
        *pict= *(AVFrame*)&s->last_picture;
714
        ff_print_debug_info(s, s->last_picture_ptr);
Michael Niedermayer's avatar
Michael Niedermayer committed
715
    }
716

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

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

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

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

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

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

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

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
816 817 818 819 820
AVCodec h263i_decoder = {
    "h263i",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H263I,
    sizeof(MpegEncContext),
Michael Niedermayer's avatar
Michael Niedermayer committed
821
    ff_h263_decode_init,
Fabrice Bellard's avatar
Fabrice Bellard committed
822
    NULL,
Michael Niedermayer's avatar
Michael Niedermayer committed
823 824
    ff_h263_decode_end,
    ff_h263_decode_frame,