1
by Sérgio Benjamim
FFmpeg 2.7.1 source for ppsspp. |
1 |
/*
|
2 |
* H.263 decoder
|
|
3 |
* Copyright (c) 2001 Fabrice Bellard
|
|
4 |
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
|
|
5 |
*
|
|
6 |
* This file is part of FFmpeg.
|
|
7 |
*
|
|
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.
|
|
12 |
*
|
|
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.
|
|
17 |
*
|
|
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
|
|
21 |
*/
|
|
22 |
||
23 |
/**
|
|
24 |
* @file
|
|
25 |
* H.263 decoder.
|
|
26 |
*/
|
|
27 |
||
28 |
#define UNCHECKED_BITSTREAM_READER 1
|
|
29 |
||
30 |
#include "libavutil/cpu.h" |
|
31 |
#include "avcodec.h" |
|
32 |
#include "error_resilience.h" |
|
33 |
#include "flv.h" |
|
34 |
#include "h263.h" |
|
35 |
#include "h263_parser.h" |
|
36 |
#include "internal.h" |
|
37 |
#include "mpeg_er.h" |
|
38 |
#include "mpeg4video.h" |
|
39 |
#include "mpeg4video_parser.h" |
|
40 |
#include "mpegutils.h" |
|
41 |
#include "mpegvideo.h" |
|
42 |
#include "msmpeg4.h" |
|
43 |
#include "qpeldsp.h" |
|
44 |
#include "vdpau_compat.h" |
|
45 |
#include "thread.h" |
|
46 |
#include "wmv2.h" |
|
47 |
||
48 |
static enum AVPixelFormat h263_get_format(AVCodecContext *avctx) |
|
49 |
{
|
|
50 |
if (avctx->codec->id == AV_CODEC_ID_MSS2) |
|
51 |
return AV_PIX_FMT_YUV420P; |
|
52 |
||
53 |
if (CONFIG_GRAY && (avctx->flags & CODEC_FLAG_GRAY)) { |
|
54 |
if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED) |
|
55 |
avctx->color_range = AVCOL_RANGE_MPEG; |
|
56 |
return AV_PIX_FMT_GRAY8; |
|
57 |
}
|
|
58 |
||
59 |
return avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts); |
|
60 |
}
|
|
61 |
||
62 |
av_cold int ff_h263_decode_init(AVCodecContext *avctx) |
|
63 |
{
|
|
64 |
MpegEncContext *s = avctx->priv_data; |
|
65 |
int ret; |
|
66 |
||
67 |
s->out_format = FMT_H263; |
|
68 |
||
69 |
// set defaults
|
|
70 |
ff_mpv_decode_defaults(s); |
|
71 |
ff_mpv_decode_init(s, avctx); |
|
72 |
||
73 |
s->quant_precision = 5; |
|
74 |
s->decode_mb = ff_h263_decode_mb; |
|
75 |
s->low_delay = 1; |
|
76 |
s->unrestricted_mv = 1; |
|
77 |
||
78 |
/* select sub codec */
|
|
79 |
switch (avctx->codec->id) { |
|
80 |
case AV_CODEC_ID_H263: |
|
81 |
case AV_CODEC_ID_H263P: |
|
82 |
s->unrestricted_mv = 0; |
|
83 |
avctx->chroma_sample_location = AVCHROMA_LOC_CENTER; |
|
84 |
break; |
|
85 |
case AV_CODEC_ID_MPEG4: |
|
86 |
break; |
|
87 |
case AV_CODEC_ID_MSMPEG4V1: |
|
88 |
s->h263_pred = 1; |
|
89 |
s->msmpeg4_version = 1; |
|
90 |
break; |
|
91 |
case AV_CODEC_ID_MSMPEG4V2: |
|
92 |
s->h263_pred = 1; |
|
93 |
s->msmpeg4_version = 2; |
|
94 |
break; |
|
95 |
case AV_CODEC_ID_MSMPEG4V3: |
|
96 |
s->h263_pred = 1; |
|
97 |
s->msmpeg4_version = 3; |
|
98 |
break; |
|
99 |
case AV_CODEC_ID_WMV1: |
|
100 |
s->h263_pred = 1; |
|
101 |
s->msmpeg4_version = 4; |
|
102 |
break; |
|
103 |
case AV_CODEC_ID_WMV2: |
|
104 |
s->h263_pred = 1; |
|
105 |
s->msmpeg4_version = 5; |
|
106 |
break; |
|
107 |
case AV_CODEC_ID_VC1: |
|
108 |
case AV_CODEC_ID_WMV3: |
|
109 |
case AV_CODEC_ID_VC1IMAGE: |
|
110 |
case AV_CODEC_ID_WMV3IMAGE: |
|
111 |
case AV_CODEC_ID_MSS2: |
|
112 |
s->h263_pred = 1; |
|
113 |
s->msmpeg4_version = 6; |
|
114 |
avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; |
|
115 |
break; |
|
116 |
case AV_CODEC_ID_H263I: |
|
117 |
break; |
|
118 |
case AV_CODEC_ID_FLV1: |
|
119 |
s->h263_flv = 1; |
|
120 |
break; |
|
121 |
default: |
|
122 |
av_log(avctx, AV_LOG_ERROR, "Unsupported codec %d\n", |
|
123 |
avctx->codec->id); |
|
124 |
return AVERROR(ENOSYS); |
|
125 |
}
|
|
126 |
s->codec_id = avctx->codec->id; |
|
127 |
||
128 |
if (avctx->codec_tag == AV_RL32("L263") || avctx->codec_tag == AV_RL32("S263")) |
|
129 |
if (avctx->extradata_size == 56 && avctx->extradata[0] == 1) |
|
130 |
s->ehc_mode = 1; |
|
131 |
||
132 |
/* for h263, we allocate the images after having read the header */
|
|
133 |
if (avctx->codec->id != AV_CODEC_ID_H263 && |
|
134 |
avctx->codec->id != AV_CODEC_ID_H263P && |
|
135 |
avctx->codec->id != AV_CODEC_ID_MPEG4) { |
|
136 |
avctx->pix_fmt = h263_get_format(avctx); |
|
137 |
ff_mpv_idct_init(s); |
|
138 |
if ((ret = ff_mpv_common_init(s)) < 0) |
|
139 |
return ret; |
|
140 |
}
|
|
141 |
||
142 |
ff_h263dsp_init(&s->h263dsp); |
|
143 |
ff_qpeldsp_init(&s->qdsp); |
|
144 |
ff_h263_decode_init_vlc(); |
|
145 |
||
146 |
return 0; |
|
147 |
}
|
|
148 |
||
149 |
av_cold int ff_h263_decode_end(AVCodecContext *avctx) |
|
150 |
{
|
|
151 |
MpegEncContext *s = avctx->priv_data; |
|
152 |
||
153 |
ff_mpv_common_end(s); |
|
154 |
return 0; |
|
155 |
}
|
|
156 |
||
157 |
/**
|
|
158 |
* Return the number of bytes consumed for building the current frame.
|
|
159 |
*/
|
|
160 |
static int get_consumed_bytes(MpegEncContext *s, int buf_size) |
|
161 |
{
|
|
162 |
int pos = (get_bits_count(&s->gb) + 7) >> 3; |
|
163 |
||
164 |
if (s->divx_packed || s->avctx->hwaccel) { |
|
165 |
/* We would have to scan through the whole buf to handle the weird
|
|
166 |
* reordering ... */
|
|
167 |
return buf_size; |
|
168 |
} else if (s->avctx->flags & CODEC_FLAG_TRUNCATED) { |
|
169 |
pos -= s->parse_context.last_index; |
|
170 |
// padding is not really read so this might be -1
|
|
171 |
if (pos < 0) |
|
172 |
pos = 0; |
|
173 |
return pos; |
|
174 |
} else { |
|
175 |
// avoid infinite loops (maybe not needed...)
|
|
176 |
if (pos == 0) |
|
177 |
pos = 1; |
|
178 |
// oops ;)
|
|
179 |
if (pos + 10 > buf_size) |
|
180 |
pos = buf_size; |
|
181 |
||
182 |
return pos; |
|
183 |
}
|
|
184 |
}
|
|
185 |
||
186 |
static int decode_slice(MpegEncContext *s) |
|
187 |
{
|
|
188 |
const int part_mask = s->partitioned_frame |
|
189 |
? (ER_AC_END | ER_AC_ERROR) : 0x7F; |
|
190 |
const int mb_size = 16 >> s->avctx->lowres; |
|
191 |
int ret; |
|
192 |
||
193 |
s->last_resync_gb = s->gb; |
|
194 |
s->first_slice_line = 1; |
|
195 |
s->resync_mb_x = s->mb_x; |
|
196 |
s->resync_mb_y = s->mb_y; |
|
197 |
||
198 |
ff_set_qscale(s, s->qscale); |
|
199 |
||
200 |
if (s->avctx->hwaccel) { |
|
201 |
const uint8_t *start = s->gb.buffer + get_bits_count(&s->gb) / 8; |
|
202 |
ret = s->avctx->hwaccel->decode_slice(s->avctx, start, s->gb.buffer_end - start); |
|
203 |
// ensure we exit decode loop
|
|
204 |
s->mb_y = s->mb_height; |
|
205 |
return ret; |
|
206 |
}
|
|
207 |
||
208 |
if (s->partitioned_frame) { |
|
209 |
const int qscale = s->qscale; |
|
210 |
||
211 |
if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4) |
|
212 |
if ((ret = ff_mpeg4_decode_partitions(s->avctx->priv_data)) < 0) |
|
213 |
return ret; |
|
214 |
||
215 |
/* restore variables which were modified */
|
|
216 |
s->first_slice_line = 1; |
|
217 |
s->mb_x = s->resync_mb_x; |
|
218 |
s->mb_y = s->resync_mb_y; |
|
219 |
ff_set_qscale(s, qscale); |
|
220 |
}
|
|
221 |
||
222 |
for (; s->mb_y < s->mb_height; s->mb_y++) { |
|
223 |
/* per-row end of slice checks */
|
|
224 |
if (s->msmpeg4_version) { |
|
225 |
if (s->resync_mb_y + s->slice_height == s->mb_y) { |
|
226 |
ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, |
|
227 |
s->mb_x - 1, s->mb_y, ER_MB_END); |
|
228 |
||
229 |
return 0; |
|
230 |
}
|
|
231 |
}
|
|
232 |
||
233 |
if (s->msmpeg4_version == 1) { |
|
234 |
s->last_dc[0] = |
|
235 |
s->last_dc[1] = |
|
236 |
s->last_dc[2] = 128; |
|
237 |
}
|
|
238 |
||
239 |
ff_init_block_index(s); |
|
240 |
for (; s->mb_x < s->mb_width; s->mb_x++) { |
|
241 |
int ret; |
|
242 |
||
243 |
ff_update_block_index(s); |
|
244 |
||
245 |
if (s->resync_mb_x == s->mb_x && s->resync_mb_y + 1 == s->mb_y) |
|
246 |
s->first_slice_line = 0; |
|
247 |
||
248 |
/* DCT & quantize */
|
|
249 |
||
250 |
s->mv_dir = MV_DIR_FORWARD; |
|
251 |
s->mv_type = MV_TYPE_16X16; |
|
252 |
ff_dlog(s, "%d %d %06X\n", |
|
253 |
ret, get_bits_count(&s->gb), show_bits(&s->gb, 24)); |
|
254 |
||
255 |
ff_tlog(NULL, "Decoding MB at %dx%d\n", s->mb_x, s->mb_y); |
|
256 |
ret = s->decode_mb(s, s->block); |
|
257 |
||
258 |
if (s->pict_type != AV_PICTURE_TYPE_B) |
|
259 |
ff_h263_update_motion_val(s); |
|
260 |
||
261 |
if (ret < 0) { |
|
262 |
const int xy = s->mb_x + s->mb_y * s->mb_stride; |
|
263 |
if (ret == SLICE_END) { |
|
264 |
ff_mpv_decode_mb(s, s->block); |
|
265 |
if (s->loop_filter) |
|
266 |
ff_h263_loop_filter(s); |
|
267 |
||
268 |
ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, |
|
269 |
s->mb_x, s->mb_y, ER_MB_END & part_mask); |
|
270 |
||
271 |
s->padding_bug_score--; |
|
272 |
||
273 |
if (++s->mb_x >= s->mb_width) { |
|
274 |
s->mb_x = 0; |
|
275 |
ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size); |
|
276 |
ff_mpv_report_decode_progress(s); |
|
277 |
s->mb_y++; |
|
278 |
}
|
|
279 |
return 0; |
|
280 |
} else if (ret == SLICE_NOEND) { |
|
281 |
av_log(s->avctx, AV_LOG_ERROR, |
|
282 |
"Slice mismatch at MB: %d\n", xy); |
|
283 |
ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, |
|
284 |
s->mb_x + 1, s->mb_y, |
|
285 |
ER_MB_END & part_mask); |
|
286 |
return AVERROR_INVALIDDATA; |
|
287 |
}
|
|
288 |
av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy); |
|
289 |
ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, |
|
290 |
s->mb_x, s->mb_y, ER_MB_ERROR & part_mask); |
|
291 |
||
292 |
if (s->avctx->err_recognition & AV_EF_IGNORE_ERR) |
|
293 |
continue; |
|
294 |
return AVERROR_INVALIDDATA; |
|
295 |
}
|
|
296 |
||
297 |
ff_mpv_decode_mb(s, s->block); |
|
298 |
if (s->loop_filter) |
|
299 |
ff_h263_loop_filter(s); |
|
300 |
}
|
|
301 |
||
302 |
ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size); |
|
303 |
ff_mpv_report_decode_progress(s); |
|
304 |
||
305 |
s->mb_x = 0; |
|
306 |
}
|
|
307 |
||
308 |
av_assert1(s->mb_x == 0 && s->mb_y == s->mb_height); |
|
309 |
||
310 |
if (s->codec_id == AV_CODEC_ID_MPEG4 && |
|
311 |
(s->workaround_bugs & FF_BUG_AUTODETECT) && |
|
312 |
get_bits_left(&s->gb) >= 48 && |
|
313 |
show_bits(&s->gb, 24) == 0x4010 && |
|
314 |
!s->data_partitioning) |
|
315 |
s->padding_bug_score += 32; |
|
316 |
||
317 |
/* try to detect the padding bug */
|
|
318 |
if (s->codec_id == AV_CODEC_ID_MPEG4 && |
|
319 |
(s->workaround_bugs & FF_BUG_AUTODETECT) && |
|
320 |
get_bits_left(&s->gb) >= 0 && |
|
321 |
get_bits_left(&s->gb) < 137 && |
|
322 |
!s->data_partitioning) { |
|
323 |
const int bits_count = get_bits_count(&s->gb); |
|
324 |
const int bits_left = s->gb.size_in_bits - bits_count; |
|
325 |
||
326 |
if (bits_left == 0) { |
|
327 |
s->padding_bug_score += 16; |
|
328 |
} else if (bits_left != 1) { |
|
329 |
int v = show_bits(&s->gb, 8); |
|
330 |
v |= 0x7F >> (7 - (bits_count & 7)); |
|
331 |
||
332 |
if (v == 0x7F && bits_left <= 8) |
|
333 |
s->padding_bug_score--; |
|
334 |
else if (v == 0x7F && ((get_bits_count(&s->gb) + 8) & 8) && |
|
335 |
bits_left <= 16) |
|
336 |
s->padding_bug_score += 4; |
|
337 |
else
|
|
338 |
s->padding_bug_score++; |
|
339 |
}
|
|
340 |
}
|
|
341 |
||
342 |
if (s->codec_id == AV_CODEC_ID_H263 && |
|
343 |
(s->workaround_bugs & FF_BUG_AUTODETECT) && |
|
344 |
get_bits_left(&s->gb) >= 8 && |
|
345 |
get_bits_left(&s->gb) < 300 && |
|
346 |
s->pict_type == AV_PICTURE_TYPE_I && |
|
347 |
show_bits(&s->gb, 8) == 0 && |
|
348 |
!s->data_partitioning) { |
|
349 |
||
350 |
s->padding_bug_score += 32; |
|
351 |
}
|
|
352 |
||
353 |
if (s->codec_id == AV_CODEC_ID_H263 && |
|
354 |
(s->workaround_bugs & FF_BUG_AUTODETECT) && |
|
355 |
get_bits_left(&s->gb) >= 64 && |
|
356 |
AV_RB64(s->gb.buffer_end - 8) == 0xCDCDCDCDFC7F0000) { |
|
357 |
||
358 |
s->padding_bug_score += 32; |
|
359 |
}
|
|
360 |
||
361 |
if (s->workaround_bugs & FF_BUG_AUTODETECT) { |
|
362 |
if ( |
|
363 |
(s->padding_bug_score > -2 && !s->data_partitioning)) |
|
364 |
s->workaround_bugs |= FF_BUG_NO_PADDING; |
|
365 |
else
|
|
366 |
s->workaround_bugs &= ~FF_BUG_NO_PADDING; |
|
367 |
}
|
|
368 |
||
369 |
// handle formats which don't have unique end markers
|
|
370 |
if (s->msmpeg4_version || (s->workaround_bugs & FF_BUG_NO_PADDING)) { // FIXME perhaps solve this more cleanly |
|
371 |
int left = get_bits_left(&s->gb); |
|
372 |
int max_extra = 7; |
|
373 |
||
374 |
/* no markers in M$ crap */
|
|
375 |
if (s->msmpeg4_version && s->pict_type == AV_PICTURE_TYPE_I) |
|
376 |
max_extra += 17; |
|
377 |
||
378 |
/* buggy padding but the frame should still end approximately at
|
|
379 |
* the bitstream end */
|
|
380 |
if ((s->workaround_bugs & FF_BUG_NO_PADDING) && |
|
381 |
(s->avctx->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE))) |
|
382 |
max_extra += 48; |
|
383 |
else if ((s->workaround_bugs & FF_BUG_NO_PADDING)) |
|
384 |
max_extra += 256 * 256 * 256 * 64; |
|
385 |
||
386 |
if (left > max_extra) |
|
387 |
av_log(s->avctx, AV_LOG_ERROR, |
|
388 |
"discarding %d junk bits at end, next would be %X\n", |
|
389 |
left, show_bits(&s->gb, 24)); |
|
390 |
else if (left < 0) |
|
391 |
av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left); |
|
392 |
else
|
|
393 |
ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, |
|
394 |
s->mb_x - 1, s->mb_y, ER_MB_END); |
|
395 |
||
396 |
return 0; |
|
397 |
}
|
|
398 |
||
399 |
av_log(s->avctx, AV_LOG_ERROR, |
|
400 |
"slice end not reached but screenspace end (%d left %06X, score= %d)\n", |
|
401 |
get_bits_left(&s->gb), show_bits(&s->gb, 24), s->padding_bug_score); |
|
402 |
||
403 |
ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, |
|
404 |
ER_MB_END & part_mask); |
|
405 |
||
406 |
return AVERROR_INVALIDDATA; |
|
407 |
}
|
|
408 |
||
409 |
int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, |
|
410 |
AVPacket *avpkt) |
|
411 |
{
|
|
412 |
const uint8_t *buf = avpkt->data; |
|
413 |
int buf_size = avpkt->size; |
|
414 |
MpegEncContext *s = avctx->priv_data; |
|
415 |
int ret; |
|
416 |
int slice_ret = 0; |
|
417 |
AVFrame *pict = data; |
|
418 |
||
419 |
/* no supplementary picture */
|
|
420 |
if (buf_size == 0) { |
|
421 |
/* special case for last picture */
|
|
422 |
if (s->low_delay == 0 && s->next_picture_ptr) { |
|
423 |
if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0) |
|
424 |
return ret; |
|
425 |
s->next_picture_ptr = NULL; |
|
426 |
||
427 |
*got_frame = 1; |
|
428 |
}
|
|
429 |
||
430 |
return 0; |
|
431 |
}
|
|
432 |
||
433 |
if (s->avctx->flags & CODEC_FLAG_TRUNCATED) { |
|
434 |
int next; |
|
435 |
||
436 |
if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4) { |
|
437 |
next = ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size); |
|
438 |
} else if (CONFIG_H263_DECODER && s->codec_id == AV_CODEC_ID_H263) { |
|
439 |
next = ff_h263_find_frame_end(&s->parse_context, buf, buf_size); |
|
440 |
} else if (CONFIG_H263P_DECODER && s->codec_id == AV_CODEC_ID_H263P) { |
|
441 |
next = ff_h263_find_frame_end(&s->parse_context, buf, buf_size); |
|
442 |
} else { |
|
443 |
av_log(s->avctx, AV_LOG_ERROR, |
|
444 |
"this codec does not support truncated bitstreams\n"); |
|
445 |
return AVERROR(ENOSYS); |
|
446 |
}
|
|
447 |
||
448 |
if (ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf, |
|
449 |
&buf_size) < 0) |
|
450 |
return buf_size; |
|
451 |
}
|
|
452 |
||
453 |
retry: |
|
454 |
if (s->divx_packed && s->bitstream_buffer_size) { |
|
455 |
int i; |
|
456 |
for(i=0; i < buf_size-3; i++) { |
|
457 |
if (buf[i]==0 && buf[i+1]==0 && buf[i+2]==1) { |
|
458 |
if (buf[i+3]==0xB0) { |
|
459 |
av_log(s->avctx, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n"); |
|
460 |
s->bitstream_buffer_size = 0; |
|
461 |
}
|
|
462 |
break; |
|
463 |
}
|
|
464 |
}
|
|
465 |
}
|
|
466 |
||
467 |
if (s->bitstream_buffer_size && (s->divx_packed || buf_size <= MAX_NVOP_SIZE)) // divx 5.01+/xvid frame reorder |
|
468 |
ret = init_get_bits8(&s->gb, s->bitstream_buffer, |
|
469 |
s->bitstream_buffer_size); |
|
470 |
else
|
|
471 |
ret = init_get_bits8(&s->gb, buf, buf_size); |
|
472 |
||
473 |
s->bitstream_buffer_size = 0; |
|
474 |
if (ret < 0) |
|
475 |
return ret; |
|
476 |
||
477 |
if (!s->context_initialized) |
|
478 |
// we need the idct permutaton for reading a custom matrix
|
|
479 |
ff_mpv_idct_init(s); |
|
480 |
||
481 |
/* let's go :-) */
|
|
482 |
if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) { |
|
483 |
ret = ff_wmv2_decode_picture_header(s); |
|
484 |
} else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) { |
|
485 |
ret = ff_msmpeg4_decode_picture_header(s); |
|
486 |
} else if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) { |
|
487 |
if (s->avctx->extradata_size && s->picture_number == 0) { |
|
488 |
GetBitContext gb; |
|
489 |
||
490 |
if (init_get_bits8(&gb, s->avctx->extradata, s->avctx->extradata_size) >= 0 ) |
|
491 |
ff_mpeg4_decode_picture_header(avctx->priv_data, &gb); |
|
492 |
}
|
|
493 |
ret = ff_mpeg4_decode_picture_header(avctx->priv_data, &s->gb); |
|
494 |
} else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) { |
|
495 |
ret = ff_intel_h263_decode_picture_header(s); |
|
496 |
} else if (CONFIG_FLV_DECODER && s->h263_flv) { |
|
497 |
ret = ff_flv_decode_picture_header(s); |
|
498 |
} else { |
|
499 |
ret = ff_h263_decode_picture_header(s); |
|
500 |
}
|
|
501 |
||
502 |
if (ret < 0 || ret == FRAME_SKIPPED) { |
|
503 |
if ( s->width != avctx->coded_width |
|
504 |
|| s->height != avctx->coded_height) { |
|
505 |
av_log(s->avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n"); |
|
506 |
s->width = avctx->coded_width; |
|
507 |
s->height= avctx->coded_height; |
|
508 |
}
|
|
509 |
}
|
|
510 |
if (ret == FRAME_SKIPPED) |
|
511 |
return get_consumed_bytes(s, buf_size); |
|
512 |
||
513 |
/* skip if the header was thrashed */
|
|
514 |
if (ret < 0) { |
|
515 |
av_log(s->avctx, AV_LOG_ERROR, "header damaged\n"); |
|
516 |
return ret; |
|
517 |
}
|
|
518 |
||
519 |
if (!s->context_initialized) { |
|
520 |
avctx->pix_fmt = h263_get_format(avctx); |
|
521 |
if ((ret = ff_mpv_common_init(s)) < 0) |
|
522 |
return ret; |
|
523 |
}
|
|
524 |
||
525 |
if (!s->current_picture_ptr || s->current_picture_ptr->f->data[0]) { |
|
526 |
int i = ff_find_unused_picture(s->avctx, s->picture, 0); |
|
527 |
if (i < 0) |
|
528 |
return i; |
|
529 |
s->current_picture_ptr = &s->picture[i]; |
|
530 |
}
|
|
531 |
||
532 |
avctx->has_b_frames = !s->low_delay; |
|
533 |
||
534 |
if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) { |
|
535 |
if (ff_mpeg4_workaround_bugs(avctx) == 1) |
|
536 |
goto retry; |
|
537 |
}
|
|
538 |
||
539 |
/* After H263 & mpeg4 header decode we have the height, width,
|
|
540 |
* and other parameters. So then we could init the picture.
|
|
541 |
* FIXME: By the way H263 decoder is evolving it should have
|
|
542 |
* an H263EncContext */
|
|
543 |
if (s->width != avctx->coded_width || |
|
544 |
s->height != avctx->coded_height || |
|
545 |
s->context_reinit) { |
|
546 |
/* H.263 could change picture size any time */
|
|
547 |
s->context_reinit = 0; |
|
548 |
||
549 |
ret = ff_set_dimensions(avctx, s->width, s->height); |
|
550 |
if (ret < 0) |
|
551 |
return ret; |
|
552 |
||
553 |
ff_set_sar(avctx, avctx->sample_aspect_ratio); |
|
554 |
||
555 |
if ((ret = ff_mpv_common_frame_size_change(s))) |
|
556 |
return ret; |
|
557 |
||
558 |
if (avctx->pix_fmt != h263_get_format(avctx)) { |
|
559 |
av_log(avctx, AV_LOG_ERROR, "format change not supported\n"); |
|
560 |
avctx->pix_fmt = AV_PIX_FMT_NONE; |
|
561 |
return AVERROR_UNKNOWN; |
|
562 |
}
|
|
563 |
}
|
|
564 |
||
565 |
if (s->codec_id == AV_CODEC_ID_H263 || |
|
566 |
s->codec_id == AV_CODEC_ID_H263P || |
|
567 |
s->codec_id == AV_CODEC_ID_H263I) |
|
568 |
s->gob_index = H263_GOB_HEIGHT(s->height); |
|
569 |
||
570 |
// for skipping the frame
|
|
571 |
s->current_picture.f->pict_type = s->pict_type; |
|
572 |
s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; |
|
573 |
||
574 |
/* skip B-frames if we don't have reference frames */
|
|
575 |
if (!s->last_picture_ptr && |
|
576 |
(s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) |
|
577 |
return get_consumed_bytes(s, buf_size); |
|
578 |
if ((avctx->skip_frame >= AVDISCARD_NONREF && |
|
579 |
s->pict_type == AV_PICTURE_TYPE_B) || |
|
580 |
(avctx->skip_frame >= AVDISCARD_NONKEY && |
|
581 |
s->pict_type != AV_PICTURE_TYPE_I) || |
|
582 |
avctx->skip_frame >= AVDISCARD_ALL) |
|
583 |
return get_consumed_bytes(s, buf_size); |
|
584 |
||
585 |
if (s->next_p_frame_damaged) { |
|
586 |
if (s->pict_type == AV_PICTURE_TYPE_B) |
|
587 |
return get_consumed_bytes(s, buf_size); |
|
588 |
else
|
|
589 |
s->next_p_frame_damaged = 0; |
|
590 |
}
|
|
591 |
||
592 |
if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) { |
|
593 |
s->me.qpel_put = s->qdsp.put_qpel_pixels_tab; |
|
594 |
s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab; |
|
595 |
} else { |
|
596 |
s->me.qpel_put = s->qdsp.put_no_rnd_qpel_pixels_tab; |
|
597 |
s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab; |
|
598 |
}
|
|
599 |
||
600 |
if ((ret = ff_mpv_frame_start(s, avctx)) < 0) |
|
601 |
return ret; |
|
602 |
||
603 |
if (!s->divx_packed && !avctx->hwaccel) |
|
604 |
ff_thread_finish_setup(avctx); |
|
605 |
||
606 |
if (CONFIG_MPEG4_VDPAU_DECODER && (s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)) { |
|
607 |
ff_vdpau_mpeg4_decode_picture(avctx->priv_data, s->gb.buffer, s->gb.buffer_end - s->gb.buffer); |
|
608 |
goto frame_end; |
|
609 |
}
|
|
610 |
||
611 |
if (avctx->hwaccel) { |
|
612 |
ret = avctx->hwaccel->start_frame(avctx, s->gb.buffer, |
|
613 |
s->gb.buffer_end - s->gb.buffer); |
|
614 |
if (ret < 0 ) |
|
615 |
return ret; |
|
616 |
}
|
|
617 |
||
618 |
ff_mpeg_er_frame_start(s); |
|
619 |
||
620 |
/* the second part of the wmv2 header contains the MB skip bits which
|
|
621 |
* are stored in current_picture->mb_type which is not available before
|
|
622 |
* ff_mpv_frame_start() */
|
|
623 |
if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) { |
|
624 |
ret = ff_wmv2_decode_secondary_picture_header(s); |
|
625 |
if (ret < 0) |
|
626 |
return ret; |
|
627 |
if (ret == 1) |
|
628 |
goto frame_end; |
|
629 |
}
|
|
630 |
||
631 |
/* decode each macroblock */
|
|
632 |
s->mb_x = 0; |
|
633 |
s->mb_y = 0; |
|
634 |
||
635 |
slice_ret = decode_slice(s); |
|
636 |
while (s->mb_y < s->mb_height) { |
|
637 |
if (s->msmpeg4_version) { |
|
638 |
if (s->slice_height == 0 || s->mb_x != 0 || |
|
639 |
(s->mb_y % s->slice_height) != 0 || get_bits_left(&s->gb) < 0) |
|
640 |
break; |
|
641 |
} else { |
|
642 |
int prev_x = s->mb_x, prev_y = s->mb_y; |
|
643 |
if (ff_h263_resync(s) < 0) |
|
644 |
break; |
|
645 |
if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x) |
|
646 |
s->er.error_occurred = 1; |
|
647 |
}
|
|
648 |
||
649 |
if (s->msmpeg4_version < 4 && s->h263_pred) |
|
650 |
ff_mpeg4_clean_buffers(s); |
|
651 |
||
652 |
if (decode_slice(s) < 0) |
|
653 |
slice_ret = AVERROR_INVALIDDATA; |
|
654 |
}
|
|
655 |
||
656 |
if (s->msmpeg4_version && s->msmpeg4_version < 4 && |
|
657 |
s->pict_type == AV_PICTURE_TYPE_I) |
|
658 |
if (!CONFIG_MSMPEG4_DECODER || |
|
659 |
ff_msmpeg4_decode_ext_header(s, buf_size) < 0) |
|
660 |
s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR; |
|
661 |
||
662 |
av_assert1(s->bitstream_buffer_size == 0); |
|
663 |
frame_end: |
|
664 |
ff_er_frame_end(&s->er); |
|
665 |
||
666 |
if (avctx->hwaccel) { |
|
667 |
ret = avctx->hwaccel->end_frame(avctx); |
|
668 |
if (ret < 0) |
|
669 |
return ret; |
|
670 |
}
|
|
671 |
||
672 |
ff_mpv_frame_end(s); |
|
673 |
||
674 |
if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) |
|
675 |
ff_mpeg4_frame_end(avctx, buf, buf_size); |
|
676 |
||
677 |
if (!s->divx_packed && avctx->hwaccel) |
|
678 |
ff_thread_finish_setup(avctx); |
|
679 |
||
680 |
av_assert1(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type); |
|
681 |
av_assert1(s->current_picture.f->pict_type == s->pict_type); |
|
682 |
if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { |
|
683 |
if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0) |
|
684 |
return ret; |
|
685 |
ff_print_debug_info(s, s->current_picture_ptr, pict); |
|
686 |
ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1); |
|
687 |
} else if (s->last_picture_ptr) { |
|
688 |
if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0) |
|
689 |
return ret; |
|
690 |
ff_print_debug_info(s, s->last_picture_ptr, pict); |
|
691 |
ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1); |
|
692 |
}
|
|
693 |
||
694 |
if (s->last_picture_ptr || s->low_delay) { |
|
695 |
if ( pict->format == AV_PIX_FMT_YUV420P |
|
696 |
&& (s->codec_tag == AV_RL32("GEOV") || s->codec_tag == AV_RL32("GEOX"))) { |
|
697 |
int x, y, p; |
|
698 |
av_frame_make_writable(pict); |
|
699 |
for (p=0; p<3; p++) { |
|
700 |
int w = FF_CEIL_RSHIFT(pict-> width, !!p); |
|
701 |
int h = FF_CEIL_RSHIFT(pict->height, !!p); |
|
702 |
int linesize = pict->linesize[p]; |
|
703 |
for (y=0; y<(h>>1); y++) |
|
704 |
for (x=0; x<w; x++) |
|
705 |
FFSWAP(int, |
|
706 |
pict->data[p][x + y*linesize], |
|
707 |
pict->data[p][x + (h-1-y)*linesize]); |
|
708 |
}
|
|
709 |
}
|
|
710 |
*got_frame = 1; |
|
711 |
}
|
|
712 |
||
713 |
if (slice_ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) |
|
714 |
return ret; |
|
715 |
else
|
|
716 |
return get_consumed_bytes(s, buf_size); |
|
717 |
}
|
|
718 |
||
719 |
const enum AVPixelFormat ff_h263_hwaccel_pixfmt_list_420[] = { |
|
720 |
#if CONFIG_H263_VAAPI_HWACCEL || CONFIG_MPEG4_VAAPI_HWACCEL
|
|
721 |
AV_PIX_FMT_VAAPI_VLD, |
|
722 |
#endif
|
|
723 |
#if CONFIG_H263_VDPAU_HWACCEL || CONFIG_MPEG4_VDPAU_HWACCEL
|
|
724 |
AV_PIX_FMT_VDPAU, |
|
725 |
#endif
|
|
726 |
AV_PIX_FMT_YUV420P, |
|
727 |
AV_PIX_FMT_NONE
|
|
728 |
};
|
|
729 |
||
730 |
AVCodec ff_h263_decoder = { |
|
731 |
.name = "h263", |
|
732 |
.long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"), |
|
733 |
.type = AVMEDIA_TYPE_VIDEO, |
|
734 |
.id = AV_CODEC_ID_H263, |
|
735 |
.priv_data_size = sizeof(MpegEncContext), |
|
736 |
.init = ff_h263_decode_init, |
|
737 |
.close = ff_h263_decode_end, |
|
738 |
.decode = ff_h263_decode_frame, |
|
739 |
.capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | |
|
740 |
CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
|
741 |
.flush = ff_mpeg_flush, |
|
742 |
.max_lowres = 3, |
|
743 |
.pix_fmts = ff_h263_hwaccel_pixfmt_list_420, |
|
744 |
};
|
|
745 |
||
746 |
AVCodec ff_h263p_decoder = { |
|
747 |
.name = "h263p", |
|
748 |
.long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"), |
|
749 |
.type = AVMEDIA_TYPE_VIDEO, |
|
750 |
.id = AV_CODEC_ID_H263P, |
|
751 |
.priv_data_size = sizeof(MpegEncContext), |
|
752 |
.init = ff_h263_decode_init, |
|
753 |
.close = ff_h263_decode_end, |
|
754 |
.decode = ff_h263_decode_frame, |
|
755 |
.capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | |
|
756 |
CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
|
757 |
.flush = ff_mpeg_flush, |
|
758 |
.max_lowres = 3, |
|
759 |
.pix_fmts = ff_h263_hwaccel_pixfmt_list_420, |
|
760 |
};
|