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
28 #define UNCHECKED_BITSTREAM_READER 1
30 #include "libavutil/cpu.h"
32 #include "error_resilience.h"
35 #include "h263_parser.h"
38 #include "mpeg4video.h"
39 #include "mpeg4video_parser.h"
40 #include "mpegvideo.h"
43 #include "vdpau_internal.h"
46 av_cold
int ff_h263_decode_init(AVCodecContext
*avctx
)
48 MpegEncContext
*s
= avctx
->priv_data
;
51 s
->out_format
= FMT_H263
;
54 ff_mpv_decode_defaults(s
);
55 ff_mpv_decode_init(s
, avctx
);
57 s
->quant_precision
= 5;
58 s
->decode_mb
= ff_h263_decode_mb
;
60 if (avctx
->codec
->id
== AV_CODEC_ID_MSS2
)
61 avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
63 avctx
->pix_fmt
= ff_get_format(avctx
, avctx
->codec
->pix_fmts
);
64 s
->unrestricted_mv
= 1;
66 /* select sub codec */
67 switch (avctx
->codec
->id
) {
68 case AV_CODEC_ID_H263
:
69 case AV_CODEC_ID_H263P
:
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
:
77 s
->msmpeg4_version
= 1;
79 case AV_CODEC_ID_MSMPEG4V2
:
81 s
->msmpeg4_version
= 2;
83 case AV_CODEC_ID_MSMPEG4V3
:
85 s
->msmpeg4_version
= 3;
87 case AV_CODEC_ID_WMV1
:
89 s
->msmpeg4_version
= 4;
91 case AV_CODEC_ID_WMV2
:
93 s
->msmpeg4_version
= 5;
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
:
110 av_log(avctx
, AV_LOG_ERROR
, "Unsupported codec %d\n",
112 return AVERROR(ENOSYS
);
114 s
->codec_id
= avctx
->codec
->id
;
116 if (avctx
->stream_codec_tag
== AV_RL32("l263") && avctx
->extradata_size
== 56 && avctx
->extradata
[0] == 1)
119 /* for h263, we allocate the images after having read the header */
120 if (avctx
->codec
->id
!= AV_CODEC_ID_H263
&&
121 avctx
->codec
->id
!= AV_CODEC_ID_H263P
&&
122 avctx
->codec
->id
!= AV_CODEC_ID_MPEG4
) {
124 if ((ret
= ff_mpv_common_init(s
)) < 0)
128 ff_h263dsp_init(&s
->h263dsp
);
129 ff_qpeldsp_init(&s
->qdsp
);
130 ff_h263_decode_init_vlc();
135 av_cold
int ff_h263_decode_end(AVCodecContext
*avctx
)
137 MpegEncContext
*s
= avctx
->priv_data
;
139 ff_mpv_common_end(s
);
144 * Return the number of bytes consumed for building the current frame.
146 static int get_consumed_bytes(MpegEncContext
*s
, int buf_size
)
148 int pos
= (get_bits_count(&s
->gb
) + 7) >> 3;
150 if (s
->divx_packed
|| s
->avctx
->hwaccel
) {
151 /* We would have to scan through the whole buf to handle the weird
154 } else if (s
->flags
& CODEC_FLAG_TRUNCATED
) {
155 pos
-= s
->parse_context
.last_index
;
156 // padding is not really read so this might be -1
161 // avoid infinite loops (maybe not needed...)
165 if (pos
+ 10 > buf_size
)
172 static int decode_slice(MpegEncContext
*s
)
174 const int part_mask
= s
->partitioned_frame
175 ? (ER_AC_END
| ER_AC_ERROR
) : 0x7F;
176 const int mb_size
= 16 >> s
->avctx
->lowres
;
179 s
->last_resync_gb
= s
->gb
;
180 s
->first_slice_line
= 1;
181 s
->resync_mb_x
= s
->mb_x
;
182 s
->resync_mb_y
= s
->mb_y
;
184 ff_set_qscale(s
, s
->qscale
);
186 if (s
->avctx
->hwaccel
) {
187 const uint8_t *start
= s
->gb
.buffer
+ get_bits_count(&s
->gb
) / 8;
188 ret
= s
->avctx
->hwaccel
->decode_slice(s
->avctx
, start
, s
->gb
.buffer_end
- start
);
189 // ensure we exit decode loop
190 s
->mb_y
= s
->mb_height
;
194 if (s
->partitioned_frame
) {
195 const int qscale
= s
->qscale
;
197 if (CONFIG_MPEG4_DECODER
&& s
->codec_id
== AV_CODEC_ID_MPEG4
)
198 if ((ret
= ff_mpeg4_decode_partitions(s
->avctx
->priv_data
)) < 0)
201 /* restore variables which were modified */
202 s
->first_slice_line
= 1;
203 s
->mb_x
= s
->resync_mb_x
;
204 s
->mb_y
= s
->resync_mb_y
;
205 ff_set_qscale(s
, qscale
);
208 for (; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
209 /* per-row end of slice checks */
210 if (s
->msmpeg4_version
) {
211 if (s
->resync_mb_y
+ s
->slice_height
== s
->mb_y
) {
212 ff_er_add_slice(&s
->er
, s
->resync_mb_x
, s
->resync_mb_y
,
213 s
->mb_x
- 1, s
->mb_y
, ER_MB_END
);
219 if (s
->msmpeg4_version
== 1) {
225 ff_init_block_index(s
);
226 for (; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
229 ff_update_block_index(s
);
231 if (s
->resync_mb_x
== s
->mb_x
&& s
->resync_mb_y
+ 1 == s
->mb_y
)
232 s
->first_slice_line
= 0;
236 s
->mv_dir
= MV_DIR_FORWARD
;
237 s
->mv_type
= MV_TYPE_16X16
;
238 av_dlog(s
, "%d %d %06X\n",
239 ret
, get_bits_count(&s
->gb
), show_bits(&s
->gb
, 24));
241 tprintf(NULL
, "Decoding MB at %dx%d\n", s
->mb_x
, s
->mb_y
);
242 ret
= s
->decode_mb(s
, s
->block
);
244 if (s
->pict_type
!= AV_PICTURE_TYPE_B
)
245 ff_h263_update_motion_val(s
);
248 const int xy
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
249 if (ret
== SLICE_END
) {
250 ff_mpv_decode_mb(s
, s
->block
);
252 ff_h263_loop_filter(s
);
254 ff_er_add_slice(&s
->er
, s
->resync_mb_x
, s
->resync_mb_y
,
255 s
->mb_x
, s
->mb_y
, ER_MB_END
& part_mask
);
257 s
->padding_bug_score
--;
259 if (++s
->mb_x
>= s
->mb_width
) {
261 ff_mpeg_draw_horiz_band(s
, s
->mb_y
* mb_size
, mb_size
);
262 ff_mpv_report_decode_progress(s
);
266 } else if (ret
== SLICE_NOEND
) {
267 av_log(s
->avctx
, AV_LOG_ERROR
,
268 "Slice mismatch at MB: %d\n", xy
);
269 ff_er_add_slice(&s
->er
, s
->resync_mb_x
, s
->resync_mb_y
,
270 s
->mb_x
+ 1, s
->mb_y
,
271 ER_MB_END
& part_mask
);
272 return AVERROR_INVALIDDATA
;
274 av_log(s
->avctx
, AV_LOG_ERROR
, "Error at MB: %d\n", xy
);
275 ff_er_add_slice(&s
->er
, s
->resync_mb_x
, s
->resync_mb_y
,
276 s
->mb_x
, s
->mb_y
, ER_MB_ERROR
& part_mask
);
278 if (s
->err_recognition
& AV_EF_IGNORE_ERR
)
280 return AVERROR_INVALIDDATA
;
283 ff_mpv_decode_mb(s
, s
->block
);
285 ff_h263_loop_filter(s
);
288 ff_mpeg_draw_horiz_band(s
, s
->mb_y
* mb_size
, mb_size
);
289 ff_mpv_report_decode_progress(s
);
294 av_assert1(s
->mb_x
== 0 && s
->mb_y
== s
->mb_height
);
296 if (s
->codec_id
== AV_CODEC_ID_MPEG4
&&
297 (s
->workaround_bugs
& FF_BUG_AUTODETECT
) &&
298 get_bits_left(&s
->gb
) >= 48 &&
299 show_bits(&s
->gb
, 24) == 0x4010 &&
300 !s
->data_partitioning
)
301 s
->padding_bug_score
+= 32;
303 /* try to detect the padding bug */
304 if (s
->codec_id
== AV_CODEC_ID_MPEG4
&&
305 (s
->workaround_bugs
& FF_BUG_AUTODETECT
) &&
306 get_bits_left(&s
->gb
) >= 0 &&
307 get_bits_left(&s
->gb
) < 137 &&
308 !s
->data_partitioning
) {
309 const int bits_count
= get_bits_count(&s
->gb
);
310 const int bits_left
= s
->gb
.size_in_bits
- bits_count
;
312 if (bits_left
== 0) {
313 s
->padding_bug_score
+= 16;
314 } else if (bits_left
!= 1) {
315 int v
= show_bits(&s
->gb
, 8);
316 v
|= 0x7F >> (7 - (bits_count
& 7));
318 if (v
== 0x7F && bits_left
<= 8)
319 s
->padding_bug_score
--;
320 else if (v
== 0x7F && ((get_bits_count(&s
->gb
) + 8) & 8) &&
322 s
->padding_bug_score
+= 4;
324 s
->padding_bug_score
++;
328 if (s
->codec_id
== AV_CODEC_ID_H263
&&
329 (s
->workaround_bugs
& FF_BUG_AUTODETECT
) &&
330 get_bits_left(&s
->gb
) >= 8 &&
331 get_bits_left(&s
->gb
) < 300 &&
332 s
->pict_type
== AV_PICTURE_TYPE_I
&&
333 show_bits(&s
->gb
, 8) == 0 &&
334 !s
->data_partitioning
) {
336 s
->padding_bug_score
+= 32;
339 if (s
->codec_id
== AV_CODEC_ID_H263
&&
340 (s
->workaround_bugs
& FF_BUG_AUTODETECT
) &&
341 get_bits_left(&s
->gb
) >= 64 &&
342 AV_RB64(s
->gb
.buffer_end
- 8) == 0xCDCDCDCDFC7F0000) {
344 s
->padding_bug_score
+= 32;
347 if (s
->workaround_bugs
& FF_BUG_AUTODETECT
) {
348 if (s
->padding_bug_score
> -2 && !s
->data_partitioning
)
349 s
->workaround_bugs
|= FF_BUG_NO_PADDING
;
351 s
->workaround_bugs
&= ~FF_BUG_NO_PADDING
;
354 // handle formats which don't have unique end markers
355 if (s
->msmpeg4_version
|| (s
->workaround_bugs
& FF_BUG_NO_PADDING
)) { // FIXME perhaps solve this more cleanly
356 int left
= get_bits_left(&s
->gb
);
359 /* no markers in M$ crap */
360 if (s
->msmpeg4_version
&& s
->pict_type
== AV_PICTURE_TYPE_I
)
363 /* buggy padding but the frame should still end approximately at
364 * the bitstream end */
365 if ((s
->workaround_bugs
& FF_BUG_NO_PADDING
) &&
366 (s
->err_recognition
& (AV_EF_BUFFER
|AV_EF_AGGRESSIVE
)))
368 else if ((s
->workaround_bugs
& FF_BUG_NO_PADDING
))
369 max_extra
+= 256 * 256 * 256 * 64;
371 if (left
> max_extra
)
372 av_log(s
->avctx
, AV_LOG_ERROR
,
373 "discarding %d junk bits at end, next would be %X\n",
374 left
, show_bits(&s
->gb
, 24));
376 av_log(s
->avctx
, AV_LOG_ERROR
, "overreading %d bits\n", -left
);
378 ff_er_add_slice(&s
->er
, s
->resync_mb_x
, s
->resync_mb_y
,
379 s
->mb_x
- 1, s
->mb_y
, ER_MB_END
);
384 av_log(s
->avctx
, AV_LOG_ERROR
,
385 "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
386 get_bits_left(&s
->gb
), show_bits(&s
->gb
, 24), s
->padding_bug_score
);
388 ff_er_add_slice(&s
->er
, s
->resync_mb_x
, s
->resync_mb_y
, s
->mb_x
, s
->mb_y
,
389 ER_MB_END
& part_mask
);
391 return AVERROR_INVALIDDATA
;
394 int ff_h263_decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame
,
397 const uint8_t *buf
= avpkt
->data
;
398 int buf_size
= avpkt
->size
;
399 MpegEncContext
*s
= avctx
->priv_data
;
402 AVFrame
*pict
= data
;
404 s
->flags
= avctx
->flags
;
405 s
->flags2
= avctx
->flags2
;
407 /* no supplementary picture */
409 /* special case for last picture */
410 if (s
->low_delay
== 0 && s
->next_picture_ptr
) {
411 if ((ret
= av_frame_ref(pict
, s
->next_picture_ptr
->f
)) < 0)
413 s
->next_picture_ptr
= NULL
;
421 if (s
->flags
& CODEC_FLAG_TRUNCATED
) {
424 if (CONFIG_MPEG4_DECODER
&& s
->codec_id
== AV_CODEC_ID_MPEG4
) {
425 next
= ff_mpeg4_find_frame_end(&s
->parse_context
, buf
, buf_size
);
426 } else if (CONFIG_H263_DECODER
&& s
->codec_id
== AV_CODEC_ID_H263
) {
427 next
= ff_h263_find_frame_end(&s
->parse_context
, buf
, buf_size
);
428 } else if (CONFIG_H263P_DECODER
&& s
->codec_id
== AV_CODEC_ID_H263P
) {
429 next
= ff_h263_find_frame_end(&s
->parse_context
, buf
, buf_size
);
431 av_log(s
->avctx
, AV_LOG_ERROR
,
432 "this codec does not support truncated bitstreams\n");
433 return AVERROR(ENOSYS
);
436 if (ff_combine_frame(&s
->parse_context
, next
, (const uint8_t **)&buf
,
442 if (s
->divx_packed
&& s
->bitstream_buffer_size
) {
444 for(i
=0; i
< buf_size
-3; i
++) {
445 if (buf
[i
]==0 && buf
[i
+1]==0 && buf
[i
+2]==1) {
446 if (buf
[i
+3]==0xB0) {
447 av_log(s
->avctx
, AV_LOG_WARNING
, "Discarding excessive bitstream in packed xvid\n");
448 s
->bitstream_buffer_size
= 0;
455 if (s
->bitstream_buffer_size
&& (s
->divx_packed
|| buf_size
< 20)) // divx 5.01+/xvid frame reorder
456 ret
= init_get_bits8(&s
->gb
, s
->bitstream_buffer
,
457 s
->bitstream_buffer_size
);
459 ret
= init_get_bits8(&s
->gb
, buf
, buf_size
);
461 s
->bitstream_buffer_size
= 0;
465 if (!s
->context_initialized
)
466 // we need the idct permutaton for reading a custom matrix
470 if (CONFIG_WMV2_DECODER
&& s
->msmpeg4_version
== 5) {
471 ret
= ff_wmv2_decode_picture_header(s
);
472 } else if (CONFIG_MSMPEG4_DECODER
&& s
->msmpeg4_version
) {
473 ret
= ff_msmpeg4_decode_picture_header(s
);
474 } else if (CONFIG_MPEG4_DECODER
&& avctx
->codec_id
== AV_CODEC_ID_MPEG4
) {
475 if (s
->avctx
->extradata_size
&& s
->picture_number
== 0) {
478 if (init_get_bits8(&gb
, s
->avctx
->extradata
, s
->avctx
->extradata_size
) >= 0 )
479 ff_mpeg4_decode_picture_header(avctx
->priv_data
, &gb
);
481 ret
= ff_mpeg4_decode_picture_header(avctx
->priv_data
, &s
->gb
);
482 } else if (CONFIG_H263I_DECODER
&& s
->codec_id
== AV_CODEC_ID_H263I
) {
483 ret
= ff_intel_h263_decode_picture_header(s
);
484 } else if (CONFIG_FLV_DECODER
&& s
->h263_flv
) {
485 ret
= ff_flv_decode_picture_header(s
);
487 ret
= ff_h263_decode_picture_header(s
);
490 if (ret
< 0 || ret
== FRAME_SKIPPED
) {
491 if ( s
->width
!= avctx
->coded_width
492 || s
->height
!= avctx
->coded_height
) {
493 av_log(s
->avctx
, AV_LOG_WARNING
, "Reverting picture dimensions change due to header decoding failure\n");
494 s
->width
= avctx
->coded_width
;
495 s
->height
= avctx
->coded_height
;
498 if (ret
== FRAME_SKIPPED
)
499 return get_consumed_bytes(s
, buf_size
);
501 /* skip if the header was thrashed */
503 av_log(s
->avctx
, AV_LOG_ERROR
, "header damaged\n");
507 if (!s
->context_initialized
)
508 if ((ret
= ff_mpv_common_init(s
)) < 0)
511 if (!s
->current_picture_ptr
|| s
->current_picture_ptr
->f
->data
[0]) {
512 int i
= ff_find_unused_picture(s
, 0);
515 s
->current_picture_ptr
= &s
->picture
[i
];
518 avctx
->has_b_frames
= !s
->low_delay
;
520 if (CONFIG_MPEG4_DECODER
&& avctx
->codec_id
== AV_CODEC_ID_MPEG4
) {
521 if (ff_mpeg4_workaround_bugs(avctx
) == 1)
525 /* After H263 & mpeg4 header decode we have the height, width,
526 * and other parameters. So then we could init the picture.
527 * FIXME: By the way H263 decoder is evolving it should have
528 * an H263EncContext */
529 if (s
->width
!= avctx
->coded_width
||
530 s
->height
!= avctx
->coded_height
||
532 /* H.263 could change picture size any time */
533 s
->context_reinit
= 0;
535 ret
= ff_set_dimensions(avctx
, s
->width
, s
->height
);
539 ff_set_sar(avctx
, avctx
->sample_aspect_ratio
);
541 if ((ret
= ff_mpv_common_frame_size_change(s
)))
545 if (s
->codec_id
== AV_CODEC_ID_H263
||
546 s
->codec_id
== AV_CODEC_ID_H263P
||
547 s
->codec_id
== AV_CODEC_ID_H263I
)
548 s
->gob_index
= ff_h263_get_gob_height(s
);
550 // for skipping the frame
551 s
->current_picture
.f
->pict_type
= s
->pict_type
;
552 s
->current_picture
.f
->key_frame
= s
->pict_type
== AV_PICTURE_TYPE_I
;
554 /* skip B-frames if we don't have reference frames */
555 if (!s
->last_picture_ptr
&&
556 (s
->pict_type
== AV_PICTURE_TYPE_B
|| s
->droppable
))
557 return get_consumed_bytes(s
, buf_size
);
558 if ((avctx
->skip_frame
>= AVDISCARD_NONREF
&&
559 s
->pict_type
== AV_PICTURE_TYPE_B
) ||
560 (avctx
->skip_frame
>= AVDISCARD_NONKEY
&&
561 s
->pict_type
!= AV_PICTURE_TYPE_I
) ||
562 avctx
->skip_frame
>= AVDISCARD_ALL
)
563 return get_consumed_bytes(s
, buf_size
);
565 if (s
->next_p_frame_damaged
) {
566 if (s
->pict_type
== AV_PICTURE_TYPE_B
)
567 return get_consumed_bytes(s
, buf_size
);
569 s
->next_p_frame_damaged
= 0;
572 if ((!s
->no_rounding
) || s
->pict_type
== AV_PICTURE_TYPE_B
) {
573 s
->me
.qpel_put
= s
->qdsp
.put_qpel_pixels_tab
;
574 s
->me
.qpel_avg
= s
->qdsp
.avg_qpel_pixels_tab
;
576 s
->me
.qpel_put
= s
->qdsp
.put_no_rnd_qpel_pixels_tab
;
577 s
->me
.qpel_avg
= s
->qdsp
.avg_qpel_pixels_tab
;
580 if ((ret
= ff_mpv_frame_start(s
, avctx
)) < 0)
583 if (!s
->divx_packed
&& !avctx
->hwaccel
)
584 ff_thread_finish_setup(avctx
);
586 if (CONFIG_MPEG4_VDPAU_DECODER
&& (s
->avctx
->codec
->capabilities
& CODEC_CAP_HWACCEL_VDPAU
)) {
587 ff_vdpau_mpeg4_decode_picture(avctx
->priv_data
, s
->gb
.buffer
, s
->gb
.buffer_end
- s
->gb
.buffer
);
591 if (avctx
->hwaccel
) {
592 ret
= avctx
->hwaccel
->start_frame(avctx
, s
->gb
.buffer
,
593 s
->gb
.buffer_end
- s
->gb
.buffer
);
598 ff_mpeg_er_frame_start(s
);
600 /* the second part of the wmv2 header contains the MB skip bits which
601 * are stored in current_picture->mb_type which is not available before
602 * ff_mpv_frame_start() */
603 if (CONFIG_WMV2_DECODER
&& s
->msmpeg4_version
== 5) {
604 ret
= ff_wmv2_decode_secondary_picture_header(s
);
611 /* decode each macroblock */
615 slice_ret
= decode_slice(s
);
616 while (s
->mb_y
< s
->mb_height
) {
617 if (s
->msmpeg4_version
) {
618 if (s
->slice_height
== 0 || s
->mb_x
!= 0 ||
619 (s
->mb_y
% s
->slice_height
) != 0 || get_bits_left(&s
->gb
) < 0)
622 int prev_x
= s
->mb_x
, prev_y
= s
->mb_y
;
623 if (ff_h263_resync(s
) < 0)
625 if (prev_y
* s
->mb_width
+ prev_x
< s
->mb_y
* s
->mb_width
+ s
->mb_x
)
626 s
->er
.error_occurred
= 1;
629 if (s
->msmpeg4_version
< 4 && s
->h263_pred
)
630 ff_mpeg4_clean_buffers(s
);
632 if (decode_slice(s
) < 0)
633 slice_ret
= AVERROR_INVALIDDATA
;
636 if (s
->msmpeg4_version
&& s
->msmpeg4_version
< 4 &&
637 s
->pict_type
== AV_PICTURE_TYPE_I
)
638 if (!CONFIG_MSMPEG4_DECODER
||
639 ff_msmpeg4_decode_ext_header(s
, buf_size
) < 0)
640 s
->er
.error_status_table
[s
->mb_num
- 1] = ER_MB_ERROR
;
642 av_assert1(s
->bitstream_buffer_size
== 0);
644 ff_er_frame_end(&s
->er
);
646 if (avctx
->hwaccel
) {
647 ret
= avctx
->hwaccel
->end_frame(avctx
);
654 if (CONFIG_MPEG4_DECODER
&& avctx
->codec_id
== AV_CODEC_ID_MPEG4
)
655 ff_mpeg4_frame_end(avctx
, buf
, buf_size
);
657 if (!s
->divx_packed
&& avctx
->hwaccel
)
658 ff_thread_finish_setup(avctx
);
660 av_assert1(s
->current_picture
.f
->pict_type
== s
->current_picture_ptr
->f
->pict_type
);
661 av_assert1(s
->current_picture
.f
->pict_type
== s
->pict_type
);
662 if (s
->pict_type
== AV_PICTURE_TYPE_B
|| s
->low_delay
) {
663 if ((ret
= av_frame_ref(pict
, s
->current_picture_ptr
->f
)) < 0)
665 ff_print_debug_info(s
, s
->current_picture_ptr
, pict
);
666 ff_mpv_export_qp_table(s
, pict
, s
->current_picture_ptr
, FF_QSCALE_TYPE_MPEG1
);
667 } else if (s
->last_picture_ptr
) {
668 if ((ret
= av_frame_ref(pict
, s
->last_picture_ptr
->f
)) < 0)
670 ff_print_debug_info(s
, s
->last_picture_ptr
, pict
);
671 ff_mpv_export_qp_table(s
, pict
, s
->last_picture_ptr
, FF_QSCALE_TYPE_MPEG1
);
674 if (s
->last_picture_ptr
|| s
->low_delay
) {
675 if ( pict
->format
== AV_PIX_FMT_YUV420P
676 && (s
->codec_tag
== AV_RL32("GEOV") || s
->codec_tag
== AV_RL32("GEOX"))) {
678 av_frame_make_writable(pict
);
679 for (p
=0; p
<3; p
++) {
680 int w
= FF_CEIL_RSHIFT(pict
-> width
, !!p
);
681 int h
= FF_CEIL_RSHIFT(pict
->height
, !!p
);
682 int linesize
= pict
->linesize
[p
];
683 for (y
=0; y
<(h
>>1); y
++)
686 pict
->data
[p
][x
+ y
*linesize
],
687 pict
->data
[p
][x
+ (h
-1-y
)*linesize
]);
693 if (slice_ret
< 0 && (avctx
->err_recognition
& AV_EF_EXPLODE
))
696 return get_consumed_bytes(s
, buf_size
);
699 const enum AVPixelFormat ff_h263_hwaccel_pixfmt_list_420
[] = {
700 #if CONFIG_H263_VAAPI_HWACCEL || CONFIG_MPEG4_VAAPI_HWACCEL
701 AV_PIX_FMT_VAAPI_VLD
,
703 #if CONFIG_H263_VDPAU_HWACCEL || CONFIG_MPEG4_VDPAU_HWACCEL
710 AVCodec ff_h263_decoder
= {
712 .long_name
= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
713 .type
= AVMEDIA_TYPE_VIDEO
,
714 .id
= AV_CODEC_ID_H263
,
715 .priv_data_size
= sizeof(MpegEncContext
),
716 .init
= ff_h263_decode_init
,
717 .close
= ff_h263_decode_end
,
718 .decode
= ff_h263_decode_frame
,
719 .capabilities
= CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
|
720 CODEC_CAP_TRUNCATED
| CODEC_CAP_DELAY
,
721 .flush
= ff_mpeg_flush
,
723 .pix_fmts
= ff_h263_hwaccel_pixfmt_list_420
,
726 AVCodec ff_h263p_decoder
= {
728 .long_name
= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
729 .type
= AVMEDIA_TYPE_VIDEO
,
730 .id
= AV_CODEC_ID_H263P
,
731 .priv_data_size
= sizeof(MpegEncContext
),
732 .init
= ff_h263_decode_init
,
733 .close
= ff_h263_decode_end
,
734 .decode
= ff_h263_decode_frame
,
735 .capabilities
= CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
|
736 CODEC_CAP_TRUNCATED
| CODEC_CAP_DELAY
,
737 .flush
= ff_mpeg_flush
,
739 .pix_fmts
= ff_h263_hwaccel_pixfmt_list_420
,