3 * Copyright (c) 2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of Libav.
8 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 #include "libavutil/cpu.h"
32 #include "mpegvideo.h"
34 #include "h263_parser.h"
35 #include "mpeg4video_parser.h"
37 #include "vdpau_internal.h"
40 #include "mpeg4video.h"
43 //#define PRINT_FRAME_TIME
45 av_cold
int ff_h263_decode_init(AVCodecContext
*avctx
)
47 MpegEncContext
*s
= avctx
->priv_data
;
50 s
->out_format
= FMT_H263
;
52 s
->width
= avctx
->coded_width
;
53 s
->height
= avctx
->coded_height
;
54 s
->workaround_bugs
= avctx
->workaround_bugs
;
57 ff_MPV_decode_defaults(s
);
59 s
->decode_mb
= ff_h263_decode_mb
;
61 if (avctx
->codec
->id
== AV_CODEC_ID_MSS2
)
62 avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
64 avctx
->pix_fmt
= avctx
->get_format(avctx
, avctx
->codec
->pix_fmts
);
65 s
->unrestricted_mv
= 1;
67 /* select sub codec */
68 switch(avctx
->codec
->id
) {
69 case AV_CODEC_ID_H263
:
70 s
->unrestricted_mv
= 0;
71 avctx
->chroma_sample_location
= AVCHROMA_LOC_CENTER
;
73 case AV_CODEC_ID_MPEG4
:
75 case AV_CODEC_ID_MSMPEG4V1
:
79 case AV_CODEC_ID_MSMPEG4V2
:
83 case AV_CODEC_ID_MSMPEG4V3
:
87 case AV_CODEC_ID_WMV1
:
91 case AV_CODEC_ID_WMV2
:
96 case AV_CODEC_ID_WMV3
:
97 case AV_CODEC_ID_VC1IMAGE
:
98 case AV_CODEC_ID_WMV3IMAGE
:
99 case AV_CODEC_ID_MSS2
:
101 s
->msmpeg4_version
=6;
102 avctx
->chroma_sample_location
= AVCHROMA_LOC_LEFT
;
104 case AV_CODEC_ID_H263I
:
106 case AV_CODEC_ID_FLV1
:
112 s
->codec_id
= avctx
->codec
->id
;
113 avctx
->hwaccel
= ff_find_hwaccel(avctx
->codec
->id
, avctx
->pix_fmt
);
115 /* for h263, we allocate the images after having read the header */
116 if (avctx
->codec
->id
!= AV_CODEC_ID_H263
&& avctx
->codec
->id
!= AV_CODEC_ID_MPEG4
)
117 if (ff_MPV_common_init(s
) < 0)
120 ff_h263_decode_init_vlc(s
);
125 av_cold
int ff_h263_decode_end(AVCodecContext
*avctx
)
127 MpegEncContext
*s
= avctx
->priv_data
;
129 ff_MPV_common_end(s
);
134 * Return the number of bytes consumed for building the current frame.
136 static int get_consumed_bytes(MpegEncContext
*s
, int buf_size
){
137 int pos
= (get_bits_count(&s
->gb
)+7)>>3;
139 if(s
->divx_packed
|| s
->avctx
->hwaccel
){
140 //we would have to scan through the whole buf to handle the weird reordering ...
142 }else if(s
->flags
&CODEC_FLAG_TRUNCATED
){
143 pos
-= s
->parse_context
.last_index
;
144 if(pos
<0) pos
=0; // padding is not really read so this might be -1
147 if(pos
==0) pos
=1; //avoid infinite loops (i doubt that is needed but ...)
148 if(pos
+10>buf_size
) pos
=buf_size
; // oops ;)
154 static int decode_slice(MpegEncContext
*s
){
155 const int part_mask
= s
->partitioned_frame
? (ER_AC_END
|ER_AC_ERROR
) : 0x7F;
156 const int mb_size
= 16;
157 s
->last_resync_gb
= s
->gb
;
158 s
->first_slice_line
= 1;
160 s
->resync_mb_x
= s
->mb_x
;
161 s
->resync_mb_y
= s
->mb_y
;
163 ff_set_qscale(s
, s
->qscale
);
165 if (s
->avctx
->hwaccel
) {
166 const uint8_t *start
= s
->gb
.buffer
+ get_bits_count(&s
->gb
)/8;
167 const uint8_t *end
= ff_h263_find_resync_marker(start
+ 1, s
->gb
.buffer_end
);
168 skip_bits_long(&s
->gb
, 8*(end
- start
));
169 return s
->avctx
->hwaccel
->decode_slice(s
->avctx
, start
, end
- start
);
172 if(s
->partitioned_frame
){
173 const int qscale
= s
->qscale
;
175 if(CONFIG_MPEG4_DECODER
&& s
->codec_id
==AV_CODEC_ID_MPEG4
){
176 if(ff_mpeg4_decode_partitions(s
) < 0)
180 /* restore variables which were modified */
181 s
->first_slice_line
=1;
182 s
->mb_x
= s
->resync_mb_x
;
183 s
->mb_y
= s
->resync_mb_y
;
184 ff_set_qscale(s
, qscale
);
187 for(; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
188 /* per-row end of slice checks */
189 if(s
->msmpeg4_version
){
190 if(s
->resync_mb_y
+ s
->slice_height
== s
->mb_y
){
191 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
-1, s
->mb_y
, ER_MB_END
);
197 if(s
->msmpeg4_version
==1){
203 ff_init_block_index(s
);
204 for(; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
207 ff_update_block_index(s
);
209 if(s
->resync_mb_x
== s
->mb_x
&& s
->resync_mb_y
+1 == s
->mb_y
){
210 s
->first_slice_line
=0;
215 s
->mv_dir
= MV_DIR_FORWARD
;
216 s
->mv_type
= MV_TYPE_16X16
;
217 // s->mb_skipped = 0;
218 av_dlog(s
, "%d %d %06X\n",
219 ret
, get_bits_count(&s
->gb
), show_bits(&s
->gb
, 24));
220 ret
= s
->decode_mb(s
, s
->block
);
222 if (s
->pict_type
!=AV_PICTURE_TYPE_B
)
223 ff_h263_update_motion_val(s
);
226 const int xy
= s
->mb_x
+ s
->mb_y
*s
->mb_stride
;
228 ff_MPV_decode_mb(s
, s
->block
);
230 ff_h263_loop_filter(s
);
232 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
, s
->mb_y
, ER_MB_END
&part_mask
);
234 s
->padding_bug_score
--;
236 if(++s
->mb_x
>= s
->mb_width
){
238 ff_draw_horiz_band(s
, s
->mb_y
*mb_size
, mb_size
);
239 ff_MPV_report_decode_progress(s
);
243 }else if(ret
==SLICE_NOEND
){
244 av_log(s
->avctx
, AV_LOG_ERROR
, "Slice mismatch at MB: %d\n", xy
);
245 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
+1, s
->mb_y
, ER_MB_END
&part_mask
);
248 av_log(s
->avctx
, AV_LOG_ERROR
, "Error at MB: %d\n", xy
);
249 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
, s
->mb_y
, ER_MB_ERROR
&part_mask
);
254 ff_MPV_decode_mb(s
, s
->block
);
256 ff_h263_loop_filter(s
);
259 ff_draw_horiz_band(s
, s
->mb_y
*mb_size
, mb_size
);
260 ff_MPV_report_decode_progress(s
);
265 assert(s
->mb_x
==0 && s
->mb_y
==s
->mb_height
);
267 if(s
->codec_id
==AV_CODEC_ID_MPEG4
268 && (s
->workaround_bugs
&FF_BUG_AUTODETECT
)
269 && get_bits_left(&s
->gb
) >= 48
270 && show_bits(&s
->gb
, 24)==0x4010
271 && !s
->data_partitioning
)
272 s
->padding_bug_score
+=32;
274 /* try to detect the padding bug */
275 if( s
->codec_id
==AV_CODEC_ID_MPEG4
276 && (s
->workaround_bugs
&FF_BUG_AUTODETECT
)
277 && get_bits_left(&s
->gb
) >=0
278 && get_bits_left(&s
->gb
) < 48
279 // && !s->resync_marker
280 && !s
->data_partitioning
){
282 const int bits_count
= get_bits_count(&s
->gb
);
283 const int bits_left
= s
->gb
.size_in_bits
- bits_count
;
286 s
->padding_bug_score
+=16;
287 } else if(bits_left
!= 1){
288 int v
= show_bits(&s
->gb
, 8);
289 v
|= 0x7F >> (7-(bits_count
&7));
291 if(v
==0x7F && bits_left
<=8)
292 s
->padding_bug_score
--;
293 else if(v
==0x7F && ((get_bits_count(&s
->gb
)+8)&8) && bits_left
<=16)
294 s
->padding_bug_score
+= 4;
296 s
->padding_bug_score
++;
300 if(s
->workaround_bugs
&FF_BUG_AUTODETECT
){
301 if(s
->padding_bug_score
> -2 && !s
->data_partitioning
/*&& (s->divx_version>=0 || !s->resync_marker)*/)
302 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
304 s
->workaround_bugs
&= ~FF_BUG_NO_PADDING
;
307 // handle formats which don't have unique end markers
308 if(s
->msmpeg4_version
|| (s
->workaround_bugs
&FF_BUG_NO_PADDING
)){ //FIXME perhaps solve this more cleanly
309 int left
= get_bits_left(&s
->gb
);
312 /* no markers in M$ crap */
313 if(s
->msmpeg4_version
&& s
->pict_type
==AV_PICTURE_TYPE_I
)
316 /* buggy padding but the frame should still end approximately at the bitstream end */
317 if((s
->workaround_bugs
&FF_BUG_NO_PADDING
) && (s
->err_recognition
&AV_EF_BUFFER
))
319 else if((s
->workaround_bugs
&FF_BUG_NO_PADDING
))
320 max_extra
+= 256*256*256*64;
323 av_log(s
->avctx
, AV_LOG_ERROR
, "discarding %d junk bits at end, next would be %X\n", left
, show_bits(&s
->gb
, 24));
326 av_log(s
->avctx
, AV_LOG_ERROR
, "overreading %d bits\n", -left
);
328 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
-1, s
->mb_y
, ER_MB_END
);
333 av_log(s
->avctx
, AV_LOG_ERROR
, "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
334 get_bits_left(&s
->gb
),
335 show_bits(&s
->gb
, 24), s
->padding_bug_score
);
337 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
, s
->mb_y
, ER_MB_END
&part_mask
);
342 int ff_h263_decode_frame(AVCodecContext
*avctx
,
343 void *data
, int *got_frame
,
346 const uint8_t *buf
= avpkt
->data
;
347 int buf_size
= avpkt
->size
;
348 MpegEncContext
*s
= avctx
->priv_data
;
350 AVFrame
*pict
= data
;
352 #ifdef PRINT_FRAME_TIME
353 uint64_t time
= rdtsc();
355 s
->flags
= avctx
->flags
;
356 s
->flags2
= avctx
->flags2
;
358 /* no supplementary picture */
360 /* special case for last picture */
361 if (s
->low_delay
==0 && s
->next_picture_ptr
) {
362 *pict
= s
->next_picture_ptr
->f
;
363 s
->next_picture_ptr
= NULL
;
371 if(s
->flags
&CODEC_FLAG_TRUNCATED
){
374 if(CONFIG_MPEG4_DECODER
&& s
->codec_id
==AV_CODEC_ID_MPEG4
){
375 next
= ff_mpeg4_find_frame_end(&s
->parse_context
, buf
, buf_size
);
376 }else if(CONFIG_H263_DECODER
&& s
->codec_id
==AV_CODEC_ID_H263
){
377 next
= ff_h263_find_frame_end(&s
->parse_context
, buf
, buf_size
);
379 av_log(s
->avctx
, AV_LOG_ERROR
, "this codec does not support truncated bitstreams\n");
383 if( ff_combine_frame(&s
->parse_context
, next
, (const uint8_t **)&buf
, &buf_size
) < 0 )
390 if(s
->bitstream_buffer_size
&& (s
->divx_packed
|| buf_size
<20)){ //divx 5.01+/xvid frame reorder
391 init_get_bits(&s
->gb
, s
->bitstream_buffer
, s
->bitstream_buffer_size
*8);
393 init_get_bits(&s
->gb
, buf
, buf_size
*8);
394 s
->bitstream_buffer_size
=0;
396 if (!s
->context_initialized
) {
397 if (ff_MPV_common_init(s
) < 0) //we need the idct permutaton for reading a custom matrix
401 /* We need to set current_picture_ptr before reading the header,
402 * otherwise we cannot store anyting in there */
403 if (s
->current_picture_ptr
== NULL
|| s
->current_picture_ptr
->f
.data
[0]) {
404 int i
= ff_find_unused_picture(s
, 0);
407 s
->current_picture_ptr
= &s
->picture
[i
];
411 if (CONFIG_WMV2_DECODER
&& s
->msmpeg4_version
==5) {
412 ret
= ff_wmv2_decode_picture_header(s
);
413 } else if (CONFIG_MSMPEG4_DECODER
&& s
->msmpeg4_version
) {
414 ret
= ff_msmpeg4_decode_picture_header(s
);
415 } else if (CONFIG_MPEG4_DECODER
&& s
->h263_pred
) {
416 if(s
->avctx
->extradata_size
&& s
->picture_number
==0){
419 init_get_bits(&gb
, s
->avctx
->extradata
, s
->avctx
->extradata_size
*8);
420 ret
= ff_mpeg4_decode_picture_header(s
, &gb
);
422 ret
= ff_mpeg4_decode_picture_header(s
, &s
->gb
);
423 } else if (CONFIG_H263I_DECODER
&& s
->codec_id
== AV_CODEC_ID_H263I
) {
424 ret
= ff_intel_h263_decode_picture_header(s
);
425 } else if (CONFIG_FLV_DECODER
&& s
->h263_flv
) {
426 ret
= ff_flv_decode_picture_header(s
);
428 ret
= ff_h263_decode_picture_header(s
);
431 if(ret
==FRAME_SKIPPED
) return get_consumed_bytes(s
, buf_size
);
433 /* skip if the header was thrashed */
435 av_log(s
->avctx
, AV_LOG_ERROR
, "header damaged\n");
439 avctx
->has_b_frames
= !s
->low_delay
;
441 if(s
->xvid_build
==-1 && s
->divx_version
==-1 && s
->lavc_build
==-1){
442 if(s
->stream_codec_tag
== AV_RL32("XVID") ||
443 s
->codec_tag
== AV_RL32("XVID") || s
->codec_tag
== AV_RL32("XVIX") ||
444 s
->codec_tag
== AV_RL32("RMP4") ||
445 s
->codec_tag
== AV_RL32("SIPP")
449 if(s
->codec_tag
== AV_RL32("DIVX") && s
->vo_type
==0 && s
->vol_control_parameters
==1
450 && s
->padding_bug_score
> 0 && s
->low_delay
) // XVID with modified fourcc
455 if(s
->xvid_build
==-1 && s
->divx_version
==-1 && s
->lavc_build
==-1){
456 if(s
->codec_tag
== AV_RL32("DIVX") && s
->vo_type
==0 && s
->vol_control_parameters
==0)
457 s
->divx_version
= 400; //divx 4
460 if(s
->xvid_build
>=0 && s
->divx_version
>=0){
465 if(s
->workaround_bugs
&FF_BUG_AUTODETECT
){
466 if(s
->codec_tag
== AV_RL32("XVIX"))
467 s
->workaround_bugs
|= FF_BUG_XVID_ILACE
;
469 if(s
->codec_tag
== AV_RL32("UMP4")){
470 s
->workaround_bugs
|= FF_BUG_UMP4
;
473 if(s
->divx_version
>=500 && s
->divx_build
<1814){
474 s
->workaround_bugs
|= FF_BUG_QPEL_CHROMA
;
477 if(s
->divx_version
>502 && s
->divx_build
<1814){
478 s
->workaround_bugs
|= FF_BUG_QPEL_CHROMA2
;
481 if(s
->xvid_build
<=3U)
482 s
->padding_bug_score
= 256*256*256*64;
484 if(s
->xvid_build
<=1U)
485 s
->workaround_bugs
|= FF_BUG_QPEL_CHROMA
;
487 if(s
->xvid_build
<=12U)
488 s
->workaround_bugs
|= FF_BUG_EDGE
;
490 if(s
->xvid_build
<=32U)
491 s
->workaround_bugs
|= FF_BUG_DC_CLIP
;
493 #define SET_QPEL_FUNC(postfix1, postfix2) \
494 s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\
495 s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\
496 s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
498 if(s
->lavc_build
<4653U)
499 s
->workaround_bugs
|= FF_BUG_STD_QPEL
;
501 if(s
->lavc_build
<4655U)
502 s
->workaround_bugs
|= FF_BUG_DIRECT_BLOCKSIZE
;
504 if(s
->lavc_build
<4670U){
505 s
->workaround_bugs
|= FF_BUG_EDGE
;
508 if(s
->lavc_build
<=4712U)
509 s
->workaround_bugs
|= FF_BUG_DC_CLIP
;
511 if(s
->divx_version
>=0)
512 s
->workaround_bugs
|= FF_BUG_DIRECT_BLOCKSIZE
;
513 if(s
->divx_version
==501 && s
->divx_build
==20020416)
514 s
->padding_bug_score
= 256*256*256*64;
516 if(s
->divx_version
<500U){
517 s
->workaround_bugs
|= FF_BUG_EDGE
;
520 if(s
->divx_version
>=0)
521 s
->workaround_bugs
|= FF_BUG_HPEL_CHROMA
;
523 if(s
->divx_version
==500)
524 s
->padding_bug_score
= 256*256*256*64;
526 /* very ugly XVID padding bug detection FIXME/XXX solve this differently
527 * Let us hope this at least works.
529 if( s
->resync_marker
==0 && s
->data_partitioning
==0 && s
->divx_version
==-1
530 && s
->codec_id
==AV_CODEC_ID_MPEG4
&& s
->vo_type
==0)
531 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
533 if(s
->lavc_build
<4609U) //FIXME not sure about the version num but a 4609 file seems ok
534 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
538 if(s
->workaround_bugs
& FF_BUG_STD_QPEL
){
539 SET_QPEL_FUNC(qpel_pixels_tab
[0][ 5], qpel16_mc11_old_c
)
540 SET_QPEL_FUNC(qpel_pixels_tab
[0][ 7], qpel16_mc31_old_c
)
541 SET_QPEL_FUNC(qpel_pixels_tab
[0][ 9], qpel16_mc12_old_c
)
542 SET_QPEL_FUNC(qpel_pixels_tab
[0][11], qpel16_mc32_old_c
)
543 SET_QPEL_FUNC(qpel_pixels_tab
[0][13], qpel16_mc13_old_c
)
544 SET_QPEL_FUNC(qpel_pixels_tab
[0][15], qpel16_mc33_old_c
)
546 SET_QPEL_FUNC(qpel_pixels_tab
[1][ 5], qpel8_mc11_old_c
)
547 SET_QPEL_FUNC(qpel_pixels_tab
[1][ 7], qpel8_mc31_old_c
)
548 SET_QPEL_FUNC(qpel_pixels_tab
[1][ 9], qpel8_mc12_old_c
)
549 SET_QPEL_FUNC(qpel_pixels_tab
[1][11], qpel8_mc32_old_c
)
550 SET_QPEL_FUNC(qpel_pixels_tab
[1][13], qpel8_mc13_old_c
)
551 SET_QPEL_FUNC(qpel_pixels_tab
[1][15], qpel8_mc33_old_c
)
554 if(avctx
->debug
& FF_DEBUG_BUGS
)
555 av_log(s
->avctx
, AV_LOG_DEBUG
, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
556 s
->workaround_bugs
, s
->lavc_build
, s
->xvid_build
, s
->divx_version
, s
->divx_build
,
557 s
->divx_packed
? "p" : "");
560 if (s
->codec_id
== AV_CODEC_ID_MPEG4
&& s
->xvid_build
>=0 && avctx
->idct_algo
== FF_IDCT_AUTO
&& (av_get_cpu_flags() & AV_CPU_FLAG_MMX
)) {
561 avctx
->idct_algo
= FF_IDCT_XVIDMMX
;
562 ff_dct_common_init(s
);
567 /* After H263 & mpeg4 header decode we have the height, width,*/
568 /* and other parameters. So then we could init the picture */
569 /* FIXME: By the way H263 decoder is evolving it should have */
570 /* an H263EncContext */
572 if (!avctx
->coded_width
|| !avctx
->coded_height
) {
573 ParseContext pc
= s
->parse_context
; //FIXME move these demuxng hack to avformat
575 s
->parse_context
.buffer
=0;
576 ff_MPV_common_end(s
);
577 s
->parse_context
= pc
;
578 avcodec_set_dimensions(avctx
, s
->width
, s
->height
);
583 if (s
->width
!= avctx
->coded_width
||
584 s
->height
!= avctx
->coded_height
||
586 /* H.263 could change picture size any time */
587 s
->context_reinit
= 0;
589 avcodec_set_dimensions(avctx
, s
->width
, s
->height
);
591 if ((ret
= ff_MPV_common_frame_size_change(s
)))
595 if((s
->codec_id
==AV_CODEC_ID_H263
|| s
->codec_id
==AV_CODEC_ID_H263P
|| s
->codec_id
== AV_CODEC_ID_H263I
))
596 s
->gob_index
= ff_h263_get_gob_height(s
);
598 // for skipping the frame
599 s
->current_picture
.f
.pict_type
= s
->pict_type
;
600 s
->current_picture
.f
.key_frame
= s
->pict_type
== AV_PICTURE_TYPE_I
;
602 /* skip B-frames if we don't have reference frames */
603 if (s
->last_picture_ptr
== NULL
&&
604 (s
->pict_type
== AV_PICTURE_TYPE_B
|| s
->droppable
))
605 return get_consumed_bytes(s
, buf_size
);
606 if( (avctx
->skip_frame
>= AVDISCARD_NONREF
&& s
->pict_type
==AV_PICTURE_TYPE_B
)
607 || (avctx
->skip_frame
>= AVDISCARD_NONKEY
&& s
->pict_type
!=AV_PICTURE_TYPE_I
)
608 || avctx
->skip_frame
>= AVDISCARD_ALL
)
609 return get_consumed_bytes(s
, buf_size
);
611 if(s
->next_p_frame_damaged
){
612 if(s
->pict_type
==AV_PICTURE_TYPE_B
)
613 return get_consumed_bytes(s
, buf_size
);
615 s
->next_p_frame_damaged
=0;
618 if((s
->avctx
->flags2
& CODEC_FLAG2_FAST
) && s
->pict_type
==AV_PICTURE_TYPE_B
){
619 s
->me
.qpel_put
= s
->dsp
.put_2tap_qpel_pixels_tab
;
620 s
->me
.qpel_avg
= s
->dsp
.avg_2tap_qpel_pixels_tab
;
621 }else if((!s
->no_rounding
) || s
->pict_type
==AV_PICTURE_TYPE_B
){
622 s
->me
.qpel_put
= s
->dsp
.put_qpel_pixels_tab
;
623 s
->me
.qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
625 s
->me
.qpel_put
= s
->dsp
.put_no_rnd_qpel_pixels_tab
;
626 s
->me
.qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
629 if(ff_MPV_frame_start(s
, avctx
) < 0)
632 if (!s
->divx_packed
) ff_thread_finish_setup(avctx
);
634 if (CONFIG_MPEG4_VDPAU_DECODER
&& (s
->avctx
->codec
->capabilities
& CODEC_CAP_HWACCEL_VDPAU
)) {
635 ff_vdpau_mpeg4_decode_picture(s
, s
->gb
.buffer
, s
->gb
.buffer_end
- s
->gb
.buffer
);
639 if (avctx
->hwaccel
) {
640 if (avctx
->hwaccel
->start_frame(avctx
, s
->gb
.buffer
, s
->gb
.buffer_end
- s
->gb
.buffer
) < 0)
644 ff_er_frame_start(s
);
646 //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type
647 //which is not available before ff_MPV_frame_start()
648 if (CONFIG_WMV2_DECODER
&& s
->msmpeg4_version
==5){
649 ret
= ff_wmv2_decode_secondary_picture_header(s
);
650 if(ret
<0) return ret
;
651 if(ret
==1) goto intrax8_decoded
;
654 /* decode each macroblock */
658 ret
= decode_slice(s
);
659 while(s
->mb_y
<s
->mb_height
){
660 if(s
->msmpeg4_version
){
661 if(s
->slice_height
==0 || s
->mb_x
!=0 || (s
->mb_y
%s
->slice_height
)!=0 || get_bits_left(&s
->gb
)<0)
664 int prev_x
=s
->mb_x
, prev_y
=s
->mb_y
;
665 if(ff_h263_resync(s
)<0)
667 if (prev_y
* s
->mb_width
+ prev_x
< s
->mb_y
* s
->mb_width
+ s
->mb_x
)
668 s
->error_occurred
= 1;
671 if(s
->msmpeg4_version
<4 && s
->h263_pred
)
672 ff_mpeg4_clean_buffers(s
);
674 if (decode_slice(s
) < 0) ret
= AVERROR_INVALIDDATA
;
677 if (s
->msmpeg4_version
&& s
->msmpeg4_version
<4 && s
->pict_type
==AV_PICTURE_TYPE_I
)
678 if(!CONFIG_MSMPEG4_DECODER
|| ff_msmpeg4_decode_ext_header(s
, buf_size
) < 0){
679 s
->error_status_table
[s
->mb_num
-1]= ER_MB_ERROR
;
682 assert(s
->bitstream_buffer_size
==0);
684 /* divx 5.01+ bistream reorder stuff */
685 if(s
->codec_id
==AV_CODEC_ID_MPEG4
&& s
->divx_packed
){
686 int current_pos
= get_bits_count(&s
->gb
)>>3;
687 int startcode_found
=0;
689 if(buf_size
- current_pos
> 5){
691 for(i
=current_pos
; i
<buf_size
-3; i
++){
692 if(buf
[i
]==0 && buf
[i
+1]==0 && buf
[i
+2]==1 && buf
[i
+3]==0xB6){
698 if(s
->gb
.buffer
== s
->bitstream_buffer
&& buf_size
>7 && s
->xvid_build
>=0){ //xvid style
705 &s
->bitstream_buffer
,
706 &s
->allocated_bitstream_buffer_size
,
707 buf_size
- current_pos
+ FF_INPUT_BUFFER_PADDING_SIZE
);
708 if (!s
->bitstream_buffer
)
709 return AVERROR(ENOMEM
);
710 memcpy(s
->bitstream_buffer
, buf
+ current_pos
, buf_size
- current_pos
);
711 s
->bitstream_buffer_size
= buf_size
- current_pos
;
718 if (avctx
->hwaccel
) {
719 if (avctx
->hwaccel
->end_frame(avctx
) < 0)
725 assert(s
->current_picture
.f
.pict_type
== s
->current_picture_ptr
->f
.pict_type
);
726 assert(s
->current_picture
.f
.pict_type
== s
->pict_type
);
727 if (s
->pict_type
== AV_PICTURE_TYPE_B
|| s
->low_delay
) {
728 *pict
= s
->current_picture_ptr
->f
;
729 } else if (s
->last_picture_ptr
!= NULL
) {
730 *pict
= s
->last_picture_ptr
->f
;
733 if(s
->last_picture_ptr
|| s
->low_delay
){
735 ff_print_debug_info(s
, pict
);
738 #ifdef PRINT_FRAME_TIME
739 av_log(avctx
, AV_LOG_DEBUG
, "%"PRId64
"\n", rdtsc()-time
);
742 return (ret
&& (avctx
->err_recognition
& AV_EF_EXPLODE
))?ret
:get_consumed_bytes(s
, buf_size
);
745 AVCodec ff_h263_decoder
= {
747 .type
= AVMEDIA_TYPE_VIDEO
,
748 .id
= AV_CODEC_ID_H263
,
749 .priv_data_size
= sizeof(MpegEncContext
),
750 .init
= ff_h263_decode_init
,
751 .close
= ff_h263_decode_end
,
752 .decode
= ff_h263_decode_frame
,
753 .capabilities
= CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
|
754 CODEC_CAP_TRUNCATED
| CODEC_CAP_DELAY
,
755 .flush
= ff_mpeg_flush
,
756 .long_name
= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
757 .pix_fmts
= ff_hwaccel_pixfmt_list_420
,