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
24 * @file libavcodec/h263dec.c
31 #include "mpegvideo.h"
32 #include "h263_parser.h"
33 #include "mpeg4video_parser.h"
37 //#define PRINT_FRAME_TIME
39 av_cold
int ff_h263_decode_init(AVCodecContext
*avctx
)
41 MpegEncContext
*s
= avctx
->priv_data
;
44 s
->out_format
= FMT_H263
;
46 s
->width
= avctx
->coded_width
;
47 s
->height
= avctx
->coded_height
;
48 s
->workaround_bugs
= avctx
->workaround_bugs
;
51 MPV_decode_defaults(s
);
53 s
->decode_mb
= ff_h263_decode_mb
;
55 avctx
->pix_fmt
= avctx
->get_format(avctx
, avctx
->codec
->pix_fmts
);
56 s
->unrestricted_mv
= 1;
58 /* select sub codec */
59 switch(avctx
->codec
->id
) {
61 s
->unrestricted_mv
= 0;
64 s
->decode_mb
= ff_mpeg4_decode_mb
;
65 s
->time_increment_bits
= 4; /* default value for broken headers */
67 s
->low_delay
= 0; //default, might be overriden in the vol header during header parsing
69 case CODEC_ID_MSMPEG4V1
:
74 case CODEC_ID_MSMPEG4V2
:
79 case CODEC_ID_MSMPEG4V3
:
108 s
->codec_id
= avctx
->codec
->id
;
109 avctx
->hwaccel
= ff_find_hwaccel(avctx
->codec
->id
, avctx
->pix_fmt
);
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 (CONFIG_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;
138 if(s
->divx_packed
|| s
->avctx
->hwaccel
){
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
->avctx
->hwaccel
) {
165 const uint8_t *start
= s
->gb
.buffer
+ get_bits_count(&s
->gb
)/8;
166 const uint8_t *end
= ff_h263_find_resync_marker(start
+ 1, s
->gb
.buffer_end
);
167 skip_bits_long(&s
->gb
, 8*(end
- start
));
168 return s
->avctx
->hwaccel
->decode_slice(s
->avctx
, start
, end
- start
);
171 if(s
->partitioned_frame
){
172 const int qscale
= s
->qscale
;
174 if(s
->codec_id
==CODEC_ID_MPEG4
){
175 if(ff_mpeg4_decode_partitions(s
) < 0)
179 /* restore variables which were modified */
180 s
->first_slice_line
=1;
181 s
->mb_x
= s
->resync_mb_x
;
182 s
->mb_y
= s
->resync_mb_y
;
183 ff_set_qscale(s
, qscale
);
186 for(; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
187 /* per-row end of slice checks */
188 if(s
->msmpeg4_version
){
189 if(s
->resync_mb_y
+ s
->slice_height
== s
->mb_y
){
190 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
);
196 if(s
->msmpeg4_version
==1){
202 ff_init_block_index(s
);
203 for(; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
206 ff_update_block_index(s
);
208 if(s
->resync_mb_x
== s
->mb_x
&& s
->resync_mb_y
+1 == s
->mb_y
){
209 s
->first_slice_line
=0;
214 s
->mv_dir
= MV_DIR_FORWARD
;
215 s
->mv_type
= MV_TYPE_16X16
;
216 // s->mb_skipped = 0;
217 //printf("%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
218 ret
= s
->decode_mb(s
, s
->block
);
220 if (s
->pict_type
!=FF_B_TYPE
)
221 ff_h263_update_motion_val(s
);
224 const int xy
= s
->mb_x
+ s
->mb_y
*s
->mb_stride
;
226 MPV_decode_mb(s
, s
->block
);
228 ff_h263_loop_filter(s
);
230 //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));
231 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
);
233 s
->padding_bug_score
--;
235 if(++s
->mb_x
>= s
->mb_width
){
237 ff_draw_horiz_band(s
, s
->mb_y
*mb_size
, mb_size
);
241 }else if(ret
==SLICE_NOEND
){
242 av_log(s
->avctx
, AV_LOG_ERROR
, "Slice mismatch at MB: %d\n", xy
);
243 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
);
246 av_log(s
->avctx
, AV_LOG_ERROR
, "Error at MB: %d\n", xy
);
247 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
);
252 MPV_decode_mb(s
, s
->block
);
254 ff_h263_loop_filter(s
);
257 ff_draw_horiz_band(s
, s
->mb_y
*mb_size
, mb_size
);
262 assert(s
->mb_x
==0 && s
->mb_y
==s
->mb_height
);
264 /* try to detect the padding bug */
265 if( s
->codec_id
==CODEC_ID_MPEG4
266 && (s
->workaround_bugs
&FF_BUG_AUTODETECT
)
267 && s
->gb
.size_in_bits
- get_bits_count(&s
->gb
) >=0
268 && s
->gb
.size_in_bits
- get_bits_count(&s
->gb
) < 48
269 // && !s->resync_marker
270 && !s
->data_partitioning
){
272 const int bits_count
= get_bits_count(&s
->gb
);
273 const int bits_left
= s
->gb
.size_in_bits
- bits_count
;
276 s
->padding_bug_score
+=16;
277 } else if(bits_left
!= 1){
278 int v
= show_bits(&s
->gb
, 8);
279 v
|= 0x7F >> (7-(bits_count
&7));
281 if(v
==0x7F && bits_left
<=8)
282 s
->padding_bug_score
--;
283 else if(v
==0x7F && ((get_bits_count(&s
->gb
)+8)&8) && bits_left
<=16)
284 s
->padding_bug_score
+= 4;
286 s
->padding_bug_score
++;
290 if(s
->workaround_bugs
&FF_BUG_AUTODETECT
){
291 if(s
->padding_bug_score
> -2 && !s
->data_partitioning
/*&& (s->divx_version || !s->resync_marker)*/)
292 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
294 s
->workaround_bugs
&= ~FF_BUG_NO_PADDING
;
297 // handle formats which don't have unique end markers
298 if(s
->msmpeg4_version
|| (s
->workaround_bugs
&FF_BUG_NO_PADDING
)){ //FIXME perhaps solve this more cleanly
299 int left
= s
->gb
.size_in_bits
- get_bits_count(&s
->gb
);
302 /* no markers in M$ crap */
303 if(s
->msmpeg4_version
&& s
->pict_type
==FF_I_TYPE
)
306 /* buggy padding but the frame should still end approximately at the bitstream end */
307 if((s
->workaround_bugs
&FF_BUG_NO_PADDING
) && s
->error_recognition
>=3)
309 else if((s
->workaround_bugs
&FF_BUG_NO_PADDING
))
310 max_extra
+= 256*256*256*64;
313 av_log(s
->avctx
, AV_LOG_ERROR
, "discarding %d junk bits at end, next would be %X\n", left
, show_bits(&s
->gb
, 24));
316 av_log(s
->avctx
, AV_LOG_ERROR
, "overreading %d bits\n", -left
);
318 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
);
323 av_log(s
->avctx
, AV_LOG_ERROR
, "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
324 s
->gb
.size_in_bits
- get_bits_count(&s
->gb
),
325 show_bits(&s
->gb
, 24), s
->padding_bug_score
);
327 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
);
332 int ff_h263_decode_frame(AVCodecContext
*avctx
,
333 void *data
, int *data_size
,
334 const uint8_t *buf
, int buf_size
)
336 MpegEncContext
*s
= avctx
->priv_data
;
338 AVFrame
*pict
= data
;
340 #ifdef PRINT_FRAME_TIME
341 uint64_t time
= rdtsc();
344 av_log(avctx
, AV_LOG_DEBUG
, "*****frame %d size=%d\n", avctx
->frame_number
, buf_size
);
346 av_log(avctx
, AV_LOG_DEBUG
, "bytes=%x %x %x %x\n", buf
[0], buf
[1], buf
[2], buf
[3]);
348 s
->flags
= avctx
->flags
;
349 s
->flags2
= avctx
->flags2
;
351 /* no supplementary picture */
353 /* special case for last picture */
354 if (s
->low_delay
==0 && s
->next_picture_ptr
) {
355 *pict
= *(AVFrame
*)s
->next_picture_ptr
;
356 s
->next_picture_ptr
= NULL
;
358 *data_size
= sizeof(AVFrame
);
364 if(s
->flags
&CODEC_FLAG_TRUNCATED
){
367 if(CONFIG_MPEG4_DECODER
&& s
->codec_id
==CODEC_ID_MPEG4
){
368 next
= ff_mpeg4_find_frame_end(&s
->parse_context
, buf
, buf_size
);
369 }else if(CONFIG_H263_DECODER
&& s
->codec_id
==CODEC_ID_H263
){
370 next
= ff_h263_find_frame_end(&s
->parse_context
, buf
, buf_size
);
372 av_log(s
->avctx
, AV_LOG_ERROR
, "this codec does not support truncated bitstreams\n");
376 if( ff_combine_frame(&s
->parse_context
, next
, (const uint8_t **)&buf
, &buf_size
) < 0 )
383 if(s
->bitstream_buffer_size
&& (s
->divx_packed
|| buf_size
<20)){ //divx 5.01+/xvid frame reorder
384 init_get_bits(&s
->gb
, s
->bitstream_buffer
, s
->bitstream_buffer_size
*8);
386 init_get_bits(&s
->gb
, buf
, buf_size
*8);
387 s
->bitstream_buffer_size
=0;
389 if (!s
->context_initialized
) {
390 if (MPV_common_init(s
) < 0) //we need the idct permutaton for reading a custom matrix
394 /* We need to set current_picture_ptr before reading the header,
395 * otherwise we cannot store anyting in there */
396 if(s
->current_picture_ptr
==NULL
|| s
->current_picture_ptr
->data
[0]){
397 int i
= ff_find_unused_picture(s
, 0);
398 s
->current_picture_ptr
= &s
->picture
[i
];
402 if (CONFIG_WMV2_DECODER
&& s
->msmpeg4_version
==5) {
403 ret
= ff_wmv2_decode_picture_header(s
);
404 } else if (CONFIG_MSMPEG4_DECODER
&& s
->msmpeg4_version
) {
405 ret
= msmpeg4_decode_picture_header(s
);
406 } else if (s
->h263_pred
) {
407 if(s
->avctx
->extradata_size
&& s
->picture_number
==0){
410 init_get_bits(&gb
, s
->avctx
->extradata
, s
->avctx
->extradata_size
*8);
411 ret
= ff_mpeg4_decode_picture_header(s
, &gb
);
413 ret
= ff_mpeg4_decode_picture_header(s
, &s
->gb
);
414 } else if (s
->codec_id
== CODEC_ID_H263I
) {
415 ret
= intel_h263_decode_picture_header(s
);
416 } else if (s
->h263_flv
) {
417 ret
= flv_h263_decode_picture_header(s
);
419 ret
= h263_decode_picture_header(s
);
422 if(ret
==FRAME_SKIPPED
) return get_consumed_bytes(s
, buf_size
);
424 /* skip if the header was thrashed */
426 av_log(s
->avctx
, AV_LOG_ERROR
, "header damaged\n");
430 avctx
->has_b_frames
= !s
->low_delay
;
432 if(s
->xvid_build
==0 && s
->divx_version
==0 && s
->lavc_build
==0){
433 if(s
->stream_codec_tag
== AV_RL32("XVID") ||
434 s
->codec_tag
== AV_RL32("XVID") || s
->codec_tag
== AV_RL32("XVIX") ||
435 s
->codec_tag
== AV_RL32("RMP4"))
438 if(s
->codec_tag
== AV_RL32("DIVX") && s
->vo_type
==0 && s
->vol_control_parameters
==1
439 && s
->padding_bug_score
> 0 && s
->low_delay
) // XVID with modified fourcc
444 if(s
->xvid_build
==0 && s
->divx_version
==0 && s
->lavc_build
==0){
445 if(s
->codec_tag
== AV_RL32("DIVX") && s
->vo_type
==0 && s
->vol_control_parameters
==0)
446 s
->divx_version
= 400; //divx 4
449 if(s
->xvid_build
&& s
->divx_version
){
454 if(s
->workaround_bugs
&FF_BUG_AUTODETECT
){
455 if(s
->codec_tag
== AV_RL32("XVIX"))
456 s
->workaround_bugs
|= FF_BUG_XVID_ILACE
;
458 if(s
->codec_tag
== AV_RL32("UMP4")){
459 s
->workaround_bugs
|= FF_BUG_UMP4
;
462 if(s
->divx_version
>=500 && s
->divx_build
<1814){
463 s
->workaround_bugs
|= FF_BUG_QPEL_CHROMA
;
466 if(s
->divx_version
>502 && s
->divx_build
<1814){
467 s
->workaround_bugs
|= FF_BUG_QPEL_CHROMA2
;
470 if(s
->xvid_build
&& s
->xvid_build
<=3)
471 s
->padding_bug_score
= 256*256*256*64;
473 if(s
->xvid_build
&& s
->xvid_build
<=1)
474 s
->workaround_bugs
|= FF_BUG_QPEL_CHROMA
;
476 if(s
->xvid_build
&& s
->xvid_build
<=12)
477 s
->workaround_bugs
|= FF_BUG_EDGE
;
479 if(s
->xvid_build
&& s
->xvid_build
<=32)
480 s
->workaround_bugs
|= FF_BUG_DC_CLIP
;
482 #define SET_QPEL_FUNC(postfix1, postfix2) \
483 s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\
484 s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\
485 s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
487 if(s
->lavc_build
&& s
->lavc_build
<4653)
488 s
->workaround_bugs
|= FF_BUG_STD_QPEL
;
490 if(s
->lavc_build
&& s
->lavc_build
<4655)
491 s
->workaround_bugs
|= FF_BUG_DIRECT_BLOCKSIZE
;
493 if(s
->lavc_build
&& s
->lavc_build
<4670){
494 s
->workaround_bugs
|= FF_BUG_EDGE
;
497 if(s
->lavc_build
&& s
->lavc_build
<=4712)
498 s
->workaround_bugs
|= FF_BUG_DC_CLIP
;
501 s
->workaround_bugs
|= FF_BUG_DIRECT_BLOCKSIZE
;
502 //printf("padding_bug_score: %d\n", s->padding_bug_score);
503 if(s
->divx_version
==501 && s
->divx_build
==20020416)
504 s
->padding_bug_score
= 256*256*256*64;
506 if(s
->divx_version
&& s
->divx_version
<500){
507 s
->workaround_bugs
|= FF_BUG_EDGE
;
511 s
->workaround_bugs
|= FF_BUG_HPEL_CHROMA
;
513 if(s
->divx_version
==500)
514 s
->padding_bug_score
= 256*256*256*64;
516 /* very ugly XVID padding bug detection FIXME/XXX solve this differently
517 * Let us hope this at least works.
519 if( s
->resync_marker
==0 && s
->data_partitioning
==0 && s
->divx_version
==0
520 && s
->codec_id
==CODEC_ID_MPEG4
&& s
->vo_type
==0)
521 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
523 if(s
->lavc_build
&& s
->lavc_build
<4609) //FIXME not sure about the version num but a 4609 file seems ok
524 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
528 if(s
->workaround_bugs
& FF_BUG_STD_QPEL
){
529 SET_QPEL_FUNC(qpel_pixels_tab
[0][ 5], qpel16_mc11_old_c
)
530 SET_QPEL_FUNC(qpel_pixels_tab
[0][ 7], qpel16_mc31_old_c
)
531 SET_QPEL_FUNC(qpel_pixels_tab
[0][ 9], qpel16_mc12_old_c
)
532 SET_QPEL_FUNC(qpel_pixels_tab
[0][11], qpel16_mc32_old_c
)
533 SET_QPEL_FUNC(qpel_pixels_tab
[0][13], qpel16_mc13_old_c
)
534 SET_QPEL_FUNC(qpel_pixels_tab
[0][15], qpel16_mc33_old_c
)
536 SET_QPEL_FUNC(qpel_pixels_tab
[1][ 5], qpel8_mc11_old_c
)
537 SET_QPEL_FUNC(qpel_pixels_tab
[1][ 7], qpel8_mc31_old_c
)
538 SET_QPEL_FUNC(qpel_pixels_tab
[1][ 9], qpel8_mc12_old_c
)
539 SET_QPEL_FUNC(qpel_pixels_tab
[1][11], qpel8_mc32_old_c
)
540 SET_QPEL_FUNC(qpel_pixels_tab
[1][13], qpel8_mc13_old_c
)
541 SET_QPEL_FUNC(qpel_pixels_tab
[1][15], qpel8_mc33_old_c
)
544 if(avctx
->debug
& FF_DEBUG_BUGS
)
545 av_log(s
->avctx
, AV_LOG_DEBUG
, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
546 s
->workaround_bugs
, s
->lavc_build
, s
->xvid_build
, s
->divx_version
, s
->divx_build
,
547 s
->divx_packed
? "p" : "");
549 #if 0 // dump bits per frame / qp / complexity
552 if(!f
) f
=fopen("rate_qp_cplx.txt", "w");
553 fprintf(f
, "%d %d %f\n", buf_size
, s
->qscale
, buf_size
*(double)s
->qscale
);
558 if(s
->codec_id
== CODEC_ID_MPEG4
&& s
->xvid_build
&& avctx
->idct_algo
== FF_IDCT_AUTO
&& (mm_flags
& FF_MM_MMX
)){
559 avctx
->idct_algo
= FF_IDCT_XVIDMMX
;
560 avctx
->coded_width
= 0; // force reinit
561 // dsputil_init(&s->dsp, avctx);
566 /* After H263 & mpeg4 header decode we have the height, width,*/
567 /* and other parameters. So then we could init the picture */
568 /* FIXME: By the way H263 decoder is evolving it should have */
569 /* an H263EncContext */
571 if ( s
->width
!= avctx
->coded_width
572 || s
->height
!= avctx
->coded_height
) {
573 /* H.263 could change picture size any time */
574 ParseContext pc
= s
->parse_context
; //FIXME move these demuxng hack to avformat
575 s
->parse_context
.buffer
=0;
577 s
->parse_context
= pc
;
579 if (!s
->context_initialized
) {
580 avcodec_set_dimensions(avctx
, s
->width
, s
->height
);
585 if((s
->codec_id
==CODEC_ID_H263
|| s
->codec_id
==CODEC_ID_H263P
|| s
->codec_id
== CODEC_ID_H263I
))
586 s
->gob_index
= ff_h263_get_gob_height(s
);
589 s
->current_picture
.pict_type
= s
->pict_type
;
590 s
->current_picture
.key_frame
= s
->pict_type
== FF_I_TYPE
;
592 /* skip B-frames if we don't have reference frames */
593 if(s
->last_picture_ptr
==NULL
&& (s
->pict_type
==FF_B_TYPE
|| s
->dropable
)) return get_consumed_bytes(s
, buf_size
);
594 /* skip b frames if we are in a hurry */
595 if(avctx
->hurry_up
&& s
->pict_type
==FF_B_TYPE
) return get_consumed_bytes(s
, buf_size
);
596 if( (avctx
->skip_frame
>= AVDISCARD_NONREF
&& s
->pict_type
==FF_B_TYPE
)
597 || (avctx
->skip_frame
>= AVDISCARD_NONKEY
&& s
->pict_type
!=FF_I_TYPE
)
598 || avctx
->skip_frame
>= AVDISCARD_ALL
)
599 return get_consumed_bytes(s
, buf_size
);
600 /* skip everything if we are in a hurry>=5 */
601 if(avctx
->hurry_up
>=5) return get_consumed_bytes(s
, buf_size
);
603 if(s
->next_p_frame_damaged
){
604 if(s
->pict_type
==FF_B_TYPE
)
605 return get_consumed_bytes(s
, buf_size
);
607 s
->next_p_frame_damaged
=0;
610 if((s
->avctx
->flags2
& CODEC_FLAG2_FAST
) && s
->pict_type
==FF_B_TYPE
){
611 s
->me
.qpel_put
= s
->dsp
.put_2tap_qpel_pixels_tab
;
612 s
->me
.qpel_avg
= s
->dsp
.avg_2tap_qpel_pixels_tab
;
613 }else if((!s
->no_rounding
) || s
->pict_type
==FF_B_TYPE
){
614 s
->me
.qpel_put
= s
->dsp
.put_qpel_pixels_tab
;
615 s
->me
.qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
617 s
->me
.qpel_put
= s
->dsp
.put_no_rnd_qpel_pixels_tab
;
618 s
->me
.qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
621 if(MPV_frame_start(s
, avctx
) < 0)
624 if (avctx
->hwaccel
) {
625 if (avctx
->hwaccel
->start_frame(avctx
, buf
, buf_size
) < 0)
630 av_log(avctx
, AV_LOG_DEBUG
, "qscale=%d\n", s
->qscale
);
633 ff_er_frame_start(s
);
635 //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type
636 //which is not available before MPV_frame_start()
637 if (CONFIG_WMV2_DECODER
&& s
->msmpeg4_version
==5){
638 ret
= ff_wmv2_decode_secondary_picture_header(s
);
639 if(ret
<0) return ret
;
640 if(ret
==1) goto intrax8_decoded
;
643 /* decode each macroblock */
648 while(s
->mb_y
<s
->mb_height
){
649 if(s
->msmpeg4_version
){
650 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
)
653 if(ff_h263_resync(s
)<0)
657 if(s
->msmpeg4_version
<4 && s
->h263_pred
)
658 ff_mpeg4_clean_buffers(s
);
663 if (s
->h263_msmpeg4
&& s
->msmpeg4_version
<4 && s
->pict_type
==FF_I_TYPE
)
664 if(!CONFIG_MSMPEG4_DECODER
|| msmpeg4_decode_ext_header(s
, buf_size
) < 0){
665 s
->error_status_table
[s
->mb_num
-1]= AC_ERROR
|DC_ERROR
|MV_ERROR
;
668 /* divx 5.01+ bistream reorder stuff */
669 if(s
->codec_id
==CODEC_ID_MPEG4
&& s
->bitstream_buffer_size
==0 && s
->divx_packed
){
670 int current_pos
= get_bits_count(&s
->gb
)>>3;
671 int startcode_found
=0;
673 if(buf_size
- current_pos
> 5){
675 for(i
=current_pos
; i
<buf_size
-3; i
++){
676 if(buf
[i
]==0 && buf
[i
+1]==0 && buf
[i
+2]==1 && buf
[i
+3]==0xB6){
682 if(s
->gb
.buffer
== s
->bitstream_buffer
&& buf_size
>20){ //xvid style
688 s
->bitstream_buffer
= av_fast_realloc(
690 &s
->allocated_bitstream_buffer_size
,
691 buf_size
- current_pos
+ FF_INPUT_BUFFER_PADDING_SIZE
);
692 memcpy(s
->bitstream_buffer
, buf
+ current_pos
, buf_size
- current_pos
);
693 s
->bitstream_buffer_size
= buf_size
- current_pos
;
700 if (avctx
->hwaccel
) {
701 if (avctx
->hwaccel
->end_frame(avctx
) < 0)
707 assert(s
->current_picture
.pict_type
== s
->current_picture_ptr
->pict_type
);
708 assert(s
->current_picture
.pict_type
== s
->pict_type
);
709 if (s
->pict_type
== FF_B_TYPE
|| s
->low_delay
) {
710 *pict
= *(AVFrame
*)s
->current_picture_ptr
;
711 } else if (s
->last_picture_ptr
!= NULL
) {
712 *pict
= *(AVFrame
*)s
->last_picture_ptr
;
715 if(s
->last_picture_ptr
|| s
->low_delay
){
716 *data_size
= sizeof(AVFrame
);
717 ff_print_debug_info(s
, pict
);
720 /* Return the Picture timestamp as the frame number */
721 /* we subtract 1 because it is added on utils.c */
722 avctx
->frame_number
= s
->picture_number
- 1;
724 #ifdef PRINT_FRAME_TIME
725 av_log(avctx
, AV_LOG_DEBUG
, "%"PRId64
"\n", rdtsc()-time
);
728 return get_consumed_bytes(s
, buf_size
);
731 AVCodec mpeg4_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("MPEG-4 part 2"),
743 .pix_fmts
= ff_hwaccel_pixfmt_list_420
,
746 AVCodec h263_decoder
= {
750 sizeof(MpegEncContext
),
754 ff_h263_decode_frame
,
755 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
| CODEC_CAP_TRUNCATED
| CODEC_CAP_DELAY
,
756 .flush
= ff_mpeg_flush
,
757 .long_name
= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
758 .pix_fmts
= ff_hwaccel_pixfmt_list_420
,
761 AVCodec msmpeg4v1_decoder
= {
765 sizeof(MpegEncContext
),
769 ff_h263_decode_frame
,
770 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
771 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
772 .pix_fmts
= ff_pixfmt_list_420
,
775 AVCodec msmpeg4v2_decoder
= {
779 sizeof(MpegEncContext
),
783 ff_h263_decode_frame
,
784 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
785 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
786 .pix_fmts
= ff_pixfmt_list_420
,
789 AVCodec msmpeg4v3_decoder
= {
793 sizeof(MpegEncContext
),
797 ff_h263_decode_frame
,
798 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
799 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
800 .pix_fmts
= ff_pixfmt_list_420
,
803 AVCodec wmv1_decoder
= {
807 sizeof(MpegEncContext
),
811 ff_h263_decode_frame
,
812 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
813 .long_name
= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
814 .pix_fmts
= ff_pixfmt_list_420
,
817 AVCodec h263i_decoder
= {
821 sizeof(MpegEncContext
),
825 ff_h263_decode_frame
,
826 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
827 .long_name
= NULL_IF_CONFIG_SMALL("Intel H.263"),
828 .pix_fmts
= ff_pixfmt_list_420
,
831 AVCodec flv_decoder
= {
835 sizeof(MpegEncContext
),
839 ff_h263_decode_frame
,
840 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
841 .long_name
= NULL_IF_CONFIG_SMALL("Flash Video (FLV)"),
842 .pix_fmts
= ff_pixfmt_list_420
,