h263dec.c 24.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 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;
393
    int ret,i;
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 485 486 487 488 489 490
    
    if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
        if(s->avctx->codec_tag == ff_get_fourcc("XVID") || s->avctx->codec_tag == ff_get_fourcc("XVIX"))
            s->xvid_build= -1;

        if(s->avctx->codec_tag == ff_get_fourcc("DIVX") && s->vo_type==0 && s->vol_control_parameters==0)
            s->divx_version= 400; //divx 4
    }
491 492

    if(s->workaround_bugs&FF_BUG_AUTODETECT){
493 494 495
        s->workaround_bugs &= ~FF_BUG_NO_PADDING;
        
        if(s->padding_bug_score > -2 && !s->data_partitioning && (s->divx_version || !s->resync_marker))
496 497
            s->workaround_bugs |=  FF_BUG_NO_PADDING;

498
        if(s->avctx->codec_tag == ff_get_fourcc("XVIX")) 
499
            s->workaround_bugs|= FF_BUG_XVID_ILACE;
500

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

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

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

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

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

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

534 535 536 537
        if(s->lavc_build && s->lavc_build<4618){
            s->workaround_bugs|= FF_BUG_EDGE;
        }

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

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

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

580 581 582 583
#if 0 // dump bits per frame / qp / complexity
{
    static FILE *f=NULL;
    if(!f) f=fopen("rate_qp_cplx.txt", "w");
584
    fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale);
585 586
}
#endif
587
       
588
        /* After H263 & mpeg4 header decode we have the height, width,*/
589 590 591
        /* 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
592
    if(s->aspected_height)
Michael Niedermayer's avatar
Michael Niedermayer committed
593
        new_aspect= s->aspected_width*s->width / (float)(s->height*s->aspected_height);
Michael Niedermayer's avatar
Michael Niedermayer committed
594 595
    else
        new_aspect=0;
Michael Niedermayer's avatar
Michael Niedermayer committed
596
    
597
    if (   s->width != avctx->width || s->height != avctx->height 
Michael Niedermayer's avatar
Michael Niedermayer committed
598
        || ABS(new_aspect - avctx->aspect_ratio) > 0.001) {
599 600 601
        /* H.263 could change picture size any time */
        MPV_common_end(s);
    }
602
    if (!s->context_initialized) {
Michael Niedermayer's avatar
10l  
Michael Niedermayer committed
603 604
        avctx->width = s->width;
        avctx->height = s->height;
Michael Niedermayer's avatar
Michael Niedermayer committed
605
        avctx->aspect_ratio= new_aspect;
606

607
        goto retry;
Fabrice Bellard's avatar
Fabrice Bellard committed
608
    }
609 610 611

    if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P))
        s->gob_index = ff_h263_get_gob_height(s);
612
    
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
613 614 615
    // for hurry_up==5
    s->current_picture.pict_type= s->pict_type;
    s->current_picture.key_frame= s->pict_type == I_TYPE;
616

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

631 632
    if(MPV_frame_start(s, avctx) < 0)
        return -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
633 634 635 636 637

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

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

664
        decode_slice(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
665
    }
666

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

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

693
    ff_er_frame_end(s);
694

Fabrice Bellard's avatar
Fabrice Bellard committed
695
    MPV_frame_end(s);
Michael Niedermayer's avatar
Michael Niedermayer committed
696

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

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

Michael Niedermayer's avatar
Michael Niedermayer committed
718
    return get_consumed_bytes(s, buf_size);
Fabrice Bellard's avatar
Fabrice Bellard committed
719 720
}

721 722 723 724 725 726
static const AVOption mpeg4_decoptions[] =
{
    AVOPTION_SUB(avoptions_workaround_bug),
    AVOPTION_END()
};

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

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

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

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

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

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

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

819 820 821 822 823 824 825 826 827 828 829
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
};