ffmpeg / libavcodec / h263dec.c @ 8ed2ae09
History | View | Annotate | Download (24.7 KB)
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 Libav.
|
7 |
*
|
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.
|
12 |
*
|
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.
|
17 |
*
|
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
|
21 |
*/
|
22 |
|
23 |
/**
|
24 |
* @file
|
25 |
* H.263 decoder.
|
26 |
*/
|
27 |
|
28 |
#include "libavutil/cpu.h" |
29 |
#include "internal.h" |
30 |
#include "avcodec.h" |
31 |
#include "dsputil.h" |
32 |
#include "mpegvideo.h" |
33 |
#include "h263.h" |
34 |
#include "h263_parser.h" |
35 |
#include "mpeg4video_parser.h" |
36 |
#include "msmpeg4.h" |
37 |
#include "vdpau_internal.h" |
38 |
#include "flv.h" |
39 |
#include "mpeg4video.h" |
40 |
|
41 |
//#define DEBUG
|
42 |
//#define PRINT_FRAME_TIME
|
43 |
|
44 |
av_cold int ff_h263_decode_init(AVCodecContext *avctx)
|
45 |
{ |
46 |
MpegEncContext *s = avctx->priv_data; |
47 |
|
48 |
s->avctx = avctx; |
49 |
s->out_format = FMT_H263; |
50 |
|
51 |
s->width = avctx->coded_width; |
52 |
s->height = avctx->coded_height; |
53 |
s->workaround_bugs= avctx->workaround_bugs; |
54 |
|
55 |
// set defaults
|
56 |
MPV_decode_defaults(s); |
57 |
s->quant_precision=5;
|
58 |
s->decode_mb= ff_h263_decode_mb; |
59 |
s->low_delay= 1;
|
60 |
avctx->pix_fmt= avctx->get_format(avctx, avctx->codec->pix_fmts); |
61 |
s->unrestricted_mv= 1;
|
62 |
|
63 |
/* select sub codec */
|
64 |
switch(avctx->codec->id) {
|
65 |
case CODEC_ID_H263:
|
66 |
s->unrestricted_mv= 0;
|
67 |
avctx->chroma_sample_location = AVCHROMA_LOC_CENTER; |
68 |
break;
|
69 |
case CODEC_ID_MPEG4:
|
70 |
break;
|
71 |
case CODEC_ID_MSMPEG4V1:
|
72 |
s->h263_msmpeg4 = 1;
|
73 |
s->h263_pred = 1;
|
74 |
s->msmpeg4_version=1;
|
75 |
break;
|
76 |
case CODEC_ID_MSMPEG4V2:
|
77 |
s->h263_msmpeg4 = 1;
|
78 |
s->h263_pred = 1;
|
79 |
s->msmpeg4_version=2;
|
80 |
break;
|
81 |
case CODEC_ID_MSMPEG4V3:
|
82 |
s->h263_msmpeg4 = 1;
|
83 |
s->h263_pred = 1;
|
84 |
s->msmpeg4_version=3;
|
85 |
break;
|
86 |
case CODEC_ID_WMV1:
|
87 |
s->h263_msmpeg4 = 1;
|
88 |
s->h263_pred = 1;
|
89 |
s->msmpeg4_version=4;
|
90 |
break;
|
91 |
case CODEC_ID_WMV2:
|
92 |
s->h263_msmpeg4 = 1;
|
93 |
s->h263_pred = 1;
|
94 |
s->msmpeg4_version=5;
|
95 |
break;
|
96 |
case CODEC_ID_VC1:
|
97 |
case CODEC_ID_WMV3:
|
98 |
s->h263_msmpeg4 = 1;
|
99 |
s->h263_pred = 1;
|
100 |
s->msmpeg4_version=6;
|
101 |
avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; |
102 |
break;
|
103 |
case CODEC_ID_H263I:
|
104 |
break;
|
105 |
case CODEC_ID_FLV1:
|
106 |
s->h263_flv = 1;
|
107 |
break;
|
108 |
default:
|
109 |
return -1; |
110 |
} |
111 |
s->codec_id= avctx->codec->id; |
112 |
avctx->hwaccel= ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt); |
113 |
|
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) |
117 |
return -1; |
118 |
|
119 |
h263_decode_init_vlc(s); |
120 |
|
121 |
return 0; |
122 |
} |
123 |
|
124 |
av_cold int ff_h263_decode_end(AVCodecContext *avctx)
|
125 |
{ |
126 |
MpegEncContext *s = avctx->priv_data; |
127 |
|
128 |
MPV_common_end(s); |
129 |
return 0; |
130 |
} |
131 |
|
132 |
/**
|
133 |
* returns the number of bytes consumed for building the current frame
|
134 |
*/
|
135 |
static int get_consumed_bytes(MpegEncContext *s, int buf_size){ |
136 |
int pos= (get_bits_count(&s->gb)+7)>>3; |
137 |
|
138 |
if(s->divx_packed || s->avctx->hwaccel){
|
139 |
//we would have to scan through the whole buf to handle the weird reordering ...
|
140 |
return buf_size;
|
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 |
144 |
return pos;
|
145 |
}else{
|
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 ;) |
148 |
|
149 |
return pos;
|
150 |
} |
151 |
} |
152 |
|
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;
|
158 |
|
159 |
s->resync_mb_x= s->mb_x; |
160 |
s->resync_mb_y= s->mb_y; |
161 |
|
162 |
ff_set_qscale(s, s->qscale); |
163 |
|
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);
|
169 |
} |
170 |
|
171 |
if(s->partitioned_frame){
|
172 |
const int qscale= s->qscale; |
173 |
|
174 |
if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){
|
175 |
if(ff_mpeg4_decode_partitions(s) < 0) |
176 |
return -1; |
177 |
} |
178 |
|
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); |
184 |
} |
185 |
|
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);
|
191 |
|
192 |
return 0; |
193 |
} |
194 |
} |
195 |
|
196 |
if(s->msmpeg4_version==1){ |
197 |
s->last_dc[0]=
|
198 |
s->last_dc[1]=
|
199 |
s->last_dc[2]= 128; |
200 |
} |
201 |
|
202 |
ff_init_block_index(s); |
203 |
for(; s->mb_x < s->mb_width; s->mb_x++) {
|
204 |
int ret;
|
205 |
|
206 |
ff_update_block_index(s); |
207 |
|
208 |
if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){ |
209 |
s->first_slice_line=0;
|
210 |
} |
211 |
|
212 |
/* DCT & quantize */
|
213 |
|
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); |
219 |
|
220 |
if (s->pict_type!=FF_B_TYPE)
|
221 |
ff_h263_update_motion_val(s); |
222 |
|
223 |
if(ret<0){ |
224 |
const int xy= s->mb_x + s->mb_y*s->mb_stride; |
225 |
if(ret==SLICE_END){
|
226 |
MPV_decode_mb(s, s->block); |
227 |
if(s->loop_filter)
|
228 |
ff_h263_loop_filter(s); |
229 |
|
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); |
232 |
|
233 |
s->padding_bug_score--; |
234 |
|
235 |
if(++s->mb_x >= s->mb_width){
|
236 |
s->mb_x=0;
|
237 |
ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size); |
238 |
s->mb_y++; |
239 |
} |
240 |
return 0; |
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);
|
244 |
return -1; |
245 |
} |
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); |
248 |
|
249 |
return -1; |
250 |
} |
251 |
|
252 |
MPV_decode_mb(s, s->block); |
253 |
if(s->loop_filter)
|
254 |
ff_h263_loop_filter(s); |
255 |
} |
256 |
|
257 |
ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size); |
258 |
|
259 |
s->mb_x= 0;
|
260 |
} |
261 |
|
262 |
assert(s->mb_x==0 && s->mb_y==s->mb_height);
|
263 |
|
264 |
if(s->codec_id==CODEC_ID_MPEG4
|
265 |
&& (s->workaround_bugs&FF_BUG_AUTODETECT) |
266 |
&& get_bits_left(&s->gb) >= 48
|
267 |
&& show_bits(&s->gb, 24)==0x4010 |
268 |
&& !s->data_partitioning) |
269 |
s->padding_bug_score+=32;
|
270 |
|
271 |
/* try to detect the padding bug */
|
272 |
if( s->codec_id==CODEC_ID_MPEG4
|
273 |
&& (s->workaround_bugs&FF_BUG_AUTODETECT) |
274 |
&& get_bits_left(&s->gb) >=0
|
275 |
&& get_bits_left(&s->gb) < 48
|
276 |
// && !s->resync_marker
|
277 |
&& !s->data_partitioning){ |
278 |
|
279 |
const int bits_count= get_bits_count(&s->gb); |
280 |
const int bits_left = s->gb.size_in_bits - bits_count; |
281 |
|
282 |
if(bits_left==0){ |
283 |
s->padding_bug_score+=16;
|
284 |
} else if(bits_left != 1){ |
285 |
int v= show_bits(&s->gb, 8); |
286 |
v|= 0x7F >> (7-(bits_count&7)); |
287 |
|
288 |
if(v==0x7F && bits_left<=8) |
289 |
s->padding_bug_score--; |
290 |
else if(v==0x7F && ((get_bits_count(&s->gb)+8)&8) && bits_left<=16) |
291 |
s->padding_bug_score+= 4;
|
292 |
else
|
293 |
s->padding_bug_score++; |
294 |
} |
295 |
} |
296 |
|
297 |
if(s->workaround_bugs&FF_BUG_AUTODETECT){
|
298 |
if(s->padding_bug_score > -2 && !s->data_partitioning /*&& (s->divx_version>=0 || !s->resync_marker)*/) |
299 |
s->workaround_bugs |= FF_BUG_NO_PADDING; |
300 |
else
|
301 |
s->workaround_bugs &= ~FF_BUG_NO_PADDING; |
302 |
} |
303 |
|
304 |
// handle formats which don't have unique end markers
|
305 |
if(s->msmpeg4_version || (s->workaround_bugs&FF_BUG_NO_PADDING)){ //FIXME perhaps solve this more cleanly |
306 |
int left= get_bits_left(&s->gb);
|
307 |
int max_extra=7; |
308 |
|
309 |
/* no markers in M$ crap */
|
310 |
if(s->msmpeg4_version && s->pict_type==FF_I_TYPE)
|
311 |
max_extra+= 17;
|
312 |
|
313 |
/* buggy padding but the frame should still end approximately at the bitstream end */
|
314 |
if((s->workaround_bugs&FF_BUG_NO_PADDING) && s->error_recognition>=3) |
315 |
max_extra+= 48;
|
316 |
else if((s->workaround_bugs&FF_BUG_NO_PADDING)) |
317 |
max_extra+= 256*256*256*64; |
318 |
|
319 |
if(left>max_extra){
|
320 |
av_log(s->avctx, AV_LOG_ERROR, "discarding %d junk bits at end, next would be %X\n", left, show_bits(&s->gb, 24)); |
321 |
} |
322 |
else if(left<0){ |
323 |
av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);
|
324 |
}else
|
325 |
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 |
|
327 |
return 0; |
328 |
} |
329 |
|
330 |
av_log(s->avctx, AV_LOG_ERROR, "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
|
331 |
get_bits_left(&s->gb), |
332 |
show_bits(&s->gb, 24), s->padding_bug_score);
|
333 |
|
334 |
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 |
|
336 |
return -1; |
337 |
} |
338 |
|
339 |
int ff_h263_decode_frame(AVCodecContext *avctx,
|
340 |
void *data, int *data_size, |
341 |
AVPacket *avpkt) |
342 |
{ |
343 |
const uint8_t *buf = avpkt->data;
|
344 |
int buf_size = avpkt->size;
|
345 |
MpegEncContext *s = avctx->priv_data; |
346 |
int ret;
|
347 |
AVFrame *pict = data; |
348 |
|
349 |
#ifdef PRINT_FRAME_TIME
|
350 |
uint64_t time= rdtsc(); |
351 |
#endif
|
352 |
s->flags= avctx->flags; |
353 |
s->flags2= avctx->flags2; |
354 |
|
355 |
/* no supplementary picture */
|
356 |
if (buf_size == 0) { |
357 |
/* special case for last picture */
|
358 |
if (s->low_delay==0 && s->next_picture_ptr) { |
359 |
*pict= *(AVFrame*)s->next_picture_ptr; |
360 |
s->next_picture_ptr= NULL;
|
361 |
|
362 |
*data_size = sizeof(AVFrame);
|
363 |
} |
364 |
|
365 |
return 0; |
366 |
} |
367 |
|
368 |
if(s->flags&CODEC_FLAG_TRUNCATED){
|
369 |
int next;
|
370 |
|
371 |
if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){
|
372 |
next= ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size); |
373 |
}else if(CONFIG_H263_DECODER && s->codec_id==CODEC_ID_H263){ |
374 |
next= ff_h263_find_frame_end(&s->parse_context, buf, buf_size); |
375 |
}else{
|
376 |
av_log(s->avctx, AV_LOG_ERROR, "this codec does not support truncated bitstreams\n");
|
377 |
return -1; |
378 |
} |
379 |
|
380 |
if( ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 ) |
381 |
return buf_size;
|
382 |
} |
383 |
|
384 |
|
385 |
retry:
|
386 |
|
387 |
if(s->bitstream_buffer_size && (s->divx_packed || buf_size<20)){ //divx 5.01+/xvid frame reorder |
388 |
init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8);
|
389 |
}else
|
390 |
init_get_bits(&s->gb, buf, buf_size*8);
|
391 |
s->bitstream_buffer_size=0;
|
392 |
|
393 |
if (!s->context_initialized) {
|
394 |
if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix |
395 |
return -1; |
396 |
} |
397 |
|
398 |
/* We need to set current_picture_ptr before reading the header,
|
399 |
* otherwise we cannot store anyting in there */
|
400 |
if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){ |
401 |
int i= ff_find_unused_picture(s, 0); |
402 |
s->current_picture_ptr= &s->picture[i]; |
403 |
} |
404 |
|
405 |
/* let's go :-) */
|
406 |
if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5) { |
407 |
ret= ff_wmv2_decode_picture_header(s); |
408 |
} else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) { |
409 |
ret = msmpeg4_decode_picture_header(s); |
410 |
} else if (CONFIG_MPEG4_DECODER && s->h263_pred) { |
411 |
if(s->avctx->extradata_size && s->picture_number==0){ |
412 |
GetBitContext gb; |
413 |
|
414 |
init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8);
|
415 |
ret = ff_mpeg4_decode_picture_header(s, &gb); |
416 |
} |
417 |
ret = ff_mpeg4_decode_picture_header(s, &s->gb); |
418 |
} else if (CONFIG_H263I_DECODER && s->codec_id == CODEC_ID_H263I) { |
419 |
ret = ff_intel_h263_decode_picture_header(s); |
420 |
} else if (CONFIG_FLV_DECODER && s->h263_flv) { |
421 |
ret = ff_flv_decode_picture_header(s); |
422 |
} else {
|
423 |
ret = h263_decode_picture_header(s); |
424 |
} |
425 |
|
426 |
if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_size); |
427 |
|
428 |
/* skip if the header was thrashed */
|
429 |
if (ret < 0){ |
430 |
av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
|
431 |
return -1; |
432 |
} |
433 |
|
434 |
avctx->has_b_frames= !s->low_delay; |
435 |
|
436 |
if(s->xvid_build==-1 && s->divx_version==-1 && s->lavc_build==-1){ |
437 |
if(s->stream_codec_tag == AV_RL32("XVID") || |
438 |
s->codec_tag == AV_RL32("XVID") || s->codec_tag == AV_RL32("XVIX") || |
439 |
s->codec_tag == AV_RL32("RMP4") ||
|
440 |
s->codec_tag == AV_RL32("SIPP")
|
441 |
) |
442 |
s->xvid_build= 0;
|
443 |
#if 0
|
444 |
if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==1
|
445 |
&& s->padding_bug_score > 0 && s->low_delay) // XVID with modified fourcc
|
446 |
s->xvid_build= 0;
|
447 |
#endif
|
448 |
} |
449 |
|
450 |
if(s->xvid_build==-1 && s->divx_version==-1 && s->lavc_build==-1){ |
451 |
if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==0) |
452 |
s->divx_version= 400; //divx 4 |
453 |
} |
454 |
|
455 |
if(s->xvid_build>=0 && s->divx_version>=0){ |
456 |
s->divx_version= |
457 |
s->divx_build= -1;
|
458 |
} |
459 |
|
460 |
if(s->workaround_bugs&FF_BUG_AUTODETECT){
|
461 |
if(s->codec_tag == AV_RL32("XVIX")) |
462 |
s->workaround_bugs|= FF_BUG_XVID_ILACE; |
463 |
|
464 |
if(s->codec_tag == AV_RL32("UMP4")){ |
465 |
s->workaround_bugs|= FF_BUG_UMP4; |
466 |
} |
467 |
|
468 |
if(s->divx_version>=500 && s->divx_build<1814){ |
469 |
s->workaround_bugs|= FF_BUG_QPEL_CHROMA; |
470 |
} |
471 |
|
472 |
if(s->divx_version>502 && s->divx_build<1814){ |
473 |
s->workaround_bugs|= FF_BUG_QPEL_CHROMA2; |
474 |
} |
475 |
|
476 |
if(s->xvid_build<=3U) |
477 |
s->padding_bug_score= 256*256*256*64; |
478 |
|
479 |
if(s->xvid_build<=1U) |
480 |
s->workaround_bugs|= FF_BUG_QPEL_CHROMA; |
481 |
|
482 |
if(s->xvid_build<=12U) |
483 |
s->workaround_bugs|= FF_BUG_EDGE; |
484 |
|
485 |
if(s->xvid_build<=32U) |
486 |
s->workaround_bugs|= FF_BUG_DC_CLIP; |
487 |
|
488 |
#define SET_QPEL_FUNC(postfix1, postfix2) \
|
489 |
s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\ |
490 |
s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\ |
491 |
s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2; |
492 |
|
493 |
if(s->lavc_build<4653U) |
494 |
s->workaround_bugs|= FF_BUG_STD_QPEL; |
495 |
|
496 |
if(s->lavc_build<4655U) |
497 |
s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE; |
498 |
|
499 |
if(s->lavc_build<4670U){ |
500 |
s->workaround_bugs|= FF_BUG_EDGE; |
501 |
} |
502 |
|
503 |
if(s->lavc_build<=4712U) |
504 |
s->workaround_bugs|= FF_BUG_DC_CLIP; |
505 |
|
506 |
if(s->divx_version>=0) |
507 |
s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE; |
508 |
//printf("padding_bug_score: %d\n", s->padding_bug_score);
|
509 |
if(s->divx_version==501 && s->divx_build==20020416) |
510 |
s->padding_bug_score= 256*256*256*64; |
511 |
|
512 |
if(s->divx_version<500U){ |
513 |
s->workaround_bugs|= FF_BUG_EDGE; |
514 |
} |
515 |
|
516 |
if(s->divx_version>=0) |
517 |
s->workaround_bugs|= FF_BUG_HPEL_CHROMA; |
518 |
#if 0
|
519 |
if(s->divx_version==500)
|
520 |
s->padding_bug_score= 256*256*256*64;
|
521 |
|
522 |
/* very ugly XVID padding bug detection FIXME/XXX solve this differently
|
523 |
* Let us hope this at least works.
|
524 |
*/
|
525 |
if( s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==-1
|
526 |
&& s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)
|
527 |
s->workaround_bugs|= FF_BUG_NO_PADDING;
|
528 |
|
529 |
if(s->lavc_build<4609U) //FIXME not sure about the version num but a 4609 file seems ok
|
530 |
s->workaround_bugs|= FF_BUG_NO_PADDING;
|
531 |
#endif
|
532 |
} |
533 |
|
534 |
if(s->workaround_bugs& FF_BUG_STD_QPEL){
|
535 |
SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c) |
536 |
SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c) |
537 |
SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c) |
538 |
SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c) |
539 |
SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c) |
540 |
SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c) |
541 |
|
542 |
SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c) |
543 |
SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c) |
544 |
SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c) |
545 |
SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c) |
546 |
SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c) |
547 |
SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c) |
548 |
} |
549 |
|
550 |
if(avctx->debug & FF_DEBUG_BUGS)
|
551 |
av_log(s->avctx, AV_LOG_DEBUG, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
|
552 |
s->workaround_bugs, s->lavc_build, s->xvid_build, s->divx_version, s->divx_build, |
553 |
s->divx_packed ? "p" : ""); |
554 |
|
555 |
#if 0 // dump bits per frame / qp / complexity
|
556 |
{
|
557 |
static FILE *f=NULL;
|
558 |
if(!f) f=fopen("rate_qp_cplx.txt", "w");
|
559 |
fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale);
|
560 |
}
|
561 |
#endif
|
562 |
|
563 |
#if HAVE_MMX
|
564 |
if (s->codec_id == CODEC_ID_MPEG4 && s->xvid_build>=0 && avctx->idct_algo == FF_IDCT_AUTO && (av_get_cpu_flags() & AV_CPU_FLAG_MMX)) { |
565 |
avctx->idct_algo= FF_IDCT_XVIDMMX; |
566 |
avctx->coded_width= 0; // force reinit |
567 |
// dsputil_init(&s->dsp, avctx);
|
568 |
s->picture_number=0;
|
569 |
} |
570 |
#endif
|
571 |
|
572 |
/* After H263 & mpeg4 header decode we have the height, width,*/
|
573 |
/* and other parameters. So then we could init the picture */
|
574 |
/* FIXME: By the way H263 decoder is evolving it should have */
|
575 |
/* an H263EncContext */
|
576 |
|
577 |
if ( s->width != avctx->coded_width
|
578 |
|| s->height != avctx->coded_height) { |
579 |
/* H.263 could change picture size any time */
|
580 |
ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat
|
581 |
s->parse_context.buffer=0;
|
582 |
MPV_common_end(s); |
583 |
s->parse_context= pc; |
584 |
} |
585 |
if (!s->context_initialized) {
|
586 |
avcodec_set_dimensions(avctx, s->width, s->height); |
587 |
|
588 |
goto retry;
|
589 |
} |
590 |
|
591 |
if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P || s->codec_id == CODEC_ID_H263I))
|
592 |
s->gob_index = ff_h263_get_gob_height(s); |
593 |
|
594 |
// for skipping the frame
|
595 |
s->current_picture.pict_type= s->pict_type; |
596 |
s->current_picture.key_frame= s->pict_type == FF_I_TYPE; |
597 |
|
598 |
/* skip B-frames if we don't have reference frames */
|
599 |
if(s->last_picture_ptr==NULL && (s->pict_type==FF_B_TYPE || s->dropable)) return get_consumed_bytes(s, buf_size); |
600 |
#if FF_API_HURRY_UP
|
601 |
/* skip b frames if we are in a hurry */
|
602 |
if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return get_consumed_bytes(s, buf_size); |
603 |
#endif
|
604 |
if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
|
605 |
|| (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE) |
606 |
|| avctx->skip_frame >= AVDISCARD_ALL) |
607 |
return get_consumed_bytes(s, buf_size);
|
608 |
#if FF_API_HURRY_UP
|
609 |
/* skip everything if we are in a hurry>=5 */
|
610 |
if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size); |
611 |
#endif
|
612 |
|
613 |
if(s->next_p_frame_damaged){
|
614 |
if(s->pict_type==FF_B_TYPE)
|
615 |
return get_consumed_bytes(s, buf_size);
|
616 |
else
|
617 |
s->next_p_frame_damaged=0;
|
618 |
} |
619 |
|
620 |
if((s->avctx->flags2 & CODEC_FLAG2_FAST) && s->pict_type==FF_B_TYPE){
|
621 |
s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab; |
622 |
s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab; |
623 |
}else if((!s->no_rounding) || s->pict_type==FF_B_TYPE){ |
624 |
s->me.qpel_put= s->dsp.put_qpel_pixels_tab; |
625 |
s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab; |
626 |
}else{
|
627 |
s->me.qpel_put= s->dsp.put_no_rnd_qpel_pixels_tab; |
628 |
s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab; |
629 |
} |
630 |
|
631 |
if(MPV_frame_start(s, avctx) < 0) |
632 |
return -1; |
633 |
|
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); |
636 |
goto frame_end;
|
637 |
} |
638 |
|
639 |
if (avctx->hwaccel) {
|
640 |
if (avctx->hwaccel->start_frame(avctx, s->gb.buffer, s->gb.buffer_end - s->gb.buffer) < 0) |
641 |
return -1; |
642 |
} |
643 |
|
644 |
ff_er_frame_start(s); |
645 |
|
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 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; |
652 |
} |
653 |
|
654 |
/* decode each macroblock */
|
655 |
s->mb_x=0;
|
656 |
s->mb_y=0;
|
657 |
|
658 |
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_count(&s->gb) > s->gb.size_in_bits) |
662 |
break;
|
663 |
}else{
|
664 |
if(ff_h263_resync(s)<0) |
665 |
break;
|
666 |
} |
667 |
|
668 |
if(s->msmpeg4_version<4 && s->h263_pred) |
669 |
ff_mpeg4_clean_buffers(s); |
670 |
|
671 |
decode_slice(s); |
672 |
} |
673 |
|
674 |
if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==FF_I_TYPE) |
675 |
if(!CONFIG_MSMPEG4_DECODER || msmpeg4_decode_ext_header(s, buf_size) < 0){ |
676 |
s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;
|
677 |
} |
678 |
|
679 |
assert(s->bitstream_buffer_size==0);
|
680 |
frame_end:
|
681 |
/* divx 5.01+ bistream reorder stuff */
|
682 |
if(s->codec_id==CODEC_ID_MPEG4 && s->divx_packed){
|
683 |
int current_pos= get_bits_count(&s->gb)>>3; |
684 |
int startcode_found=0; |
685 |
|
686 |
if(buf_size - current_pos > 5){ |
687 |
int i;
|
688 |
for(i=current_pos; i<buf_size-3; i++){ |
689 |
if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){ |
690 |
startcode_found=1;
|
691 |
break;
|
692 |
} |
693 |
} |
694 |
} |
695 |
if(s->gb.buffer == s->bitstream_buffer && buf_size>7 && s->xvid_build>=0){ //xvid style |
696 |
startcode_found=1;
|
697 |
current_pos=0;
|
698 |
} |
699 |
|
700 |
if(startcode_found){
|
701 |
av_fast_malloc( |
702 |
&s->bitstream_buffer, |
703 |
&s->allocated_bitstream_buffer_size, |
704 |
buf_size - current_pos + FF_INPUT_BUFFER_PADDING_SIZE); |
705 |
if (!s->bitstream_buffer)
|
706 |
return AVERROR(ENOMEM);
|
707 |
memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos); |
708 |
s->bitstream_buffer_size= buf_size - current_pos; |
709 |
} |
710 |
} |
711 |
|
712 |
intrax8_decoded:
|
713 |
ff_er_frame_end(s); |
714 |
|
715 |
if (avctx->hwaccel) {
|
716 |
if (avctx->hwaccel->end_frame(avctx) < 0) |
717 |
return -1; |
718 |
} |
719 |
|
720 |
MPV_frame_end(s); |
721 |
|
722 |
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type); |
723 |
assert(s->current_picture.pict_type == s->pict_type); |
724 |
if (s->pict_type == FF_B_TYPE || s->low_delay) {
|
725 |
*pict= *(AVFrame*)s->current_picture_ptr; |
726 |
} else if (s->last_picture_ptr != NULL) { |
727 |
*pict= *(AVFrame*)s->last_picture_ptr; |
728 |
} |
729 |
|
730 |
if(s->last_picture_ptr || s->low_delay){
|
731 |
*data_size = sizeof(AVFrame);
|
732 |
ff_print_debug_info(s, pict); |
733 |
} |
734 |
|
735 |
#ifdef PRINT_FRAME_TIME
|
736 |
av_log(avctx, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time); |
737 |
#endif
|
738 |
|
739 |
return get_consumed_bytes(s, buf_size);
|
740 |
} |
741 |
|
742 |
AVCodec ff_h263_decoder = { |
743 |
"h263",
|
744 |
AVMEDIA_TYPE_VIDEO, |
745 |
CODEC_ID_H263, |
746 |
sizeof(MpegEncContext),
|
747 |
ff_h263_decode_init, |
748 |
NULL,
|
749 |
ff_h263_decode_end, |
750 |
ff_h263_decode_frame, |
751 |
CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
752 |
.flush= ff_mpeg_flush, |
753 |
.max_lowres= 3,
|
754 |
.long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
|
755 |
.pix_fmts= ff_hwaccel_pixfmt_list_420, |
756 |
}; |