3 * Copyright (c) 2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30 #include "mpegvideo.h"
31 #include "h263_parser.h"
32 #include "mpeg4video_parser.h"
36 //#define PRINT_FRAME_TIME
38 av_cold
int ff_h263_decode_init(AVCodecContext
*avctx
)
40 MpegEncContext
*s
= avctx
->priv_data
;
43 s
->out_format
= FMT_H263
;
45 s
->width
= avctx
->coded_width
;
46 s
->height
= avctx
->coded_height
;
47 s
->workaround_bugs
= avctx
->workaround_bugs
;
50 MPV_decode_defaults(s
);
52 s
->decode_mb
= ff_h263_decode_mb
;
54 avctx
->pix_fmt
= PIX_FMT_YUV420P
;
55 s
->unrestricted_mv
= 1;
57 /* select sub codec */
58 switch(avctx
->codec
->id
) {
60 s
->unrestricted_mv
= 0;
63 s
->decode_mb
= ff_mpeg4_decode_mb
;
64 s
->time_increment_bits
= 4; /* default value for broken headers */
66 s
->low_delay
= 0; //default, might be overriden in the vol header during header parsing
68 case CODEC_ID_MSMPEG4V1
:
73 case CODEC_ID_MSMPEG4V2
:
78 case CODEC_ID_MSMPEG4V3
:
95 case CODEC_ID_VC1_VDPAU
:
96 case CODEC_ID_WMV3_VDPAU
:
109 s
->codec_id
= avctx
->codec
->id
;
111 /* for h263, we allocate the images after having read the header */
112 if (avctx
->codec
->id
!= CODEC_ID_H263
&& avctx
->codec
->id
!= CODEC_ID_MPEG4
)
113 if (MPV_common_init(s
) < 0)
116 if (ENABLE_MSMPEG4_DECODER
&& s
->h263_msmpeg4
)
117 ff_msmpeg4_decode_init(s
);
119 h263_decode_init_vlc(s
);
124 av_cold
int ff_h263_decode_end(AVCodecContext
*avctx
)
126 MpegEncContext
*s
= avctx
->priv_data
;
133 * returns the number of bytes consumed for building the current frame
135 static int get_consumed_bytes(MpegEncContext
*s
, int buf_size
){
136 int pos
= (get_bits_count(&s
->gb
)+7)>>3;
139 //we would have to scan through the whole buf to handle the weird reordering ...
141 }else if(s
->flags
&CODEC_FLAG_TRUNCATED
){
142 pos
-= s
->parse_context
.last_index
;
143 if(pos
<0) pos
=0; // padding is not really read so this might be -1
146 if(pos
==0) pos
=1; //avoid infinite loops (i doubt that is needed but ...)
147 if(pos
+10>buf_size
) pos
=buf_size
; // oops ;)
153 static int decode_slice(MpegEncContext
*s
){
154 const int part_mask
= s
->partitioned_frame
? (AC_END
|AC_ERROR
) : 0x7F;
155 const int mb_size
= 16>>s
->avctx
->lowres
;
156 s
->last_resync_gb
= s
->gb
;
157 s
->first_slice_line
= 1;
159 s
->resync_mb_x
= s
->mb_x
;
160 s
->resync_mb_y
= s
->mb_y
;
162 ff_set_qscale(s
, s
->qscale
);
164 if(s
->partitioned_frame
){
165 const int qscale
= s
->qscale
;
167 if(s
->codec_id
==CODEC_ID_MPEG4
){
168 if(ff_mpeg4_decode_partitions(s
) < 0)
172 /* restore variables which were modified */
173 s
->first_slice_line
=1;
174 s
->mb_x
= s
->resync_mb_x
;
175 s
->mb_y
= s
->resync_mb_y
;
176 ff_set_qscale(s
, qscale
);
179 for(; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
180 /* per-row end of slice checks */
181 if(s
->msmpeg4_version
){
182 if(s
->resync_mb_y
+ s
->slice_height
== s
->mb_y
){
183 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
);
189 if(s
->msmpeg4_version
==1){
195 ff_init_block_index(s
);
196 for(; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
199 ff_update_block_index(s
);
201 if(s
->resync_mb_x
== s
->mb_x
&& s
->resync_mb_y
+1 == s
->mb_y
){
202 s
->first_slice_line
=0;
207 s
->mv_dir
= MV_DIR_FORWARD
;
208 s
->mv_type
= MV_TYPE_16X16
;
209 // s->mb_skipped = 0;
210 //printf("%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
211 ret
= s
->decode_mb(s
, s
->block
);
213 if (s
->pict_type
!=FF_B_TYPE
)
214 ff_h263_update_motion_val(s
);
217 const int xy
= s
->mb_x
+ s
->mb_y
*s
->mb_stride
;
219 MPV_decode_mb(s
, s
->block
);
221 ff_h263_loop_filter(s
);
223 //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));
224 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
);
226 s
->padding_bug_score
--;
228 if(++s
->mb_x
>= s
->mb_width
){
230 ff_draw_horiz_band(s
, s
->mb_y
*mb_size
, mb_size
);
234 }else if(ret
==SLICE_NOEND
){
235 av_log(s
->avctx
, AV_LOG_ERROR
, "Slice mismatch at MB: %d\n", xy
);
236 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
);
239 av_log(s
->avctx
, AV_LOG_ERROR
, "Error at MB: %d\n", xy
);
240 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
);
245 MPV_decode_mb(s
, s
->block
);
247 ff_h263_loop_filter(s
);
250 ff_draw_horiz_band(s
, s
->mb_y
*mb_size
, mb_size
);
255 assert(s
->mb_x
==0 && s
->mb_y
==s
->mb_height
);
257 /* try to detect the padding bug */
258 if( s
->codec_id
==CODEC_ID_MPEG4
259 && (s
->workaround_bugs
&FF_BUG_AUTODETECT
)
260 && s
->gb
.size_in_bits
- get_bits_count(&s
->gb
) >=0
261 && s
->gb
.size_in_bits
- get_bits_count(&s
->gb
) < 48
262 // && !s->resync_marker
263 && !s
->data_partitioning
){
265 const int bits_count
= get_bits_count(&s
->gb
);
266 const int bits_left
= s
->gb
.size_in_bits
- bits_count
;
269 s
->padding_bug_score
+=16;
270 } else if(bits_left
!= 1){
271 int v
= show_bits(&s
->gb
, 8);
272 v
|= 0x7F >> (7-(bits_count
&7));
274 if(v
==0x7F && bits_left
<=8)
275 s
->padding_bug_score
--;
276 else if(v
==0x7F && ((get_bits_count(&s
->gb
)+8)&8) && bits_left
<=16)
277 s
->padding_bug_score
+= 4;
279 s
->padding_bug_score
++;
283 if(s
->workaround_bugs
&FF_BUG_AUTODETECT
){
284 if(s
->padding_bug_score
> -2 && !s
->data_partitioning
/*&& (s->divx_version || !s->resync_marker)*/)
285 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
287 s
->workaround_bugs
&= ~FF_BUG_NO_PADDING
;
290 // handle formats which don't have unique end markers
291 if(s
->msmpeg4_version
|| (s
->workaround_bugs
&FF_BUG_NO_PADDING
)){ //FIXME perhaps solve this more cleanly
292 int left
= s
->gb
.size_in_bits
- get_bits_count(&s
->gb
);
295 /* no markers in M$ crap */
296 if(s
->msmpeg4_version
&& s
->pict_type
==FF_I_TYPE
)
299 /* buggy padding but the frame should still end approximately at the bitstream end */
300 if((s
->workaround_bugs
&FF_BUG_NO_PADDING
) && s
->error_recognition
>=3)
302 else if((s
->workaround_bugs
&FF_BUG_NO_PADDING
))
303 max_extra
+= 256*256*256*64;
306 av_log(s
->avctx
, AV_LOG_ERROR
, "discarding %d junk bits at end, next would be %X\n", left
, show_bits(&s
->gb
, 24));
309 av_log(s
->avctx
, AV_LOG_ERROR
, "overreading %d bits\n", -left
);
311 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
);
316 av_log(s
->avctx
, AV_LOG_ERROR
, "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
317 s
->gb
.size_in_bits
- get_bits_count(&s
->gb
),
318 show_bits(&s
->gb
, 24), s
->padding_bug_score
);
320 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
);
325 int ff_h263_decode_frame(AVCodecContext
*avctx
,
326 void *data
, int *data_size
,
327 const uint8_t *buf
, int buf_size
)
329 MpegEncContext
*s
= avctx
->priv_data
;
331 AVFrame
*pict
= data
;
333 #ifdef PRINT_FRAME_TIME
334 uint64_t time
= rdtsc();
337 av_log(avctx
, AV_LOG_DEBUG
, "*****frame %d size=%d\n", avctx
->frame_number
, buf_size
);
339 av_log(avctx
, AV_LOG_DEBUG
, "bytes=%x %x %x %x\n", buf
[0], buf
[1], buf
[2], buf
[3]);
341 s
->flags
= avctx
->flags
;
342 s
->flags2
= avctx
->flags2
;
344 /* no supplementary picture */
346 /* special case for last picture */
347 if (s
->low_delay
==0 && s
->next_picture_ptr
) {
348 *pict
= *(AVFrame
*)s
->next_picture_ptr
;
349 s
->next_picture_ptr
= NULL
;
351 *data_size
= sizeof(AVFrame
);
357 if(s
->flags
&CODEC_FLAG_TRUNCATED
){
360 if(ENABLE_MPEG4_DECODER
&& s
->codec_id
==CODEC_ID_MPEG4
){
361 next
= ff_mpeg4_find_frame_end(&s
->parse_context
, buf
, buf_size
);
362 }else if(ENABLE_H263_DECODER
&& s
->codec_id
==CODEC_ID_H263
){
363 next
= ff_h263_find_frame_end(&s
->parse_context
, buf
, buf_size
);
365 av_log(s
->avctx
, AV_LOG_ERROR
, "this codec does not support truncated bitstreams\n");
369 if( ff_combine_frame(&s
->parse_context
, next
, (const uint8_t **)&buf
, &buf_size
) < 0 )
376 if(s
->bitstream_buffer_size
&& (s
->divx_packed
|| buf_size
<20)){ //divx 5.01+/xvid frame reorder
377 init_get_bits(&s
->gb
, s
->bitstream_buffer
, s
->bitstream_buffer_size
*8);
379 init_get_bits(&s
->gb
, buf
, buf_size
*8);
380 s
->bitstream_buffer_size
=0;
382 if (!s
->context_initialized
) {
383 if (MPV_common_init(s
) < 0) //we need the idct permutaton for reading a custom matrix
387 /* We need to set current_picture_ptr before reading the header,
388 * otherwise we cannot store anyting in there */
389 if(s
->current_picture_ptr
==NULL
|| s
->current_picture_ptr
->data
[0]){
390 int i
= ff_find_unused_picture(s
, 0);
391 s
->current_picture_ptr
= &s
->picture
[i
];
395 if (ENABLE_WMV2_DECODER
&& s
->msmpeg4_version
==5) {
396 ret
= ff_wmv2_decode_picture_header(s
);
397 } else if (ENABLE_MSMPEG4_DECODER
&& s
->msmpeg4_version
) {
398 ret
= msmpeg4_decode_picture_header(s
);
399 } else if (s
->h263_pred
) {
400 if(s
->avctx
->extradata_size
&& s
->picture_number
==0){
403 init_get_bits(&gb
, s
->avctx
->extradata
, s
->avctx
->extradata_size
*8);
404 ret
= ff_mpeg4_decode_picture_header(s
, &gb
);
406 ret
= ff_mpeg4_decode_picture_header(s
, &s
->gb
);
408 if(s
->flags
& CODEC_FLAG_LOW_DELAY
)
410 } else if (s
->codec_id
== CODEC_ID_H263I
) {
411 ret
= intel_h263_decode_picture_header(s
);
412 } else if (s
->h263_flv
) {
413 ret
= flv_h263_decode_picture_header(s
);
415 ret
= h263_decode_picture_header(s
);
418 if(ret
==FRAME_SKIPPED
) return get_consumed_bytes(s
, buf_size
);
420 /* skip if the header was thrashed */
422 av_log(s
->avctx
, AV_LOG_ERROR
, "header damaged\n");
426 avctx
->has_b_frames
= !s
->low_delay
;
428 if(s
->xvid_build
==0 && s
->divx_version
==0 && s
->lavc_build
==0){
429 if(s
->stream_codec_tag
== ff_get_fourcc("XVID") ||
430 s
->codec_tag
== ff_get_fourcc("XVID") || s
->codec_tag
== ff_get_fourcc("XVIX") ||
431 s
->codec_tag
== ff_get_fourcc("RMP4"))
434 if(s
->codec_tag
== ff_get_fourcc("DIVX") && s
->vo_type
==0 && s
->vol_control_parameters
==1
435 && s
->padding_bug_score
> 0 && s
->low_delay
) // XVID with modified fourcc
440 if(s
->xvid_build
==0 && s
->divx_version
==0 && s
->lavc_build
==0){
441 if(s
->codec_tag
== ff_get_fourcc("DIVX") && s
->vo_type
==0 && s
->vol_control_parameters
==0)
442 s
->divx_version
= 400; //divx 4
445 if(s
->xvid_build
&& s
->divx_version
){
450 if(s
->workaround_bugs
&FF_BUG_AUTODETECT
){
451 if(s
->codec_tag
== ff_get_fourcc("XVIX"))
452 s
->workaround_bugs
|= FF_BUG_XVID_ILACE
;
454 if(s
->codec_tag
== ff_get_fourcc("UMP4")){
455 s
->workaround_bugs
|= FF_BUG_UMP4
;
458 if(s
->divx_version
>=500 && s
->divx_build
<1814){
459 s
->workaround_bugs
|= FF_BUG_QPEL_CHROMA
;
462 if(s
->divx_version
>502 && s
->divx_build
<1814){
463 s
->workaround_bugs
|= FF_BUG_QPEL_CHROMA2
;
466 if(s
->xvid_build
&& s
->xvid_build
<=3)
467 s
->padding_bug_score
= 256*256*256*64;
469 if(s
->xvid_build
&& s
->xvid_build
<=1)
470 s
->workaround_bugs
|= FF_BUG_QPEL_CHROMA
;
472 if(s
->xvid_build
&& s
->xvid_build
<=12)
473 s
->workaround_bugs
|= FF_BUG_EDGE
;
475 if(s
->xvid_build
&& s
->xvid_build
<=32)
476 s
->workaround_bugs
|= FF_BUG_DC_CLIP
;
478 #define SET_QPEL_FUNC(postfix1, postfix2) \
479 s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\
480 s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\
481 s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
483 if(s
->lavc_build
&& s
->lavc_build
<4653)
484 s
->workaround_bugs
|= FF_BUG_STD_QPEL
;
486 if(s
->lavc_build
&& s
->lavc_build
<4655)
487 s
->workaround_bugs
|= FF_BUG_DIRECT_BLOCKSIZE
;
489 if(s
->lavc_build
&& s
->lavc_build
<4670){
490 s
->workaround_bugs
|= FF_BUG_EDGE
;
493 if(s
->lavc_build
&& s
->lavc_build
<=4712)
494 s
->workaround_bugs
|= FF_BUG_DC_CLIP
;
497 s
->workaround_bugs
|= FF_BUG_DIRECT_BLOCKSIZE
;
498 //printf("padding_bug_score: %d\n", s->padding_bug_score);
499 if(s
->divx_version
==501 && s
->divx_build
==20020416)
500 s
->padding_bug_score
= 256*256*256*64;
502 if(s
->divx_version
&& s
->divx_version
<500){
503 s
->workaround_bugs
|= FF_BUG_EDGE
;
507 s
->workaround_bugs
|= FF_BUG_HPEL_CHROMA
;
509 if(s
->divx_version
==500)
510 s
->padding_bug_score
= 256*256*256*64;
512 /* very ugly XVID padding bug detection FIXME/XXX solve this differently
513 * Let us hope this at least works.
515 if( s
->resync_marker
==0 && s
->data_partitioning
==0 && s
->divx_version
==0
516 && s
->codec_id
==CODEC_ID_MPEG4
&& s
->vo_type
==0)
517 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
519 if(s
->lavc_build
&& s
->lavc_build
<4609) //FIXME not sure about the version num but a 4609 file seems ok
520 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
524 if(s
->workaround_bugs
& FF_BUG_STD_QPEL
){
525 SET_QPEL_FUNC(qpel_pixels_tab
[0][ 5], qpel16_mc11_old_c
)
526 SET_QPEL_FUNC(qpel_pixels_tab
[0][ 7], qpel16_mc31_old_c
)
527 SET_QPEL_FUNC(qpel_pixels_tab
[0][ 9], qpel16_mc12_old_c
)
528 SET_QPEL_FUNC(qpel_pixels_tab
[0][11], qpel16_mc32_old_c
)
529 SET_QPEL_FUNC(qpel_pixels_tab
[0][13], qpel16_mc13_old_c
)
530 SET_QPEL_FUNC(qpel_pixels_tab
[0][15], qpel16_mc33_old_c
)
532 SET_QPEL_FUNC(qpel_pixels_tab
[1][ 5], qpel8_mc11_old_c
)
533 SET_QPEL_FUNC(qpel_pixels_tab
[1][ 7], qpel8_mc31_old_c
)
534 SET_QPEL_FUNC(qpel_pixels_tab
[1][ 9], qpel8_mc12_old_c
)
535 SET_QPEL_FUNC(qpel_pixels_tab
[1][11], qpel8_mc32_old_c
)
536 SET_QPEL_FUNC(qpel_pixels_tab
[1][13], qpel8_mc13_old_c
)
537 SET_QPEL_FUNC(qpel_pixels_tab
[1][15], qpel8_mc33_old_c
)
540 if(avctx
->debug
& FF_DEBUG_BUGS
)
541 av_log(s
->avctx
, AV_LOG_DEBUG
, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
542 s
->workaround_bugs
, s
->lavc_build
, s
->xvid_build
, s
->divx_version
, s
->divx_build
,
543 s
->divx_packed
? "p" : "");
545 #if 0 // dump bits per frame / qp / complexity
548 if(!f
) f
=fopen("rate_qp_cplx.txt", "w");
549 fprintf(f
, "%d %d %f\n", buf_size
, s
->qscale
, buf_size
*(double)s
->qscale
);
553 #if defined(HAVE_MMX)
554 if(s
->codec_id
== CODEC_ID_MPEG4
&& s
->xvid_build
&& avctx
->idct_algo
== FF_IDCT_AUTO
&& (mm_flags
& FF_MM_MMX
)){
555 avctx
->idct_algo
= FF_IDCT_XVIDMMX
;
556 avctx
->coded_width
= 0; // force reinit
557 // dsputil_init(&s->dsp, avctx);
562 /* After H263 & mpeg4 header decode we have the height, width,*/
563 /* and other parameters. So then we could init the picture */
564 /* FIXME: By the way H263 decoder is evolving it should have */
565 /* an H263EncContext */
567 if ( s
->width
!= avctx
->coded_width
568 || s
->height
!= avctx
->coded_height
) {
569 /* H.263 could change picture size any time */
570 ParseContext pc
= s
->parse_context
; //FIXME move these demuxng hack to avformat
571 s
->parse_context
.buffer
=0;
573 s
->parse_context
= pc
;
575 if (!s
->context_initialized
) {
576 avcodec_set_dimensions(avctx
, s
->width
, s
->height
);
581 if((s
->codec_id
==CODEC_ID_H263
|| s
->codec_id
==CODEC_ID_H263P
))
582 s
->gob_index
= ff_h263_get_gob_height(s
);
585 s
->current_picture
.pict_type
= s
->pict_type
;
586 s
->current_picture
.key_frame
= s
->pict_type
== FF_I_TYPE
;
588 /* skip B-frames if we don't have reference frames */
589 if(s
->last_picture_ptr
==NULL
&& (s
->pict_type
==FF_B_TYPE
|| s
->dropable
)) return get_consumed_bytes(s
, buf_size
);
590 /* skip b frames if we are in a hurry */
591 if(avctx
->hurry_up
&& s
->pict_type
==FF_B_TYPE
) return get_consumed_bytes(s
, buf_size
);
592 if( (avctx
->skip_frame
>= AVDISCARD_NONREF
&& s
->pict_type
==FF_B_TYPE
)
593 || (avctx
->skip_frame
>= AVDISCARD_NONKEY
&& s
->pict_type
!=FF_I_TYPE
)
594 || avctx
->skip_frame
>= AVDISCARD_ALL
)
595 return get_consumed_bytes(s
, buf_size
);
596 /* skip everything if we are in a hurry>=5 */
597 if(avctx
->hurry_up
>=5) return get_consumed_bytes(s
, buf_size
);
599 if(s
->next_p_frame_damaged
){
600 if(s
->pict_type
==FF_B_TYPE
)
601 return get_consumed_bytes(s
, buf_size
);
603 s
->next_p_frame_damaged
=0;
606 if((s
->avctx
->flags2
& CODEC_FLAG2_FAST
) && s
->pict_type
==FF_B_TYPE
){
607 s
->me
.qpel_put
= s
->dsp
.put_2tap_qpel_pixels_tab
;
608 s
->me
.qpel_avg
= s
->dsp
.avg_2tap_qpel_pixels_tab
;
609 }else if((!s
->no_rounding
) || s
->pict_type
==FF_B_TYPE
){
610 s
->me
.qpel_put
= s
->dsp
.put_qpel_pixels_tab
;
611 s
->me
.qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
613 s
->me
.qpel_put
= s
->dsp
.put_no_rnd_qpel_pixels_tab
;
614 s
->me
.qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
617 if(MPV_frame_start(s
, avctx
) < 0)
621 av_log(avctx
, AV_LOG_DEBUG
, "qscale=%d\n", s
->qscale
);
624 ff_er_frame_start(s
);
626 //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type
627 //which is not available before MPV_frame_start()
628 if (ENABLE_WMV2_DECODER
&& s
->msmpeg4_version
==5){
629 ret
= ff_wmv2_decode_secondary_picture_header(s
);
630 if(ret
<0) return ret
;
631 if(ret
==1) goto intrax8_decoded
;
634 /* decode each macroblock */
639 while(s
->mb_y
<s
->mb_height
){
640 if(s
->msmpeg4_version
){
641 if(s
->slice_height
==0 || s
->mb_x
!=0 || (s
->mb_y
%s
->slice_height
)!=0 || get_bits_count(&s
->gb
) > s
->gb
.size_in_bits
)
644 if(ff_h263_resync(s
)<0)
648 if(s
->msmpeg4_version
<4 && s
->h263_pred
)
649 ff_mpeg4_clean_buffers(s
);
654 if (s
->h263_msmpeg4
&& s
->msmpeg4_version
<4 && s
->pict_type
==FF_I_TYPE
)
655 if(!ENABLE_MSMPEG4_DECODER
|| msmpeg4_decode_ext_header(s
, buf_size
) < 0){
656 s
->error_status_table
[s
->mb_num
-1]= AC_ERROR
|DC_ERROR
|MV_ERROR
;
659 /* divx 5.01+ bistream reorder stuff */
660 if(s
->codec_id
==CODEC_ID_MPEG4
&& s
->bitstream_buffer_size
==0 && s
->divx_packed
){
661 int current_pos
= get_bits_count(&s
->gb
)>>3;
662 int startcode_found
=0;
664 if(buf_size
- current_pos
> 5){
666 for(i
=current_pos
; i
<buf_size
-3; i
++){
667 if(buf
[i
]==0 && buf
[i
+1]==0 && buf
[i
+2]==1 && buf
[i
+3]==0xB6){
673 if(s
->gb
.buffer
== s
->bitstream_buffer
&& buf_size
>20){ //xvid style
679 s
->bitstream_buffer
= av_fast_realloc(
681 &s
->allocated_bitstream_buffer_size
,
682 buf_size
- current_pos
+ FF_INPUT_BUFFER_PADDING_SIZE
);
683 memcpy(s
->bitstream_buffer
, buf
+ current_pos
, buf_size
- current_pos
);
684 s
->bitstream_buffer_size
= buf_size
- current_pos
;
693 assert(s
->current_picture
.pict_type
== s
->current_picture_ptr
->pict_type
);
694 assert(s
->current_picture
.pict_type
== s
->pict_type
);
695 if (s
->pict_type
== FF_B_TYPE
|| s
->low_delay
) {
696 *pict
= *(AVFrame
*)s
->current_picture_ptr
;
697 } else if (s
->last_picture_ptr
!= NULL
) {
698 *pict
= *(AVFrame
*)s
->last_picture_ptr
;
701 if(s
->last_picture_ptr
|| s
->low_delay
){
702 *data_size
= sizeof(AVFrame
);
703 ff_print_debug_info(s
, pict
);
706 /* Return the Picture timestamp as the frame number */
707 /* we subtract 1 because it is added on utils.c */
708 avctx
->frame_number
= s
->picture_number
- 1;
710 #ifdef PRINT_FRAME_TIME
711 av_log(avctx
, AV_LOG_DEBUG
, "%"PRId64
"\n", rdtsc()-time
);
714 return get_consumed_bytes(s
, buf_size
);
717 AVCodec mpeg4_decoder
= {
721 sizeof(MpegEncContext
),
725 ff_h263_decode_frame
,
726 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
| CODEC_CAP_TRUNCATED
| CODEC_CAP_DELAY
,
727 .flush
= ff_mpeg_flush
,
728 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
731 AVCodec h263_decoder
= {
735 sizeof(MpegEncContext
),
739 ff_h263_decode_frame
,
740 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
| CODEC_CAP_TRUNCATED
| CODEC_CAP_DELAY
,
741 .flush
= ff_mpeg_flush
,
742 .long_name
= NULL_IF_CONFIG_SMALL("H.263"),
745 AVCodec msmpeg4v1_decoder
= {
749 sizeof(MpegEncContext
),
753 ff_h263_decode_frame
,
754 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
755 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
758 AVCodec msmpeg4v2_decoder
= {
762 sizeof(MpegEncContext
),
766 ff_h263_decode_frame
,
767 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
768 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
771 AVCodec msmpeg4v3_decoder
= {
775 sizeof(MpegEncContext
),
779 ff_h263_decode_frame
,
780 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
781 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
784 AVCodec wmv1_decoder
= {
788 sizeof(MpegEncContext
),
792 ff_h263_decode_frame
,
793 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
794 .long_name
= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
797 AVCodec h263i_decoder
= {
801 sizeof(MpegEncContext
),
805 ff_h263_decode_frame
,
806 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
807 .long_name
= NULL_IF_CONFIG_SMALL("H.263i"),
810 AVCodec flv_decoder
= {
814 sizeof(MpegEncContext
),
818 ff_h263_decode_frame
,
819 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
820 .long_name
= NULL_IF_CONFIG_SMALL("Flash Video"),