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