Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h263dec.c @ c6bb50e0

History | View | Annotate | Download (27.1 KB)

1
/*
2
 * H.263 decoder
3
 * Copyright (c) 2001 Fabrice Bellard.
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20

    
21
/**
22
 * @file h263dec.c
23
 * H.263 decoder.
24
 */
25

    
26
#include "avcodec.h"
27
#include "dsputil.h"
28
#include "mpegvideo.h"
29

    
30
//#define DEBUG
31
//#define PRINT_FRAME_TIME
32

    
33
int ff_h263_decode_init(AVCodecContext *avctx)
34
{
35
    MpegEncContext *s = avctx->priv_data;
36

    
37
    s->avctx = avctx;
38
    s->out_format = FMT_H263;
39

    
40
    s->width  = avctx->coded_width;
41
    s->height = avctx->coded_height;
42
    s->workaround_bugs= avctx->workaround_bugs;
43

    
44
    // set defaults
45
    MPV_decode_defaults(s);
46
    s->quant_precision=5;
47
    s->decode_mb= ff_h263_decode_mb;
48
    s->low_delay= 1;
49
    avctx->pix_fmt= PIX_FMT_YUV420P;
50
    s->unrestricted_mv= 1;
51

    
52
    /* select sub codec */
53
    switch(avctx->codec->id) {
54
    case CODEC_ID_H263:
55
        s->unrestricted_mv= 0;
56
        break;
57
    case CODEC_ID_MPEG4:
58
        s->decode_mb= ff_mpeg4_decode_mb;
59
        s->time_increment_bits = 4; /* default value for broken headers */
60
        s->h263_pred = 1;
61
        s->low_delay = 0; //default, might be overriden in the vol header during header parsing
62
        break;
63
    case CODEC_ID_MSMPEG4V1:
64
        s->h263_msmpeg4 = 1;
65
        s->h263_pred = 1;
66
        s->msmpeg4_version=1;
67
        break;
68
    case CODEC_ID_MSMPEG4V2:
69
        s->h263_msmpeg4 = 1;
70
        s->h263_pred = 1;
71
        s->msmpeg4_version=2;
72
        break;
73
    case CODEC_ID_MSMPEG4V3:
74
        s->h263_msmpeg4 = 1;
75
        s->h263_pred = 1;
76
        s->msmpeg4_version=3;
77
        break;
78
    case CODEC_ID_WMV1:
79
        s->h263_msmpeg4 = 1;
80
        s->h263_pred = 1;
81
        s->msmpeg4_version=4;
82
        break;
83
    case CODEC_ID_WMV2:
84
        s->h263_msmpeg4 = 1;
85
        s->h263_pred = 1;
86
        s->msmpeg4_version=5;
87
        break;
88
    case CODEC_ID_VC1:
89
    case CODEC_ID_WMV3:
90
        s->h263_msmpeg4 = 1;
91
        s->h263_pred = 1;
92
        s->msmpeg4_version=6;
93
        break;
94
    case CODEC_ID_H263I:
95
        break;
96
    case CODEC_ID_FLV1:
97
        s->h263_flv = 1;
98
        break;
99
    default:
100
        return -1;
101
    }
102
    s->codec_id= avctx->codec->id;
103

    
104
    /* for h263, we allocate the images after having read the header */
105
    if (avctx->codec->id != CODEC_ID_H263 && avctx->codec->id != CODEC_ID_MPEG4)
106
        if (MPV_common_init(s) < 0)
107
            return -1;
108

    
109
    if (s->h263_msmpeg4)
110
        ff_msmpeg4_decode_init(s);
111
    else
112
        h263_decode_init_vlc(s);
113

    
114
    return 0;
115
}
116

    
117
int ff_h263_decode_end(AVCodecContext *avctx)
118
{
119
    MpegEncContext *s = avctx->priv_data;
120

    
121
    MPV_common_end(s);
122
    return 0;
123
}
124

    
125
/**
126
 * returns the number of bytes consumed for building the current frame
127
 */
128
static int get_consumed_bytes(MpegEncContext *s, int buf_size){
129
    int pos= (get_bits_count(&s->gb)+7)>>3;
130

    
131
    if(s->divx_packed){
132
        //we would have to scan through the whole buf to handle the weird reordering ...
133
        return buf_size;
134
    }else if(s->flags&CODEC_FLAG_TRUNCATED){
135
        pos -= s->parse_context.last_index;
136
        if(pos<0) pos=0; // padding is not really read so this might be -1
137
        return pos;
138
    }else{
139
        if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
140
        if(pos+10>buf_size) pos=buf_size; // oops ;)
141

    
142
        return pos;
143
    }
144
}
145

    
146
static int decode_slice(MpegEncContext *s){
147
    const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
148
    const int mb_size= 16>>s->avctx->lowres;
149
    s->last_resync_gb= s->gb;
150
    s->first_slice_line= 1;
151

    
152
    s->resync_mb_x= s->mb_x;
153
    s->resync_mb_y= s->mb_y;
154

    
155
    ff_set_qscale(s, s->qscale);
156

    
157
    if(s->partitioned_frame){
158
        const int qscale= s->qscale;
159

    
160
        if(s->codec_id==CODEC_ID_MPEG4){
161
            if(ff_mpeg4_decode_partitions(s) < 0)
162
                return -1;
163
        }
164

    
165
        /* restore variables which were modified */
166
        s->first_slice_line=1;
167
        s->mb_x= s->resync_mb_x;
168
        s->mb_y= s->resync_mb_y;
169
        ff_set_qscale(s, qscale);
170
    }
171

    
172
    for(; s->mb_y < s->mb_height; s->mb_y++) {
173
        /* per-row end of slice checks */
174
        if(s->msmpeg4_version){
175
            if(s->resync_mb_y + s->slice_height == s->mb_y){
176
                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);
177

    
178
                return 0;
179
            }
180
        }
181

    
182
        if(s->msmpeg4_version==1){
183
            s->last_dc[0]=
184
            s->last_dc[1]=
185
            s->last_dc[2]= 128;
186
        }
187

    
188
        ff_init_block_index(s);
189
        for(; s->mb_x < s->mb_width; s->mb_x++) {
190
            int ret;
191

    
192
            ff_update_block_index(s);
193

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

    
198
            /* DCT & quantize */
199

    
200
            s->mv_dir = MV_DIR_FORWARD;
201
            s->mv_type = MV_TYPE_16X16;
202
//            s->mb_skipped = 0;
203
//printf("%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
204
            ret= s->decode_mb(s, s->block);
205

    
206
            if (s->pict_type!=B_TYPE)
207
                ff_h263_update_motion_val(s);
208

    
209
            if(ret<0){
210
                const int xy= s->mb_x + s->mb_y*s->mb_stride;
211
                if(ret==SLICE_END){
212
                    MPV_decode_mb(s, s->block);
213
                    if(s->loop_filter)
214
                        ff_h263_loop_filter(s);
215

    
216
//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));
217
                    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);
218

    
219
                    s->padding_bug_score--;
220

    
221
                    if(++s->mb_x >= s->mb_width){
222
                        s->mb_x=0;
223
                        ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size);
224
                        s->mb_y++;
225
                    }
226
                    return 0;
227
                }else if(ret==SLICE_NOEND){
228
                    av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy);
229
                    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);
230
                    return -1;
231
                }
232
                av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy);
233
                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);
234

    
235
                return -1;
236
            }
237

    
238
            MPV_decode_mb(s, s->block);
239
            if(s->loop_filter)
240
                ff_h263_loop_filter(s);
241
        }
242

    
243
        ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size);
244

    
245
        s->mb_x= 0;
246
    }
247

    
248
    assert(s->mb_x==0 && s->mb_y==s->mb_height);
249

    
250
    /* try to detect the padding bug */
251
    if(      s->codec_id==CODEC_ID_MPEG4
252
       &&   (s->workaround_bugs&FF_BUG_AUTODETECT)
253
       &&    s->gb.size_in_bits - get_bits_count(&s->gb) >=0
254
       &&    s->gb.size_in_bits - get_bits_count(&s->gb) < 48
255
//       &&   !s->resync_marker
256
       &&   !s->data_partitioning){
257

    
258
        const int bits_count= get_bits_count(&s->gb);
259
        const int bits_left = s->gb.size_in_bits - bits_count;
260

    
261
        if(bits_left==0){
262
            s->padding_bug_score+=16;
263
        } else if(bits_left != 1){
264
            int v= show_bits(&s->gb, 8);
265
            v|= 0x7F >> (7-(bits_count&7));
266

    
267
            if(v==0x7F && bits_left<=8)
268
                s->padding_bug_score--;
269
            else if(v==0x7F && ((get_bits_count(&s->gb)+8)&8) && bits_left<=16)
270
                s->padding_bug_score+= 4;
271
            else
272
                s->padding_bug_score++;
273
        }
274
    }
275

    
276
    if(s->workaround_bugs&FF_BUG_AUTODETECT){
277
        if(s->padding_bug_score > -2 && !s->data_partitioning /*&& (s->divx_version || !s->resync_marker)*/)
278
            s->workaround_bugs |=  FF_BUG_NO_PADDING;
279
        else
280
            s->workaround_bugs &= ~FF_BUG_NO_PADDING;
281
    }
282

    
283
    // handle formats which don't have unique end markers
284
    if(s->msmpeg4_version || (s->workaround_bugs&FF_BUG_NO_PADDING)){ //FIXME perhaps solve this more cleanly
285
        int left= s->gb.size_in_bits - get_bits_count(&s->gb);
286
        int max_extra=7;
287

    
288
        /* no markers in M$ crap */
289
        if(s->msmpeg4_version && s->pict_type==I_TYPE)
290
            max_extra+= 17;
291

    
292
        /* buggy padding but the frame should still end approximately at the bitstream end */
293
        if((s->workaround_bugs&FF_BUG_NO_PADDING) && s->error_resilience>=3)
294
            max_extra+= 48;
295
        else if((s->workaround_bugs&FF_BUG_NO_PADDING))
296
            max_extra+= 256*256*256*64;
297

    
298
        if(left>max_extra){
299
            av_log(s->avctx, AV_LOG_ERROR, "discarding %d junk bits at end, next would be %X\n", left, show_bits(&s->gb, 24));
300
        }
301
        else if(left<0){
302
            av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);
303
        }else
304
            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);
305

    
306
        return 0;
307
    }
308

    
309
    av_log(s->avctx, AV_LOG_ERROR, "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
310
            s->gb.size_in_bits - get_bits_count(&s->gb),
311
            show_bits(&s->gb, 24), s->padding_bug_score);
312

    
313
    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);
314

    
315
    return -1;
316
}
317

    
318
/**
319
 * finds the end of the current frame in the bitstream.
320
 * @return the position of the first byte of the next frame, or -1
321
 */
322
int ff_mpeg4_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
323
    int vop_found, i;
324
    uint32_t state;
325

    
326
    vop_found= pc->frame_start_found;
327
    state= pc->state;
328

    
329
    i=0;
330
    if(!vop_found){
331
        for(i=0; i<buf_size; i++){
332
            state= (state<<8) | buf[i];
333
            if(state == 0x1B6){
334
                i++;
335
                vop_found=1;
336
                break;
337
            }
338
        }
339
    }
340

    
341
    if(vop_found){
342
        /* EOF considered as end of frame */
343
        if (buf_size == 0)
344
            return 0;
345
        for(; i<buf_size; i++){
346
            state= (state<<8) | buf[i];
347
            if((state&0xFFFFFF00) == 0x100){
348
                pc->frame_start_found=0;
349
                pc->state=-1;
350
                return i-3;
351
            }
352
        }
353
    }
354
    pc->frame_start_found= vop_found;
355
    pc->state= state;
356
    return END_NOT_FOUND;
357
}
358

    
359
static int h263_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
360
    int vop_found, i;
361
    uint32_t state;
362

    
363
    vop_found= pc->frame_start_found;
364
    state= pc->state;
365

    
366
    i=0;
367
    if(!vop_found){
368
        for(i=0; i<buf_size; i++){
369
            state= (state<<8) | buf[i];
370
            if(state>>(32-22) == 0x20){
371
                i++;
372
                vop_found=1;
373
                break;
374
            }
375
        }
376
    }
377

    
378
    if(vop_found){
379
      for(; i<buf_size; i++){
380
        state= (state<<8) | buf[i];
381
        if(state>>(32-22) == 0x20){
382
            pc->frame_start_found=0;
383
            pc->state=-1;
384
            return i-3;
385
        }
386
      }
387
    }
388
    pc->frame_start_found= vop_found;
389
    pc->state= state;
390

    
391
    return END_NOT_FOUND;
392
}
393

    
394
static int h263_parse(AVCodecParserContext *s,
395
                           AVCodecContext *avctx,
396
                           uint8_t **poutbuf, int *poutbuf_size,
397
                           const uint8_t *buf, int buf_size)
398
{
399
    ParseContext *pc = s->priv_data;
400
    int next;
401

    
402
    next= h263_find_frame_end(pc, buf, buf_size);
403

    
404
    if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
405
        *poutbuf = NULL;
406
        *poutbuf_size = 0;
407
        return buf_size;
408
    }
409

    
410
    *poutbuf = (uint8_t *)buf;
411
    *poutbuf_size = buf_size;
412
    return next;
413
}
414

    
415
int ff_h263_decode_frame(AVCodecContext *avctx,
416
                             void *data, int *data_size,
417
                             uint8_t *buf, int buf_size)
418
{
419
    MpegEncContext *s = avctx->priv_data;
420
    int ret;
421
    AVFrame *pict = data;
422

    
423
#ifdef PRINT_FRAME_TIME
424
uint64_t time= rdtsc();
425
#endif
426
#ifdef DEBUG
427
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
428
    printf("bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
429
#endif
430
    s->flags= avctx->flags;
431
    s->flags2= avctx->flags2;
432

    
433
    /* no supplementary picture */
434
    if (buf_size == 0) {
435
        /* special case for last picture */
436
        if (s->low_delay==0 && s->next_picture_ptr) {
437
            *pict= *(AVFrame*)s->next_picture_ptr;
438
            s->next_picture_ptr= NULL;
439

    
440
            *data_size = sizeof(AVFrame);
441
        }
442

    
443
        return 0;
444
    }
445

    
446
    if(s->flags&CODEC_FLAG_TRUNCATED){
447
        int next;
448

    
449
        if(s->codec_id==CODEC_ID_MPEG4){
450
            next= ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size);
451
        }else if(s->codec_id==CODEC_ID_H263){
452
            next= h263_find_frame_end(&s->parse_context, buf, buf_size);
453
        }else{
454
            av_log(s->avctx, AV_LOG_ERROR, "this codec does not support truncated bitstreams\n");
455
            return -1;
456
        }
457

    
458
        if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 )
459
            return buf_size;
460
    }
461

    
462

    
463
retry:
464

    
465
    if(s->bitstream_buffer_size && (s->divx_packed || buf_size<20)){ //divx 5.01+/xvid frame reorder
466
        init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8);
467
    }else
468
        init_get_bits(&s->gb, buf, buf_size*8);
469
    s->bitstream_buffer_size=0;
470

    
471
    if (!s->context_initialized) {
472
        if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
473
            return -1;
474
    }
475

    
476
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
477
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
478
        int i= ff_find_unused_picture(s, 0);
479
        s->current_picture_ptr= &s->picture[i];
480
    }
481

    
482
    /* let's go :-) */
483
    if (s->msmpeg4_version==5) {
484
        ret= ff_wmv2_decode_picture_header(s);
485
    } else if (s->msmpeg4_version) {
486
        ret = msmpeg4_decode_picture_header(s);
487
    } else if (s->h263_pred) {
488
        if(s->avctx->extradata_size && s->picture_number==0){
489
            GetBitContext gb;
490

    
491
            init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8);
492
            ret = ff_mpeg4_decode_picture_header(s, &gb);
493
        }
494
        ret = ff_mpeg4_decode_picture_header(s, &s->gb);
495

    
496
        if(s->flags& CODEC_FLAG_LOW_DELAY)
497
            s->low_delay=1;
498
    } else if (s->codec_id == CODEC_ID_H263I) {
499
        ret = intel_h263_decode_picture_header(s);
500
    } else if (s->h263_flv) {
501
        ret = flv_h263_decode_picture_header(s);
502
    } else {
503
        ret = h263_decode_picture_header(s);
504
    }
505

    
506
    if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_size);
507

    
508
    /* skip if the header was thrashed */
509
    if (ret < 0){
510
        av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
511
        return -1;
512
    }
513

    
514
    avctx->has_b_frames= !s->low_delay;
515

    
516
    if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
517
        if(s->avctx->stream_codec_tag == ff_get_fourcc("XVID") ||
518
           s->avctx->codec_tag == ff_get_fourcc("XVID") || s->avctx->codec_tag == ff_get_fourcc("XVIX") ||
519
           s->avctx->codec_tag == ff_get_fourcc("RMP4"))
520
            s->xvid_build= -1;
521
#if 0
522
        if(s->avctx->codec_tag == ff_get_fourcc("DIVX") && s->vo_type==0 && s->vol_control_parameters==1
523
           && s->padding_bug_score > 0 && s->low_delay) // XVID with modified fourcc
524
            s->xvid_build= -1;
525
#endif
526
    }
527

    
528
    if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){
529
        if(s->avctx->codec_tag == ff_get_fourcc("DIVX") && s->vo_type==0 && s->vol_control_parameters==0)
530
            s->divx_version= 400; //divx 4
531
    }
532

    
533
    if(s->xvid_build && s->divx_version){
534
        s->divx_version=
535
        s->divx_build= 0;
536
    }
537

    
538
    if(s->workaround_bugs&FF_BUG_AUTODETECT){
539
        if(s->avctx->codec_tag == ff_get_fourcc("XVIX"))
540
            s->workaround_bugs|= FF_BUG_XVID_ILACE;
541

    
542
        if(s->avctx->codec_tag == ff_get_fourcc("UMP4")){
543
            s->workaround_bugs|= FF_BUG_UMP4;
544
        }
545

    
546
        if(s->divx_version>=500){
547
            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
548
        }
549

    
550
        if(s->divx_version>502){
551
            s->workaround_bugs|= FF_BUG_QPEL_CHROMA2;
552
        }
553

    
554
        if(s->xvid_build && s->xvid_build<=3)
555
            s->padding_bug_score= 256*256*256*64;
556

    
557
        if(s->xvid_build && s->xvid_build<=1)
558
            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;
559

    
560
        if(s->xvid_build && s->xvid_build<=12)
561
            s->workaround_bugs|= FF_BUG_EDGE;
562

    
563
        if(s->xvid_build && s->xvid_build<=32)
564
            s->workaround_bugs|= FF_BUG_DC_CLIP;
565

    
566
#define SET_QPEL_FUNC(postfix1, postfix2) \
567
    s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\
568
    s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\
569
    s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
570

    
571
        if(s->lavc_build && s->lavc_build<4653)
572
            s->workaround_bugs|= FF_BUG_STD_QPEL;
573

    
574
        if(s->lavc_build && s->lavc_build<4655)
575
            s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
576

    
577
        if(s->lavc_build && s->lavc_build<4670){
578
            s->workaround_bugs|= FF_BUG_EDGE;
579
        }
580

    
581
        if(s->lavc_build && s->lavc_build<=4712)
582
            s->workaround_bugs|= FF_BUG_DC_CLIP;
583

    
584
        if(s->divx_version)
585
            s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE;
586
//printf("padding_bug_score: %d\n", s->padding_bug_score);
587
        if(s->divx_version==501 && s->divx_build==20020416)
588
            s->padding_bug_score= 256*256*256*64;
589

    
590
        if(s->divx_version && s->divx_version<500){
591
            s->workaround_bugs|= FF_BUG_EDGE;
592
        }
593

    
594
        if(s->divx_version)
595
            s->workaround_bugs|= FF_BUG_HPEL_CHROMA;
596
#if 0
597
        if(s->divx_version==500)
598
            s->padding_bug_score= 256*256*256*64;
599

600
        /* very ugly XVID padding bug detection FIXME/XXX solve this differently
601
         * lets hope this at least works
602
         */
603
        if(   s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0
604
           && s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)
605
            s->workaround_bugs|= FF_BUG_NO_PADDING;
606

607
        if(s->lavc_build && s->lavc_build<4609) //FIXME not sure about the version num but a 4609 file seems ok
608
            s->workaround_bugs|= FF_BUG_NO_PADDING;
609
#endif
610
    }
611

    
612
    if(s->workaround_bugs& FF_BUG_STD_QPEL){
613
        SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)
614
        SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)
615
        SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)
616
        SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)
617
        SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)
618
        SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)
619

    
620
        SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)
621
        SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)
622
        SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)
623
        SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)
624
        SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)
625
        SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)
626
    }
627

    
628
    if(avctx->debug & FF_DEBUG_BUGS)
629
        av_log(s->avctx, AV_LOG_DEBUG, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
630
               s->workaround_bugs, s->lavc_build, s->xvid_build, s->divx_version, s->divx_build,
631
               s->divx_packed ? "p" : "");
632

    
633
#if 0 // dump bits per frame / qp / complexity
634
{
635
    static FILE *f=NULL;
636
    if(!f) f=fopen("rate_qp_cplx.txt", "w");
637
    fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale);
638
}
639
#endif
640

    
641
#if defined(HAVE_MMX) && defined(CONFIG_GPL)
642
    if(s->codec_id == CODEC_ID_MPEG4 && s->xvid_build && avctx->idct_algo == FF_IDCT_AUTO && (mm_flags & MM_MMX)){
643
        avctx->idct_algo= FF_IDCT_XVIDMMX;
644
        avctx->coded_width= 0; // force reinit
645
//        dsputil_init(&s->dsp, avctx);
646
        s->picture_number=0;
647
    }
648
#endif
649

    
650
        /* After H263 & mpeg4 header decode we have the height, width,*/
651
        /* and other parameters. So then we could init the picture   */
652
        /* FIXME: By the way H263 decoder is evolving it should have */
653
        /* an H263EncContext                                         */
654

    
655
    if (   s->width  != avctx->coded_width
656
        || s->height != avctx->coded_height) {
657
        /* H.263 could change picture size any time */
658
        ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat
659
        s->parse_context.buffer=0;
660
        MPV_common_end(s);
661
        s->parse_context= pc;
662
    }
663
    if (!s->context_initialized) {
664
        avcodec_set_dimensions(avctx, s->width, s->height);
665

    
666
        goto retry;
667
    }
668

    
669
    if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P))
670
        s->gob_index = ff_h263_get_gob_height(s);
671

    
672
    // for hurry_up==5
673
    s->current_picture.pict_type= s->pict_type;
674
    s->current_picture.key_frame= s->pict_type == I_TYPE;
675

    
676
    /* skip B-frames if we don't have reference frames */
677
    if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)) return get_consumed_bytes(s, buf_size);
678
    /* skip b frames if we are in a hurry */
679
    if(avctx->hurry_up && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);
680
    if(   (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
681
       || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
682
       ||  avctx->skip_frame >= AVDISCARD_ALL)
683
        return get_consumed_bytes(s, buf_size);
684
    /* skip everything if we are in a hurry>=5 */
685
    if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);
686

    
687
    if(s->next_p_frame_damaged){
688
        if(s->pict_type==B_TYPE)
689
            return get_consumed_bytes(s, buf_size);
690
        else
691
            s->next_p_frame_damaged=0;
692
    }
693

    
694
    if(MPV_frame_start(s, avctx) < 0)
695
        return -1;
696

    
697
#ifdef DEBUG
698
    av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
699
#endif
700

    
701
    ff_er_frame_start(s);
702

    
703
    //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type
704
    //which isnt available before MPV_frame_start()
705
    if (s->msmpeg4_version==5){
706
        if(ff_wmv2_decode_secondary_picture_header(s) < 0)
707
            return -1;
708
    }
709

    
710
    /* decode each macroblock */
711
    s->mb_x=0;
712
    s->mb_y=0;
713

    
714
    decode_slice(s);
715
    while(s->mb_y<s->mb_height){
716
        if(s->msmpeg4_version){
717
            if(s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits)
718
                break;
719
        }else{
720
            if(ff_h263_resync(s)<0)
721
                break;
722
        }
723

    
724
        if(s->msmpeg4_version<4 && s->h263_pred)
725
            ff_mpeg4_clean_buffers(s);
726

    
727
        decode_slice(s);
728
    }
729

    
730
    if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE)
731
        if(msmpeg4_decode_ext_header(s, buf_size) < 0){
732
            s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;
733
        }
734

    
735
    /* divx 5.01+ bistream reorder stuff */
736
    if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_packed){
737
        int current_pos= get_bits_count(&s->gb)>>3;
738
        int startcode_found=0;
739

    
740
        if(buf_size - current_pos > 5){
741
            int i;
742
            for(i=current_pos; i<buf_size-3; i++){
743
                if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){
744
                    startcode_found=1;
745
                    break;
746
                }
747
            }
748
        }
749
        if(s->gb.buffer == s->bitstream_buffer && buf_size>20){ //xvid style
750
            startcode_found=1;
751
            current_pos=0;
752
        }
753

    
754
        if(startcode_found){
755
            s->bitstream_buffer= av_fast_realloc(
756
                s->bitstream_buffer,
757
                &s->allocated_bitstream_buffer_size,
758
                buf_size - current_pos + FF_INPUT_BUFFER_PADDING_SIZE);
759
            memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos);
760
            s->bitstream_buffer_size= buf_size - current_pos;
761
        }
762
    }
763

    
764
    ff_er_frame_end(s);
765

    
766
    MPV_frame_end(s);
767

    
768
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
769
assert(s->current_picture.pict_type == s->pict_type);
770
    if (s->pict_type == B_TYPE || s->low_delay) {
771
        *pict= *(AVFrame*)s->current_picture_ptr;
772
    } else if (s->last_picture_ptr != NULL) {
773
        *pict= *(AVFrame*)s->last_picture_ptr;
774
    }
775

    
776
    if(s->last_picture_ptr || s->low_delay){
777
        *data_size = sizeof(AVFrame);
778
        ff_print_debug_info(s, pict);
779
    }
780

    
781
    /* Return the Picture timestamp as the frame number */
782
    /* we substract 1 because it is added on utils.c    */
783
    avctx->frame_number = s->picture_number - 1;
784

    
785
#ifdef PRINT_FRAME_TIME
786
av_log(avctx, AV_LOG_DEBUG, "%Ld\n", rdtsc()-time);
787
#endif
788

    
789
    return get_consumed_bytes(s, buf_size);
790
}
791

    
792
AVCodec mpeg4_decoder = {
793
    "mpeg4",
794
    CODEC_TYPE_VIDEO,
795
    CODEC_ID_MPEG4,
796
    sizeof(MpegEncContext),
797
    ff_h263_decode_init,
798
    NULL,
799
    ff_h263_decode_end,
800
    ff_h263_decode_frame,
801
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
802
    .flush= ff_mpeg_flush,
803
};
804

    
805
AVCodec h263_decoder = {
806
    "h263",
807
    CODEC_TYPE_VIDEO,
808
    CODEC_ID_H263,
809
    sizeof(MpegEncContext),
810
    ff_h263_decode_init,
811
    NULL,
812
    ff_h263_decode_end,
813
    ff_h263_decode_frame,
814
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
815
    .flush= ff_mpeg_flush,
816
};
817

    
818
AVCodec msmpeg4v1_decoder = {
819
    "msmpeg4v1",
820
    CODEC_TYPE_VIDEO,
821
    CODEC_ID_MSMPEG4V1,
822
    sizeof(MpegEncContext),
823
    ff_h263_decode_init,
824
    NULL,
825
    ff_h263_decode_end,
826
    ff_h263_decode_frame,
827
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
828
};
829

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

    
842
AVCodec msmpeg4v3_decoder = {
843
    "msmpeg4",
844
    CODEC_TYPE_VIDEO,
845
    CODEC_ID_MSMPEG4V3,
846
    sizeof(MpegEncContext),
847
    ff_h263_decode_init,
848
    NULL,
849
    ff_h263_decode_end,
850
    ff_h263_decode_frame,
851
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
852
};
853

    
854
AVCodec wmv1_decoder = {
855
    "wmv1",
856
    CODEC_TYPE_VIDEO,
857
    CODEC_ID_WMV1,
858
    sizeof(MpegEncContext),
859
    ff_h263_decode_init,
860
    NULL,
861
    ff_h263_decode_end,
862
    ff_h263_decode_frame,
863
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
864
};
865

    
866
AVCodec h263i_decoder = {
867
    "h263i",
868
    CODEC_TYPE_VIDEO,
869
    CODEC_ID_H263I,
870
    sizeof(MpegEncContext),
871
    ff_h263_decode_init,
872
    NULL,
873
    ff_h263_decode_end,
874
    ff_h263_decode_frame,
875
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
876
};
877

    
878
AVCodec flv_decoder = {
879
    "flv",
880
    CODEC_TYPE_VIDEO,
881
    CODEC_ID_FLV1,
882
    sizeof(MpegEncContext),
883
    ff_h263_decode_init,
884
    NULL,
885
    ff_h263_decode_end,
886
    ff_h263_decode_frame,
887
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1
888
};
889

    
890
AVCodecParser h263_parser = {
891
    { CODEC_ID_H263 },
892
    sizeof(ParseContext),
893
    NULL,
894
    h263_parse,
895
    ff_parse_close,
896
};