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;
62 avctx
->chroma_sample_location
= AVCHROMA_LOC_CENTER
;
65 s
->decode_mb
= ff_mpeg4_decode_mb
;
66 s
->time_increment_bits
= 4; /* default value for broken headers */
68 s
->low_delay
= 0; //default, might be overriden in the vol header during header parsing
69 avctx
->chroma_sample_location
= AVCHROMA_LOC_LEFT
;
71 case CODEC_ID_MSMPEG4V1
:
76 case CODEC_ID_MSMPEG4V2
:
81 case CODEC_ID_MSMPEG4V3
:
100 s
->msmpeg4_version
=6;
101 avctx
->chroma_sample_location
= AVCHROMA_LOC_LEFT
;
111 s
->codec_id
= avctx
->codec
->id
;
112 avctx
->hwaccel
= ff_find_hwaccel(avctx
->codec
->id
, avctx
->pix_fmt
);
114 /* for h263, we allocate the images after having read the header */
115 if (avctx
->codec
->id
!= CODEC_ID_H263
&& avctx
->codec
->id
!= CODEC_ID_MPEG4
)
116 if (MPV_common_init(s
) < 0)
119 if (CONFIG_MSMPEG4_DECODER
&& s
->h263_msmpeg4
)
120 ff_msmpeg4_decode_init(s
);
122 h263_decode_init_vlc(s
);
127 av_cold
int ff_h263_decode_end(AVCodecContext
*avctx
)
129 MpegEncContext
*s
= avctx
->priv_data
;
136 * returns the number of bytes consumed for building the current frame
138 static int get_consumed_bytes(MpegEncContext
*s
, int buf_size
){
139 int pos
= (get_bits_count(&s
->gb
)+7)>>3;
141 if(s
->divx_packed
|| s
->avctx
->hwaccel
){
142 //we would have to scan through the whole buf to handle the weird reordering ...
144 }else if(s
->flags
&CODEC_FLAG_TRUNCATED
){
145 pos
-= s
->parse_context
.last_index
;
146 if(pos
<0) pos
=0; // padding is not really read so this might be -1
149 if(pos
==0) pos
=1; //avoid infinite loops (i doubt that is needed but ...)
150 if(pos
+10>buf_size
) pos
=buf_size
; // oops ;)
156 static int decode_slice(MpegEncContext
*s
){
157 const int part_mask
= s
->partitioned_frame
? (AC_END
|AC_ERROR
) : 0x7F;
158 const int mb_size
= 16>>s
->avctx
->lowres
;
159 s
->last_resync_gb
= s
->gb
;
160 s
->first_slice_line
= 1;
162 s
->resync_mb_x
= s
->mb_x
;
163 s
->resync_mb_y
= s
->mb_y
;
165 ff_set_qscale(s
, s
->qscale
);
167 if (s
->avctx
->hwaccel
) {
168 const uint8_t *start
= s
->gb
.buffer
+ get_bits_count(&s
->gb
)/8;
169 const uint8_t *end
= ff_h263_find_resync_marker(start
+ 1, s
->gb
.buffer_end
);
170 skip_bits_long(&s
->gb
, 8*(end
- start
));
171 return s
->avctx
->hwaccel
->decode_slice(s
->avctx
, start
, end
- start
);
174 if(s
->partitioned_frame
){
175 const int qscale
= s
->qscale
;
177 if(s
->codec_id
==CODEC_ID_MPEG4
){
178 if(ff_mpeg4_decode_partitions(s
) < 0)
182 /* restore variables which were modified */
183 s
->first_slice_line
=1;
184 s
->mb_x
= s
->resync_mb_x
;
185 s
->mb_y
= s
->resync_mb_y
;
186 ff_set_qscale(s
, qscale
);
189 for(; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
190 /* per-row end of slice checks */
191 if(s
->msmpeg4_version
){
192 if(s
->resync_mb_y
+ s
->slice_height
== s
->mb_y
){
193 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
);
199 if(s
->msmpeg4_version
==1){
205 ff_init_block_index(s
);
206 for(; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
209 ff_update_block_index(s
);
211 if(s
->resync_mb_x
== s
->mb_x
&& s
->resync_mb_y
+1 == s
->mb_y
){
212 s
->first_slice_line
=0;
217 s
->mv_dir
= MV_DIR_FORWARD
;
218 s
->mv_type
= MV_TYPE_16X16
;
219 // s->mb_skipped = 0;
220 //printf("%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
221 ret
= s
->decode_mb(s
, s
->block
);
223 if (s
->pict_type
!=FF_B_TYPE
)
224 ff_h263_update_motion_val(s
);
227 const int xy
= s
->mb_x
+ s
->mb_y
*s
->mb_stride
;
229 MPV_decode_mb(s
, s
->block
);
231 ff_h263_loop_filter(s
);
233 //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));
234 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
);
236 s
->padding_bug_score
--;
238 if(++s
->mb_x
>= s
->mb_width
){
240 ff_draw_horiz_band(s
, s
->mb_y
*mb_size
, mb_size
);
244 }else if(ret
==SLICE_NOEND
){
245 av_log(s
->avctx
, AV_LOG_ERROR
, "Slice mismatch at MB: %d\n", xy
);
246 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
);
249 av_log(s
->avctx
, AV_LOG_ERROR
, "Error at MB: %d\n", xy
);
250 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
);
255 MPV_decode_mb(s
, s
->block
);
257 ff_h263_loop_filter(s
);
260 ff_draw_horiz_band(s
, s
->mb_y
*mb_size
, mb_size
);
265 assert(s
->mb_x
==0 && s
->mb_y
==s
->mb_height
);
267 /* try to detect the padding bug */
268 if( s
->codec_id
==CODEC_ID_MPEG4
269 && (s
->workaround_bugs
&FF_BUG_AUTODETECT
)
270 && s
->gb
.size_in_bits
- get_bits_count(&s
->gb
) >=0
271 && s
->gb
.size_in_bits
- get_bits_count(&s
->gb
) < 48
272 // && !s->resync_marker
273 && !s
->data_partitioning
){
275 const int bits_count
= get_bits_count(&s
->gb
);
276 const int bits_left
= s
->gb
.size_in_bits
- bits_count
;
279 s
->padding_bug_score
+=16;
280 } else if(bits_left
!= 1){
281 int v
= show_bits(&s
->gb
, 8);
282 v
|= 0x7F >> (7-(bits_count
&7));
284 if(v
==0x7F && bits_left
<=8)
285 s
->padding_bug_score
--;
286 else if(v
==0x7F && ((get_bits_count(&s
->gb
)+8)&8) && bits_left
<=16)
287 s
->padding_bug_score
+= 4;
289 s
->padding_bug_score
++;
293 if(s
->workaround_bugs
&FF_BUG_AUTODETECT
){
294 if(s
->padding_bug_score
> -2 && !s
->data_partitioning
/*&& (s->divx_version || !s->resync_marker)*/)
295 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
297 s
->workaround_bugs
&= ~FF_BUG_NO_PADDING
;
300 // handle formats which don't have unique end markers
301 if(s
->msmpeg4_version
|| (s
->workaround_bugs
&FF_BUG_NO_PADDING
)){ //FIXME perhaps solve this more cleanly
302 int left
= s
->gb
.size_in_bits
- get_bits_count(&s
->gb
);
305 /* no markers in M$ crap */
306 if(s
->msmpeg4_version
&& s
->pict_type
==FF_I_TYPE
)
309 /* buggy padding but the frame should still end approximately at the bitstream end */
310 if((s
->workaround_bugs
&FF_BUG_NO_PADDING
) && s
->error_recognition
>=3)
312 else if((s
->workaround_bugs
&FF_BUG_NO_PADDING
))
313 max_extra
+= 256*256*256*64;
316 av_log(s
->avctx
, AV_LOG_ERROR
, "discarding %d junk bits at end, next would be %X\n", left
, show_bits(&s
->gb
, 24));
319 av_log(s
->avctx
, AV_LOG_ERROR
, "overreading %d bits\n", -left
);
321 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
);
326 av_log(s
->avctx
, AV_LOG_ERROR
, "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
327 s
->gb
.size_in_bits
- get_bits_count(&s
->gb
),
328 show_bits(&s
->gb
, 24), s
->padding_bug_score
);
330 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
);
335 int ff_h263_decode_frame(AVCodecContext
*avctx
,
336 void *data
, int *data_size
,
339 const uint8_t *buf
= avpkt
->data
;
340 int buf_size
= avpkt
->size
;
341 MpegEncContext
*s
= avctx
->priv_data
;
343 AVFrame
*pict
= data
;
345 #ifdef PRINT_FRAME_TIME
346 uint64_t time
= rdtsc();
349 av_log(avctx
, AV_LOG_DEBUG
, "*****frame %d size=%d\n", avctx
->frame_number
, buf_size
);
351 av_log(avctx
, AV_LOG_DEBUG
, "bytes=%x %x %x %x\n", buf
[0], buf
[1], buf
[2], buf
[3]);
353 s
->flags
= avctx
->flags
;
354 s
->flags2
= avctx
->flags2
;
356 /* no supplementary picture */
358 /* special case for last picture */
359 if (s
->low_delay
==0 && s
->next_picture_ptr
) {
360 *pict
= *(AVFrame
*)s
->next_picture_ptr
;
361 s
->next_picture_ptr
= NULL
;
363 *data_size
= sizeof(AVFrame
);
369 if(s
->flags
&CODEC_FLAG_TRUNCATED
){
372 if(CONFIG_MPEG4_DECODER
&& s
->codec_id
==CODEC_ID_MPEG4
){
373 next
= ff_mpeg4_find_frame_end(&s
->parse_context
, buf
, buf_size
);
374 }else if(CONFIG_H263_DECODER
&& s
->codec_id
==CODEC_ID_H263
){
375 next
= ff_h263_find_frame_end(&s
->parse_context
, buf
, buf_size
);
377 av_log(s
->avctx
, AV_LOG_ERROR
, "this codec does not support truncated bitstreams\n");
381 if( ff_combine_frame(&s
->parse_context
, next
, (const uint8_t **)&buf
, &buf_size
) < 0 )
388 if(s
->bitstream_buffer_size
&& (s
->divx_packed
|| buf_size
<20)){ //divx 5.01+/xvid frame reorder
389 init_get_bits(&s
->gb
, s
->bitstream_buffer
, s
->bitstream_buffer_size
*8);
391 init_get_bits(&s
->gb
, buf
, buf_size
*8);
392 s
->bitstream_buffer_size
=0;
394 if (!s
->context_initialized
) {
395 if (MPV_common_init(s
) < 0) //we need the idct permutaton for reading a custom matrix
399 /* We need to set current_picture_ptr before reading the header,
400 * otherwise we cannot store anyting in there */
401 if(s
->current_picture_ptr
==NULL
|| s
->current_picture_ptr
->data
[0]){
402 int i
= ff_find_unused_picture(s
, 0);
403 s
->current_picture_ptr
= &s
->picture
[i
];
407 if (CONFIG_WMV2_DECODER
&& s
->msmpeg4_version
==5) {
408 ret
= ff_wmv2_decode_picture_header(s
);
409 } else if (CONFIG_MSMPEG4_DECODER
&& s
->msmpeg4_version
) {
410 ret
= msmpeg4_decode_picture_header(s
);
411 } else if (s
->h263_pred
) {
412 if(s
->avctx
->extradata_size
&& s
->picture_number
==0){
415 init_get_bits(&gb
, s
->avctx
->extradata
, s
->avctx
->extradata_size
*8);
416 ret
= ff_mpeg4_decode_picture_header(s
, &gb
);
418 ret
= ff_mpeg4_decode_picture_header(s
, &s
->gb
);
419 } else if (s
->codec_id
== CODEC_ID_H263I
) {
420 ret
= intel_h263_decode_picture_header(s
);
421 } else if (s
->h263_flv
) {
422 ret
= flv_h263_decode_picture_header(s
);
424 ret
= h263_decode_picture_header(s
);
427 if(ret
==FRAME_SKIPPED
) return get_consumed_bytes(s
, buf_size
);
429 /* skip if the header was thrashed */
431 av_log(s
->avctx
, AV_LOG_ERROR
, "header damaged\n");
435 avctx
->has_b_frames
= !s
->low_delay
;
437 if(s
->xvid_build
==0 && s
->divx_version
==0 && s
->lavc_build
==0){
438 if(s
->stream_codec_tag
== AV_RL32("XVID") ||
439 s
->codec_tag
== AV_RL32("XVID") || s
->codec_tag
== AV_RL32("XVIX") ||
440 s
->codec_tag
== AV_RL32("RMP4"))
443 if(s
->codec_tag
== AV_RL32("DIVX") && s
->vo_type
==0 && s
->vol_control_parameters
==1
444 && s
->padding_bug_score
> 0 && s
->low_delay
) // XVID with modified fourcc
449 if(s
->xvid_build
==0 && s
->divx_version
==0 && s
->lavc_build
==0){
450 if(s
->codec_tag
== AV_RL32("DIVX") && s
->vo_type
==0 && s
->vol_control_parameters
==0)
451 s
->divx_version
= 400; //divx 4
454 if(s
->xvid_build
&& s
->divx_version
){
459 if(s
->workaround_bugs
&FF_BUG_AUTODETECT
){
460 if(s
->codec_tag
== AV_RL32("XVIX"))
461 s
->workaround_bugs
|= FF_BUG_XVID_ILACE
;
463 if(s
->codec_tag
== AV_RL32("UMP4")){
464 s
->workaround_bugs
|= FF_BUG_UMP4
;
467 if(s
->divx_version
>=500 && s
->divx_build
<1814){
468 s
->workaround_bugs
|= FF_BUG_QPEL_CHROMA
;
471 if(s
->divx_version
>502 && s
->divx_build
<1814){
472 s
->workaround_bugs
|= FF_BUG_QPEL_CHROMA2
;
475 if(s
->xvid_build
&& s
->xvid_build
<=3)
476 s
->padding_bug_score
= 256*256*256*64;
478 if(s
->xvid_build
&& s
->xvid_build
<=1)
479 s
->workaround_bugs
|= FF_BUG_QPEL_CHROMA
;
481 if(s
->xvid_build
&& s
->xvid_build
<=12)
482 s
->workaround_bugs
|= FF_BUG_EDGE
;
484 if(s
->xvid_build
&& s
->xvid_build
<=32)
485 s
->workaround_bugs
|= FF_BUG_DC_CLIP
;
487 #define SET_QPEL_FUNC(postfix1, postfix2) \
488 s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\
489 s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\
490 s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
492 if(s
->lavc_build
&& s
->lavc_build
<4653)
493 s
->workaround_bugs
|= FF_BUG_STD_QPEL
;
495 if(s
->lavc_build
&& s
->lavc_build
<4655)
496 s
->workaround_bugs
|= FF_BUG_DIRECT_BLOCKSIZE
;
498 if(s
->lavc_build
&& s
->lavc_build
<4670){
499 s
->workaround_bugs
|= FF_BUG_EDGE
;
502 if(s
->lavc_build
&& s
->lavc_build
<=4712)
503 s
->workaround_bugs
|= FF_BUG_DC_CLIP
;
506 s
->workaround_bugs
|= FF_BUG_DIRECT_BLOCKSIZE
;
507 //printf("padding_bug_score: %d\n", s->padding_bug_score);
508 if(s
->divx_version
==501 && s
->divx_build
==20020416)
509 s
->padding_bug_score
= 256*256*256*64;
511 if(s
->divx_version
&& s
->divx_version
<500){
512 s
->workaround_bugs
|= FF_BUG_EDGE
;
516 s
->workaround_bugs
|= FF_BUG_HPEL_CHROMA
;
518 if(s
->divx_version
==500)
519 s
->padding_bug_score
= 256*256*256*64;
521 /* very ugly XVID padding bug detection FIXME/XXX solve this differently
522 * Let us hope this at least works.
524 if( s
->resync_marker
==0 && s
->data_partitioning
==0 && s
->divx_version
==0
525 && s
->codec_id
==CODEC_ID_MPEG4
&& s
->vo_type
==0)
526 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
528 if(s
->lavc_build
&& s
->lavc_build
<4609) //FIXME not sure about the version num but a 4609 file seems ok
529 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
533 if(s
->workaround_bugs
& FF_BUG_STD_QPEL
){
534 SET_QPEL_FUNC(qpel_pixels_tab
[0][ 5], qpel16_mc11_old_c
)
535 SET_QPEL_FUNC(qpel_pixels_tab
[0][ 7], qpel16_mc31_old_c
)
536 SET_QPEL_FUNC(qpel_pixels_tab
[0][ 9], qpel16_mc12_old_c
)
537 SET_QPEL_FUNC(qpel_pixels_tab
[0][11], qpel16_mc32_old_c
)
538 SET_QPEL_FUNC(qpel_pixels_tab
[0][13], qpel16_mc13_old_c
)
539 SET_QPEL_FUNC(qpel_pixels_tab
[0][15], qpel16_mc33_old_c
)
541 SET_QPEL_FUNC(qpel_pixels_tab
[1][ 5], qpel8_mc11_old_c
)
542 SET_QPEL_FUNC(qpel_pixels_tab
[1][ 7], qpel8_mc31_old_c
)
543 SET_QPEL_FUNC(qpel_pixels_tab
[1][ 9], qpel8_mc12_old_c
)
544 SET_QPEL_FUNC(qpel_pixels_tab
[1][11], qpel8_mc32_old_c
)
545 SET_QPEL_FUNC(qpel_pixels_tab
[1][13], qpel8_mc13_old_c
)
546 SET_QPEL_FUNC(qpel_pixels_tab
[1][15], qpel8_mc33_old_c
)
549 if(avctx
->debug
& FF_DEBUG_BUGS
)
550 av_log(s
->avctx
, AV_LOG_DEBUG
, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
551 s
->workaround_bugs
, s
->lavc_build
, s
->xvid_build
, s
->divx_version
, s
->divx_build
,
552 s
->divx_packed
? "p" : "");
554 #if 0 // dump bits per frame / qp / complexity
557 if(!f
) f
=fopen("rate_qp_cplx.txt", "w");
558 fprintf(f
, "%d %d %f\n", buf_size
, s
->qscale
, buf_size
*(double)s
->qscale
);
563 if(s
->codec_id
== CODEC_ID_MPEG4
&& s
->xvid_build
&& avctx
->idct_algo
== FF_IDCT_AUTO
&& (mm_flags
& FF_MM_MMX
)){
564 avctx
->idct_algo
= FF_IDCT_XVIDMMX
;
565 avctx
->coded_width
= 0; // force reinit
566 // dsputil_init(&s->dsp, avctx);
571 /* After H263 & mpeg4 header decode we have the height, width,*/
572 /* and other parameters. So then we could init the picture */
573 /* FIXME: By the way H263 decoder is evolving it should have */
574 /* an H263EncContext */
576 if ( s
->width
!= avctx
->coded_width
577 || s
->height
!= avctx
->coded_height
) {
578 /* H.263 could change picture size any time */
579 ParseContext pc
= s
->parse_context
; //FIXME move these demuxng hack to avformat
580 s
->parse_context
.buffer
=0;
582 s
->parse_context
= pc
;
584 if (!s
->context_initialized
) {
585 avcodec_set_dimensions(avctx
, s
->width
, s
->height
);
590 if((s
->codec_id
==CODEC_ID_H263
|| s
->codec_id
==CODEC_ID_H263P
|| s
->codec_id
== CODEC_ID_H263I
))
591 s
->gob_index
= ff_h263_get_gob_height(s
);
594 s
->current_picture
.pict_type
= s
->pict_type
;
595 s
->current_picture
.key_frame
= s
->pict_type
== FF_I_TYPE
;
597 /* skip B-frames if we don't have reference frames */
598 if(s
->last_picture_ptr
==NULL
&& (s
->pict_type
==FF_B_TYPE
|| s
->dropable
)) return get_consumed_bytes(s
, buf_size
);
599 /* skip b frames if we are in a hurry */
600 if(avctx
->hurry_up
&& s
->pict_type
==FF_B_TYPE
) return get_consumed_bytes(s
, buf_size
);
601 if( (avctx
->skip_frame
>= AVDISCARD_NONREF
&& s
->pict_type
==FF_B_TYPE
)
602 || (avctx
->skip_frame
>= AVDISCARD_NONKEY
&& s
->pict_type
!=FF_I_TYPE
)
603 || avctx
->skip_frame
>= AVDISCARD_ALL
)
604 return get_consumed_bytes(s
, buf_size
);
605 /* skip everything if we are in a hurry>=5 */
606 if(avctx
->hurry_up
>=5) return get_consumed_bytes(s
, buf_size
);
608 if(s
->next_p_frame_damaged
){
609 if(s
->pict_type
==FF_B_TYPE
)
610 return get_consumed_bytes(s
, buf_size
);
612 s
->next_p_frame_damaged
=0;
615 if((s
->avctx
->flags2
& CODEC_FLAG2_FAST
) && s
->pict_type
==FF_B_TYPE
){
616 s
->me
.qpel_put
= s
->dsp
.put_2tap_qpel_pixels_tab
;
617 s
->me
.qpel_avg
= s
->dsp
.avg_2tap_qpel_pixels_tab
;
618 }else if((!s
->no_rounding
) || s
->pict_type
==FF_B_TYPE
){
619 s
->me
.qpel_put
= s
->dsp
.put_qpel_pixels_tab
;
620 s
->me
.qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
622 s
->me
.qpel_put
= s
->dsp
.put_no_rnd_qpel_pixels_tab
;
623 s
->me
.qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
626 if(MPV_frame_start(s
, avctx
) < 0)
629 if (avctx
->hwaccel
) {
630 if (avctx
->hwaccel
->start_frame(avctx
, buf
, buf_size
) < 0)
635 av_log(avctx
, AV_LOG_DEBUG
, "qscale=%d\n", s
->qscale
);
638 ff_er_frame_start(s
);
640 //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type
641 //which is not available before MPV_frame_start()
642 if (CONFIG_WMV2_DECODER
&& s
->msmpeg4_version
==5){
643 ret
= ff_wmv2_decode_secondary_picture_header(s
);
644 if(ret
<0) return ret
;
645 if(ret
==1) goto intrax8_decoded
;
648 /* decode each macroblock */
653 while(s
->mb_y
<s
->mb_height
){
654 if(s
->msmpeg4_version
){
655 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
)
658 if(ff_h263_resync(s
)<0)
662 if(s
->msmpeg4_version
<4 && s
->h263_pred
)
663 ff_mpeg4_clean_buffers(s
);
668 if (s
->h263_msmpeg4
&& s
->msmpeg4_version
<4 && s
->pict_type
==FF_I_TYPE
)
669 if(!CONFIG_MSMPEG4_DECODER
|| msmpeg4_decode_ext_header(s
, buf_size
) < 0){
670 s
->error_status_table
[s
->mb_num
-1]= AC_ERROR
|DC_ERROR
|MV_ERROR
;
673 /* divx 5.01+ bistream reorder stuff */
674 if(s
->codec_id
==CODEC_ID_MPEG4
&& s
->bitstream_buffer_size
==0 && s
->divx_packed
){
675 int current_pos
= get_bits_count(&s
->gb
)>>3;
676 int startcode_found
=0;
678 if(buf_size
- current_pos
> 5){
680 for(i
=current_pos
; i
<buf_size
-3; i
++){
681 if(buf
[i
]==0 && buf
[i
+1]==0 && buf
[i
+2]==1 && buf
[i
+3]==0xB6){
687 if(s
->gb
.buffer
== s
->bitstream_buffer
&& buf_size
>20){ //xvid style
694 &s
->bitstream_buffer
,
695 &s
->allocated_bitstream_buffer_size
,
696 buf_size
- current_pos
+ FF_INPUT_BUFFER_PADDING_SIZE
);
697 if (!s
->bitstream_buffer
)
698 return AVERROR(ENOMEM
);
699 memcpy(s
->bitstream_buffer
, buf
+ current_pos
, buf_size
- current_pos
);
700 s
->bitstream_buffer_size
= buf_size
- current_pos
;
707 if (avctx
->hwaccel
) {
708 if (avctx
->hwaccel
->end_frame(avctx
) < 0)
714 assert(s
->current_picture
.pict_type
== s
->current_picture_ptr
->pict_type
);
715 assert(s
->current_picture
.pict_type
== s
->pict_type
);
716 if (s
->pict_type
== FF_B_TYPE
|| s
->low_delay
) {
717 *pict
= *(AVFrame
*)s
->current_picture_ptr
;
718 } else if (s
->last_picture_ptr
!= NULL
) {
719 *pict
= *(AVFrame
*)s
->last_picture_ptr
;
722 if(s
->last_picture_ptr
|| s
->low_delay
){
723 *data_size
= sizeof(AVFrame
);
724 ff_print_debug_info(s
, pict
);
727 #ifdef PRINT_FRAME_TIME
728 av_log(avctx
, AV_LOG_DEBUG
, "%"PRId64
"\n", rdtsc()-time
);
731 return get_consumed_bytes(s
, buf_size
);
734 AVCodec mpeg4_decoder
= {
738 sizeof(MpegEncContext
),
742 ff_h263_decode_frame
,
743 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
| CODEC_CAP_TRUNCATED
| CODEC_CAP_DELAY
,
744 .flush
= ff_mpeg_flush
,
745 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
746 .pix_fmts
= ff_hwaccel_pixfmt_list_420
,
749 AVCodec h263_decoder
= {
753 sizeof(MpegEncContext
),
757 ff_h263_decode_frame
,
758 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
| CODEC_CAP_TRUNCATED
| CODEC_CAP_DELAY
,
759 .flush
= ff_mpeg_flush
,
760 .long_name
= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
761 .pix_fmts
= ff_hwaccel_pixfmt_list_420
,
764 AVCodec msmpeg4v1_decoder
= {
768 sizeof(MpegEncContext
),
772 ff_h263_decode_frame
,
773 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
774 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
775 .pix_fmts
= ff_pixfmt_list_420
,
778 AVCodec msmpeg4v2_decoder
= {
782 sizeof(MpegEncContext
),
786 ff_h263_decode_frame
,
787 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
788 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
789 .pix_fmts
= ff_pixfmt_list_420
,
792 AVCodec msmpeg4v3_decoder
= {
796 sizeof(MpegEncContext
),
800 ff_h263_decode_frame
,
801 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
802 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
803 .pix_fmts
= ff_pixfmt_list_420
,
806 AVCodec wmv1_decoder
= {
810 sizeof(MpegEncContext
),
814 ff_h263_decode_frame
,
815 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
816 .long_name
= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
817 .pix_fmts
= ff_pixfmt_list_420
,
820 AVCodec h263i_decoder
= {
824 sizeof(MpegEncContext
),
828 ff_h263_decode_frame
,
829 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
830 .long_name
= NULL_IF_CONFIG_SMALL("Intel H.263"),
831 .pix_fmts
= ff_pixfmt_list_420
,
834 AVCodec flv_decoder
= {
838 sizeof(MpegEncContext
),
842 ff_h263_decode_frame
,
843 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
,
844 .long_name
= NULL_IF_CONFIG_SMALL("Flash Video (FLV)"),
845 .pix_fmts
= ff_pixfmt_list_420
,