Mercurial > libavcodec.hg
annotate h263dec.c @ 2497:69adfbbdcdeb libavcodec
- samples from mplayer ftp in the "adv" profile seem to have profile=2,
which isn't the advanced one; and indeed, using adv. profile parser fails.
Using normal parser works, and that's what is done
- attempt at taking care of stride for NORM2 bitplane decoding
- duplication of much code from msmpeg4.c; this code isn't yet used, but
goes down as far as the block layer (mainly Transform Type stuff, the
remains are wild editing without checking). Unusable yet, and lacks the AC
decoding (but a step further in bitstream parsing)
patch by anonymous
author | michael |
---|---|
date | Fri, 04 Feb 2005 02:20:38 +0000 |
parents | 81a9f883a17a |
children | 9a7770ebed14 |
rev | line source |
---|---|
0 | 1 /* |
1106 | 2 * H.263 decoder |
429 | 3 * Copyright (c) 2001 Fabrice Bellard. |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1706
diff
changeset
|
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 5 * |
429 | 6 * This library is free software; you can redistribute it and/or |
7 * modify it under the terms of the GNU Lesser General Public | |
8 * License as published by the Free Software Foundation; either | |
9 * version 2 of the License, or (at your option) any later version. | |
0 | 10 * |
429 | 11 * This library is distributed in the hope that it will be useful, |
0 | 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 * Lesser General Public License for more details. | |
0 | 15 * |
429 | 16 * You should have received a copy of the GNU Lesser General Public |
17 * License along with this library; if not, write to the Free Software | |
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
0 | 19 */ |
1106 | 20 |
21 /** | |
22 * @file h263dec.c | |
23 * H.263 decoder. | |
24 */ | |
25 | |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
384
diff
changeset
|
26 #include "avcodec.h" |
0 | 27 #include "dsputil.h" |
28 #include "mpegvideo.h" | |
29 | |
30 //#define DEBUG | |
384 | 31 //#define PRINT_FRAME_TIME |
0 | 32 |
936 | 33 int ff_h263_decode_init(AVCodecContext *avctx) |
0 | 34 { |
35 MpegEncContext *s = avctx->priv_data; | |
60 | 36 |
67 | 37 s->avctx = avctx; |
0 | 38 s->out_format = FMT_H263; |
39 | |
2270 | 40 s->width = avctx->coded_width; |
41 s->height = avctx->coded_height; | |
411
5c8b3a717929
workaround dc_scale bug in old ffmpeg msmpeg4v3 encoder (set workaround_bugs=1 for this)
michaelni
parents:
396
diff
changeset
|
42 s->workaround_bugs= avctx->workaround_bugs; |
0 | 43 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
44 // set defaults |
1892 | 45 MPV_decode_defaults(s); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
46 s->quant_precision=5; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
47 s->decode_mb= ff_h263_decode_mb; |
924 | 48 s->low_delay= 1; |
939 | 49 avctx->pix_fmt= PIX_FMT_YUV420P; |
1542
576861d6343a
emu_edge checks simplification and avoid redundant checks for mpeg1/2 if emu_edge is set
michael
parents:
1536
diff
changeset
|
50 s->unrestricted_mv= 1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
51 |
0 | 52 /* select sub codec */ |
53 switch(avctx->codec->id) { | |
54 case CODEC_ID_H263: | |
1639 | 55 s->unrestricted_mv= 0; |
0 | 56 break; |
67 | 57 case CODEC_ID_MPEG4: |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1644
diff
changeset
|
58 s->decode_mb= ff_mpeg4_decode_mb; |
0 | 59 s->time_increment_bits = 4; /* default value for broken headers */ |
60 s->h263_pred = 1; | |
924 | 61 s->low_delay = 0; //default, might be overriden in the vol header during header parsing |
0 | 62 break; |
307 | 63 case CODEC_ID_MSMPEG4V1: |
0 | 64 s->h263_msmpeg4 = 1; |
65 s->h263_pred = 1; | |
307 | 66 s->msmpeg4_version=1; |
67 break; | |
68 case CODEC_ID_MSMPEG4V2: | |
69 s->h263_msmpeg4 = 1; | |
70 s->h263_pred = 1; | |
71 s->msmpeg4_version=2; | |
72 break; | |
73 case CODEC_ID_MSMPEG4V3: | |
74 s->h263_msmpeg4 = 1; | |
75 s->h263_pred = 1; | |
76 s->msmpeg4_version=3; | |
0 | 77 break; |
311 | 78 case CODEC_ID_WMV1: |
79 s->h263_msmpeg4 = 1; | |
80 s->h263_pred = 1; | |
81 s->msmpeg4_version=4; | |
82 break; | |
498 | 83 case CODEC_ID_WMV2: |
84 s->h263_msmpeg4 = 1; | |
85 s->h263_pred = 1; | |
86 s->msmpeg4_version=5; | |
87 break; | |
2474 | 88 case CODEC_ID_WMV3: |
89 s->h263_msmpeg4 = 1; | |
90 s->h263_pred = 1; | |
91 s->msmpeg4_version=6; | |
92 break; | |
0 | 93 case CODEC_ID_H263I: |
94 break; | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
95 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
96 s->h263_flv = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
97 break; |
0 | 98 default: |
99 return -1; | |
100 } | |
344 | 101 s->codec_id= avctx->codec->id; |
553 | 102 |
0 | 103 /* for h263, we allocate the images after having read the header */ |
274
d0c186bcf075
use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents:
273
diff
changeset
|
104 if (avctx->codec->id != CODEC_ID_H263 && avctx->codec->id != CODEC_ID_MPEG4) |
144 | 105 if (MPV_common_init(s) < 0) |
106 return -1; | |
0 | 107 |
108 if (s->h263_msmpeg4) | |
498 | 109 ff_msmpeg4_decode_init(s); |
0 | 110 else |
111 h263_decode_init_vlc(s); | |
112 | |
113 return 0; | |
114 } | |
115 | |
936 | 116 int ff_h263_decode_end(AVCodecContext *avctx) |
0 | 117 { |
118 MpegEncContext *s = avctx->priv_data; | |
119 | |
120 MPV_common_end(s); | |
121 return 0; | |
122 } | |
123 | |
655 | 124 /** |
125 * retunrs the number of bytes consumed for building the current frame | |
126 */ | |
127 static int get_consumed_bytes(MpegEncContext *s, int buf_size){ | |
128 int pos= (get_bits_count(&s->gb)+7)>>3; | |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
129 |
1145
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
130 if(s->divx_packed){ |
655 | 131 //we would have to scan through the whole buf to handle the weird reordering ... |
132 return buf_size; | |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
133 }else if(s->flags&CODEC_FLAG_TRUNCATED){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
134 pos -= s->parse_context.last_index; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
135 if(pos<0) pos=0; // padding is not really read so this might be -1 |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
136 return pos; |
655 | 137 }else{ |
138 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
658 | 139 if(pos+10>buf_size) pos=buf_size; // oops ;) |
655 | 140 |
141 return pos; | |
142 } | |
143 } | |
144 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
145 static int decode_slice(MpegEncContext *s){ |
1144 | 146 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; |
2261 | 147 const int mb_size= 16>>s->avctx->lowres; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
148 s->last_resync_gb= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
149 s->first_slice_line= 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
150 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
151 s->resync_mb_x= s->mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
152 s->resync_mb_y= s->mb_y; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
153 |
1652 | 154 ff_set_qscale(s, s->qscale); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
155 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
156 if(s->partitioned_frame){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
157 const int qscale= s->qscale; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
158 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
159 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
160 if(ff_mpeg4_decode_partitions(s) < 0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
161 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
162 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
163 |
1427 | 164 /* restore variables which were modified */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
165 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
166 s->mb_x= s->resync_mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
167 s->mb_y= s->resync_mb_y; |
1652 | 168 ff_set_qscale(s, qscale); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
169 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
170 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
171 for(; s->mb_y < s->mb_height; s->mb_y++) { |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
172 /* per-row end of slice checks */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
173 if(s->msmpeg4_version){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
174 if(s->resync_mb_y + s->slice_height == s->mb_y){ |
1144 | 175 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); |
176 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
177 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
178 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
179 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
180 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
181 if(s->msmpeg4_version==1){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
182 s->last_dc[0]= |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
183 s->last_dc[1]= |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
184 s->last_dc[2]= 128; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
185 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
186 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
187 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
188 for(; s->mb_x < s->mb_width; s->mb_x++) { |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
189 int ret; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
190 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
191 ff_update_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
192 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
193 if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
194 s->first_slice_line=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
195 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
196 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
197 /* DCT & quantize */ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
845
diff
changeset
|
198 s->dsp.clear_blocks(s->block[0]); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
199 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
200 s->mv_dir = MV_DIR_FORWARD; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
201 s->mv_type = MV_TYPE_16X16; |
903 | 202 // s->mb_skiped = 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
203 //printf("%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24)); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
204 ret= s->decode_mb(s, s->block); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
205 |
1389 | 206 if (s->pict_type!=B_TYPE) |
207 ff_h263_update_motion_val(s); | |
208 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
209 if(ret<0){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1175
diff
changeset
|
210 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
211 if(ret==SLICE_END){ |
1338 | 212 MPV_decode_mb(s, s->block); |
1644 | 213 if(s->loop_filter) |
214 ff_h263_loop_filter(s); | |
1338 | 215 |
758 | 216 //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)); |
1144 | 217 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); |
750 | 218 |
219 s->padding_bug_score--; | |
220 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
221 if(++s->mb_x >= s->mb_width){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
222 s->mb_x=0; |
2261 | 223 ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
224 s->mb_y++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
225 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
226 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
227 }else if(ret==SLICE_NOEND){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
228 av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy); |
1144 | 229 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); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
230 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
231 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
232 av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy); |
1144 | 233 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); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
234 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
235 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
236 } |
1338 | 237 |
238 MPV_decode_mb(s, s->block); | |
1644 | 239 if(s->loop_filter) |
240 ff_h263_loop_filter(s); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
241 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
242 |
2261 | 243 ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
244 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
245 s->mb_x= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
246 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
247 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
248 assert(s->mb_x==0 && s->mb_y==s->mb_height); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
249 |
750 | 250 /* try to detect the padding bug */ |
251 if( s->codec_id==CODEC_ID_MPEG4 | |
252 && (s->workaround_bugs&FF_BUG_AUTODETECT) | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1004
diff
changeset
|
253 && s->gb.size_in_bits - get_bits_count(&s->gb) >=0 |
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1004
diff
changeset
|
254 && s->gb.size_in_bits - get_bits_count(&s->gb) < 48 |
928
5627a7b7ce83
fixing playback of DaveMatthews_Crash_PocketPC.avi
michaelni
parents:
925
diff
changeset
|
255 // && !s->resync_marker |
750 | 256 && !s->data_partitioning){ |
257 | |
258 const int bits_count= get_bits_count(&s->gb); | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1004
diff
changeset
|
259 const int bits_left = s->gb.size_in_bits - bits_count; |
750 | 260 |
1003 | 261 if(bits_left==0){ |
262 s->padding_bug_score+=16; | |
824 | 263 } else if(bits_left != 1){ |
750 | 264 int v= show_bits(&s->gb, 8); |
265 v|= 0x7F >> (7-(bits_count&7)); | |
824 | 266 |
2350 | 267 if(v==0x7F && bits_left<=8) |
750 | 268 s->padding_bug_score--; |
2350 | 269 else if(v==0x7F && ((get_bits_count(&s->gb)+8)&8) && bits_left<=16) |
270 s->padding_bug_score+= 4; | |
750 | 271 else |
272 s->padding_bug_score++; | |
1003 | 273 } |
750 | 274 } |
2350 | 275 |
276 if(s->workaround_bugs&FF_BUG_AUTODETECT){ | |
2411
0427eb3579b6
fix decoding of http://mplayerhq.hu/~diego/problem.mov
michael
parents:
2350
diff
changeset
|
277 if(s->padding_bug_score > -2 && !s->data_partitioning /*&& (s->divx_version || !s->resync_marker)*/) |
2350 | 278 s->workaround_bugs |= FF_BUG_NO_PADDING; |
279 else | |
280 s->workaround_bugs &= ~FF_BUG_NO_PADDING; | |
281 } | |
750 | 282 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
283 // handle formats which dont have unique end markers |
1004 | 284 if(s->msmpeg4_version || (s->workaround_bugs&FF_BUG_NO_PADDING)){ //FIXME perhaps solve this more cleanly |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1004
diff
changeset
|
285 int left= s->gb.size_in_bits - get_bits_count(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
286 int max_extra=7; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
287 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
288 /* no markers in M$ crap */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
289 if(s->msmpeg4_version && s->pict_type==I_TYPE) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
290 max_extra+= 17; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
291 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
292 /* buggy padding but the frame should still end approximately at the bitstream end */ |
1004 | 293 if((s->workaround_bugs&FF_BUG_NO_PADDING) && s->error_resilience>=3) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
294 max_extra+= 48; |
1004 | 295 else if((s->workaround_bugs&FF_BUG_NO_PADDING)) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
296 max_extra+= 256*256*256*64; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
297 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
298 if(left>max_extra){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
299 av_log(s->avctx, AV_LOG_ERROR, "discarding %d junk bits at end, next would be %X\n", left, show_bits(&s->gb, 24)); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
300 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
301 else if(left<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
302 av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
303 }else |
1144 | 304 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); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
305 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
306 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
307 } |
750 | 308 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
309 av_log(s->avctx, AV_LOG_ERROR, "slice end not reached but screenspace end (%d left %06X, score= %d)\n", |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1004
diff
changeset
|
310 s->gb.size_in_bits - get_bits_count(&s->gb), |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
311 show_bits(&s->gb, 24), s->padding_bug_score); |
1144 | 312 |
313 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); | |
314 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
315 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
316 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
317 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
318 /** |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
319 * finds the end of the current frame in the bitstream. |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
320 * @return the position of the first byte of the next frame, or -1 |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
321 */ |
1988 | 322 int ff_mpeg4_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){ |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
323 int vop_found, i; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
324 uint32_t state; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
325 |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
326 vop_found= pc->frame_start_found; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
327 state= pc->state; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
328 |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
329 i=0; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
330 if(!vop_found){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
331 for(i=0; i<buf_size; i++){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
332 state= (state<<8) | buf[i]; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
333 if(state == 0x1B6){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
334 i++; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
335 vop_found=1; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
336 break; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
337 } |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
338 } |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
339 } |
1211 | 340 |
1988 | 341 if(vop_found){ |
342 /* EOF considered as end of frame */ | |
343 if (buf_size == 0) | |
344 return 0; | |
345 for(; i<buf_size; i++){ | |
346 state= (state<<8) | buf[i]; | |
347 if((state&0xFFFFFF00) == 0x100){ | |
348 pc->frame_start_found=0; | |
349 pc->state=-1; | |
350 return i-3; | |
351 } | |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
352 } |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
353 } |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
354 pc->frame_start_found= vop_found; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
355 pc->state= state; |
1219 | 356 return END_NOT_FOUND; |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
357 } |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
358 |
1988 | 359 static int h263_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){ |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
360 int vop_found, i; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
361 uint32_t state; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
362 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
363 vop_found= pc->frame_start_found; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
364 state= pc->state; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
365 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
366 i=0; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
367 if(!vop_found){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
368 for(i=0; i<buf_size; i++){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
369 state= (state<<8) | buf[i]; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
370 if(state>>(32-22) == 0x20){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
371 i++; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
372 vop_found=1; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
373 break; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
374 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
375 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
376 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
377 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
378 if(vop_found){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
379 for(; i<buf_size; i++){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
380 state= (state<<8) | buf[i]; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
381 if(state>>(32-22) == 0x20){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
382 pc->frame_start_found=0; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
383 pc->state=-1; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
384 return i-3; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
385 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
386 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
387 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
388 pc->frame_start_found= vop_found; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
389 pc->state= state; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
390 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
391 return END_NOT_FOUND; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
392 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
393 |
1988 | 394 static int h263_parse(AVCodecParserContext *s, |
395 AVCodecContext *avctx, | |
396 uint8_t **poutbuf, int *poutbuf_size, | |
397 const uint8_t *buf, int buf_size) | |
398 { | |
399 ParseContext *pc = s->priv_data; | |
400 int next; | |
401 | |
402 next= h263_find_frame_end(pc, buf, buf_size); | |
403 | |
404 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
405 *poutbuf = NULL; | |
406 *poutbuf_size = 0; | |
407 return buf_size; | |
408 } | |
409 | |
410 *poutbuf = (uint8_t *)buf; | |
411 *poutbuf_size = buf_size; | |
412 return next; | |
413 } | |
414 | |
936 | 415 int ff_h263_decode_frame(AVCodecContext *avctx, |
0 | 416 void *data, int *data_size, |
1064 | 417 uint8_t *buf, int buf_size) |
0 | 418 { |
419 MpegEncContext *s = avctx->priv_data; | |
1453 | 420 int ret; |
925 | 421 AVFrame *pict = data; |
880 | 422 |
384 | 423 #ifdef PRINT_FRAME_TIME |
424 uint64_t time= rdtsc(); | |
425 #endif | |
0 | 426 #ifdef DEBUG |
427 printf("*****frame %d size=%d\n", avctx->frame_number, buf_size); | |
428 printf("bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]); | |
429 #endif | |
485 | 430 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1747
diff
changeset
|
431 s->flags2= avctx->flags2; |
454 | 432 |
1372 | 433 /* no supplementary picture */ |
0 | 434 if (buf_size == 0) { |
1372 | 435 /* special case for last picture */ |
436 if (s->low_delay==0 && s->next_picture_ptr) { | |
437 *pict= *(AVFrame*)s->next_picture_ptr; | |
438 s->next_picture_ptr= NULL; | |
439 | |
440 *data_size = sizeof(AVFrame); | |
441 } | |
442 | |
0 | 443 return 0; |
444 } | |
1026 | 445 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
446 if(s->flags&CODEC_FLAG_TRUNCATED){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
447 int next; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
448 |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
449 if(s->codec_id==CODEC_ID_MPEG4){ |
1988 | 450 next= ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
451 }else if(s->codec_id==CODEC_ID_H263){ |
1988 | 452 next= h263_find_frame_end(&s->parse_context, buf, buf_size); |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
453 }else{ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
454 av_log(s->avctx, AV_LOG_ERROR, "this codec doesnt support truncated bitstreams\n"); |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
455 return -1; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
456 } |
1026 | 457 |
1988 | 458 if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 ) |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
459 return buf_size; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
460 } |
0 | 461 |
1747 | 462 |
763 | 463 retry: |
464 | |
1747 | 465 if(s->bitstream_buffer_size && (s->divx_packed || buf_size<20)){ //divx 5.01+/xvid frame reorder |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1004
diff
changeset
|
466 init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8); |
353 | 467 }else |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1004
diff
changeset
|
468 init_get_bits(&s->gb, buf, buf_size*8); |
465 | 469 s->bitstream_buffer_size=0; |
0 | 470 |
718 | 471 if (!s->context_initialized) { |
752
97077dd24bfa
fixing alt_scan for the first frame (variable was reset)
michaelni
parents:
750
diff
changeset
|
472 if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix |
718 | 473 return -1; |
474 } | |
1586 | 475 |
476 //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there | |
477 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){ | |
478 int i= ff_find_unused_picture(s, 0); | |
479 s->current_picture_ptr= &s->picture[i]; | |
480 } | |
936 | 481 |
0 | 482 /* let's go :-) */ |
936 | 483 if (s->msmpeg4_version==5) { |
484 ret= ff_wmv2_decode_picture_header(s); | |
485 } else if (s->msmpeg4_version) { | |
0 | 486 ret = msmpeg4_decode_picture_header(s); |
487 } else if (s->h263_pred) { | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
488 if(s->avctx->extradata_size && s->picture_number==0){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
489 GetBitContext gb; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
490 |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1004
diff
changeset
|
491 init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
492 ret = ff_mpeg4_decode_picture_header(s, &gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
493 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
494 ret = ff_mpeg4_decode_picture_header(s, &s->gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
495 |
831 | 496 if(s->flags& CODEC_FLAG_LOW_DELAY) |
497 s->low_delay=1; | |
1687 | 498 } else if (s->codec_id == CODEC_ID_H263I) { |
0 | 499 ret = intel_h263_decode_picture_header(s); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
500 } else if (s->h263_flv) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
501 ret = flv_h263_decode_picture_header(s); |
0 | 502 } else { |
503 ret = h263_decode_picture_header(s); | |
274
d0c186bcf075
use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents:
273
diff
changeset
|
504 } |
1393 | 505 |
506 if(ret==FRAME_SKIPED) return get_consumed_bytes(s, buf_size); | |
507 | |
508 /* skip if the header was thrashed */ | |
509 if (ret < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
510 av_log(s->avctx, AV_LOG_ERROR, "header damaged\n"); |
1393 | 511 return -1; |
512 } | |
513 | |
924 | 514 avctx->has_b_frames= !s->low_delay; |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
515 |
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
516 if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){ |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
517 if(s->avctx->stream_codec_tag == ff_get_fourcc("XVID") || |
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
518 s->avctx->codec_tag == ff_get_fourcc("XVID") || s->avctx->codec_tag == ff_get_fourcc("XVIX")) |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
519 s->xvid_build= -1; |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
520 #if 0 |
1457 | 521 if(s->avctx->codec_tag == ff_get_fourcc("DIVX") && s->vo_type==0 && s->vol_control_parameters==1 |
522 && s->padding_bug_score > 0 && s->low_delay) // XVID with modified fourcc | |
523 s->xvid_build= -1; | |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
524 #endif |
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
525 } |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
526 |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
527 if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){ |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
528 if(s->avctx->codec_tag == ff_get_fourcc("DIVX") && s->vo_type==0 && s->vol_control_parameters==0) |
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
529 s->divx_version= 400; //divx 4 |
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
530 } |
2299 | 531 |
532 if(s->xvid_build && s->divx_version){ | |
533 s->divx_version= | |
534 s->divx_build= 0; | |
535 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
536 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
537 if(s->workaround_bugs&FF_BUG_AUTODETECT){ |
1116 | 538 if(s->avctx->codec_tag == ff_get_fourcc("XVIX")) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
539 s->workaround_bugs|= FF_BUG_XVID_ILACE; |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
540 |
1116 | 541 if(s->avctx->codec_tag == ff_get_fourcc("UMP4")){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
542 s->workaround_bugs|= FF_BUG_UMP4; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
543 } |
760 | 544 |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
545 if(s->divx_version>=500){ |
760 | 546 s->workaround_bugs|= FF_BUG_QPEL_CHROMA; |
547 } | |
761 | 548 |
1048 | 549 if(s->divx_version>502){ |
550 s->workaround_bugs|= FF_BUG_QPEL_CHROMA2; | |
551 } | |
552 | |
938
1e22655551b9
xvid build 3 still has the padding wrong in 1/8 of the cases :(((((
michaelni
parents:
936
diff
changeset
|
553 if(s->xvid_build && s->xvid_build<=3) |
1e22655551b9
xvid build 3 still has the padding wrong in 1/8 of the cases :(((((
michaelni
parents:
936
diff
changeset
|
554 s->padding_bug_score= 256*256*256*64; |
1e22655551b9
xvid build 3 still has the padding wrong in 1/8 of the cases :(((((
michaelni
parents:
936
diff
changeset
|
555 |
761 | 556 if(s->xvid_build && s->xvid_build<=1) |
557 s->workaround_bugs|= FF_BUG_QPEL_CHROMA; | |
558 | |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
559 if(s->xvid_build && s->xvid_build<=12) |
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
560 s->workaround_bugs|= FF_BUG_EDGE; |
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
561 |
2004 | 562 if(s->xvid_build && s->xvid_build<=32) |
563 s->workaround_bugs|= FF_BUG_DC_CLIP; | |
564 | |
984 | 565 #define SET_QPEL_FUNC(postfix1, postfix2) \ |
566 s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\ | |
567 s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\ | |
568 s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2; | |
569 | |
570 if(s->lavc_build && s->lavc_build<4653) | |
571 s->workaround_bugs|= FF_BUG_STD_QPEL; | |
572 | |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
573 if(s->lavc_build && s->lavc_build<4655) |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
574 s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE; |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
575 |
1502 | 576 if(s->lavc_build && s->lavc_build<4670){ |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1353
diff
changeset
|
577 s->workaround_bugs|= FF_BUG_EDGE; |
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1353
diff
changeset
|
578 } |
2004 | 579 |
580 if(s->lavc_build && s->lavc_build<=4712) | |
581 s->workaround_bugs|= FF_BUG_DC_CLIP; | |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1353
diff
changeset
|
582 |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
583 if(s->divx_version) |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
584 s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE; |
750 | 585 //printf("padding_bug_score: %d\n", s->padding_bug_score); |
1088
bb27c685fc72
fixing padding bug autodetection for some rare files, closes bug #647941
michaelni
parents:
1064
diff
changeset
|
586 if(s->divx_version==501 && s->divx_build==20020416) |
bb27c685fc72
fixing padding bug autodetection for some rare files, closes bug #647941
michaelni
parents:
1064
diff
changeset
|
587 s->padding_bug_score= 256*256*256*64; |
1137 | 588 |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1353
diff
changeset
|
589 if(s->divx_version && s->divx_version<500){ |
1137 | 590 s->workaround_bugs|= FF_BUG_EDGE; |
591 } | |
1389 | 592 |
1916 | 593 if(s->divx_version) |
594 s->workaround_bugs|= FF_BUG_HPEL_CHROMA; | |
750 | 595 #if 0 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
596 if(s->divx_version==500) |
1088
bb27c685fc72
fixing padding bug autodetection for some rare files, closes bug #647941
michaelni
parents:
1064
diff
changeset
|
597 s->padding_bug_score= 256*256*256*64; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
598 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
599 /* very ugly XVID padding bug detection FIXME/XXX solve this differently |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
600 * lets hope this at least works |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
601 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
602 if( s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
603 && s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
604 s->workaround_bugs|= FF_BUG_NO_PADDING; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
605 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
606 if(s->lavc_build && s->lavc_build<4609) //FIXME not sure about the version num but a 4609 file seems ok |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
607 s->workaround_bugs|= FF_BUG_NO_PADDING; |
750 | 608 #endif |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
609 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
610 |
984 | 611 if(s->workaround_bugs& FF_BUG_STD_QPEL){ |
612 SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c) | |
613 SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c) | |
614 SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c) | |
615 SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c) | |
616 SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c) | |
617 SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c) | |
618 | |
619 SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c) | |
620 SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c) | |
621 SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c) | |
622 SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c) | |
623 SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c) | |
624 SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c) | |
625 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
626 |
1457 | 627 if(avctx->debug & FF_DEBUG_BUGS) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
628 av_log(s->avctx, AV_LOG_DEBUG, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n", |
1457 | 629 s->workaround_bugs, s->lavc_build, s->xvid_build, s->divx_version, s->divx_build, |
630 s->divx_packed ? "p" : ""); | |
631 | |
585
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
632 #if 0 // dump bits per frame / qp / complexity |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
633 { |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
634 static FILE *f=NULL; |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
635 if(!f) f=fopen("rate_qp_cplx.txt", "w"); |
589
507e688d57b2
10l found by R«±mi Guyomarch <rguyom at pobox dot com>
michaelni
parents:
585
diff
changeset
|
636 fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale); |
585
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
637 } |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
638 #endif |
2096 | 639 |
640 #ifdef HAVE_MMX | |
2094
9c29987380e4
use libmpeg2 idct to decode xvid videos unless the user forced some other idct
michael
parents:
2052
diff
changeset
|
641 if(s->codec_id == CODEC_ID_MPEG4 && s->xvid_build && avctx->idct_algo == FF_IDCT_AUTO && (mm_flags & MM_MMX) && !(s->flags&CODEC_FLAG_BITEXACT)){ |
9c29987380e4
use libmpeg2 idct to decode xvid videos unless the user forced some other idct
michael
parents:
2052
diff
changeset
|
642 avctx->idct_algo= FF_IDCT_LIBMPEG2MMX; |
2278 | 643 avctx->coded_width= 0; // force reinit |
2094
9c29987380e4
use libmpeg2 idct to decode xvid videos unless the user forced some other idct
michael
parents:
2052
diff
changeset
|
644 } |
2096 | 645 #endif |
646 | |
274
d0c186bcf075
use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents:
273
diff
changeset
|
647 /* After H263 & mpeg4 header decode we have the height, width,*/ |
160 | 648 /* and other parameters. So then we could init the picture */ |
649 /* FIXME: By the way H263 decoder is evolving it should have */ | |
650 /* an H263EncContext */ | |
887 | 651 |
2270 | 652 if ( s->width != avctx->coded_width |
653 || s->height != avctx->coded_height) { | |
553 | 654 /* H.263 could change picture size any time */ |
1536 | 655 ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat |
656 s->parse_context.buffer=0; | |
553 | 657 MPV_common_end(s); |
1536 | 658 s->parse_context= pc; |
553 | 659 } |
274
d0c186bcf075
use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents:
273
diff
changeset
|
660 if (!s->context_initialized) { |
2270 | 661 avcodec_set_dimensions(avctx, s->width, s->height); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
662 |
763 | 663 goto retry; |
0 | 664 } |
758 | 665 |
666 if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)) | |
667 s->gob_index = ff_h263_get_gob_height(s); | |
845
32de034be20e
hurry_up>=5 -> skip everything except header & set pict_type&key_frame
michaelni
parents:
842
diff
changeset
|
668 |
903 | 669 // for hurry_up==5 |
670 s->current_picture.pict_type= s->pict_type; | |
671 s->current_picture.key_frame= s->pict_type == I_TYPE; | |
845
32de034be20e
hurry_up>=5 -> skip everything except header & set pict_type&key_frame
michaelni
parents:
842
diff
changeset
|
672 |
341 | 673 /* skip b frames if we dont have reference frames */ |
2052 | 674 if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)) return get_consumed_bytes(s, buf_size); |
345 | 675 /* skip b frames if we are in a hurry */ |
885
35d28522a1c5
moving init of some variables (hurry_up,...) to MPV_frame_start()
michaelni
parents:
880
diff
changeset
|
676 if(avctx->hurry_up && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size); |
845
32de034be20e
hurry_up>=5 -> skip everything except header & set pict_type&key_frame
michaelni
parents:
842
diff
changeset
|
677 /* skip everything if we are in a hurry>=5 */ |
885
35d28522a1c5
moving init of some variables (hurry_up,...) to MPV_frame_start()
michaelni
parents:
880
diff
changeset
|
678 if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size); |
454 | 679 |
680 if(s->next_p_frame_damaged){ | |
681 if(s->pict_type==B_TYPE) | |
655 | 682 return get_consumed_bytes(s, buf_size); |
454 | 683 else |
684 s->next_p_frame_damaged=0; | |
685 } | |
686 | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
763
diff
changeset
|
687 if(MPV_frame_start(s, avctx) < 0) |
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
763
diff
changeset
|
688 return -1; |
0 | 689 |
690 #ifdef DEBUG | |
691 printf("qscale=%d\n", s->qscale); | |
692 #endif | |
693 | |
1144 | 694 ff_er_frame_start(s); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
695 |
1183 | 696 //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type |
697 //which isnt available before MPV_frame_start() | |
698 if (s->msmpeg4_version==5){ | |
699 if(ff_wmv2_decode_secondary_picture_header(s) < 0) | |
700 return -1; | |
701 } | |
702 | |
0 | 703 /* decode each macroblock */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
704 s->mb_x=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
705 s->mb_y=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
706 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
707 decode_slice(s); |
1183 | 708 while(s->mb_y<s->mb_height){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
709 if(s->msmpeg4_version){ |
1183 | 710 if(s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
711 break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
712 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
713 if(ff_h263_resync(s)<0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
714 break; |
454 | 715 } |
716 | |
983 | 717 if(s->msmpeg4_version<4 && s->h263_pred) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
718 ff_mpeg4_clean_buffers(s); |
454 | 719 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
720 decode_slice(s); |
0 | 721 } |
756 | 722 |
311 | 723 if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE) |
903 | 724 if(msmpeg4_decode_ext_header(s, buf_size) < 0){ |
725 s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR; | |
726 } | |
333 | 727 |
728 /* divx 5.01+ bistream reorder stuff */ | |
1145
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
729 if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_packed){ |
454 | 730 int current_pos= get_bits_count(&s->gb)>>3; |
1747 | 731 int startcode_found=0; |
2422 | 732 |
733 if(buf_size - current_pos > 5){ | |
454 | 734 int i; |
655 | 735 for(i=current_pos; i<buf_size-3; i++){ |
454 | 736 if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){ |
737 startcode_found=1; | |
738 break; | |
739 } | |
740 } | |
1747 | 741 } |
742 if(s->gb.buffer == s->bitstream_buffer && buf_size>20){ //xvid style | |
743 startcode_found=1; | |
744 current_pos=0; | |
745 } | |
746 | |
747 if(startcode_found){ | |
2422 | 748 s->bitstream_buffer= av_fast_realloc( |
749 s->bitstream_buffer, | |
750 &s->allocated_bitstream_buffer_size, | |
751 buf_size - current_pos + FF_INPUT_BUFFER_PADDING_SIZE); | |
1747 | 752 memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos); |
753 s->bitstream_buffer_size= buf_size - current_pos; | |
454 | 754 } |
755 } | |
756 | |
1144 | 757 ff_er_frame_end(s); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
758 |
0 | 759 MPV_frame_end(s); |
984 | 760 |
1285 | 761 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type); |
762 assert(s->current_picture.pict_type == s->pict_type); | |
924 | 763 if(s->pict_type==B_TYPE || s->low_delay){ |
925 | 764 *pict= *(AVFrame*)&s->current_picture; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1687
diff
changeset
|
765 ff_print_debug_info(s, pict); |
262 | 766 } else { |
925 | 767 *pict= *(AVFrame*)&s->last_picture; |
1939 | 768 if(pict) |
769 ff_print_debug_info(s, pict); | |
262 | 770 } |
931 | 771 |
231 | 772 /* Return the Picture timestamp as the frame number */ |
773 /* we substract 1 because it is added on utils.c */ | |
774 avctx->frame_number = s->picture_number - 1; | |
775 | |
924 | 776 /* dont output the last pic after seeking */ |
1138 | 777 if(s->last_picture_ptr || s->low_delay) |
925 | 778 *data_size = sizeof(AVFrame); |
384 | 779 #ifdef PRINT_FRAME_TIME |
780 printf("%Ld\n", rdtsc()-time); | |
781 #endif | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
782 |
655 | 783 return get_consumed_bytes(s, buf_size); |
0 | 784 } |
785 | |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
786 static const AVOption mpeg4_decoptions[] = |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
787 { |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
788 AVOPTION_SUB(avoptions_workaround_bug), |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
789 AVOPTION_END() |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
790 }; |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
791 |
67 | 792 AVCodec mpeg4_decoder = { |
793 "mpeg4", | |
0 | 794 CODEC_TYPE_VIDEO, |
67 | 795 CODEC_ID_MPEG4, |
0 | 796 sizeof(MpegEncContext), |
936 | 797 ff_h263_decode_init, |
0 | 798 NULL, |
936 | 799 ff_h263_decode_end, |
800 ff_h263_decode_frame, | |
2453 | 801 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
802 .options = mpeg4_decoptions, |
1368 | 803 .flush= ff_mpeg_flush, |
0 | 804 }; |
805 | |
806 AVCodec h263_decoder = { | |
807 "h263", | |
808 CODEC_TYPE_VIDEO, | |
809 CODEC_ID_H263, | |
810 sizeof(MpegEncContext), | |
936 | 811 ff_h263_decode_init, |
0 | 812 NULL, |
936 | 813 ff_h263_decode_end, |
814 ff_h263_decode_frame, | |
2453 | 815 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
1368 | 816 .flush= ff_mpeg_flush, |
0 | 817 }; |
818 | |
307 | 819 AVCodec msmpeg4v1_decoder = { |
820 "msmpeg4v1", | |
821 CODEC_TYPE_VIDEO, | |
822 CODEC_ID_MSMPEG4V1, | |
823 sizeof(MpegEncContext), | |
936 | 824 ff_h263_decode_init, |
307 | 825 NULL, |
936 | 826 ff_h263_decode_end, |
827 ff_h263_decode_frame, | |
553 | 828 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
829 mpeg4_decoptions, |
307 | 830 }; |
831 | |
832 AVCodec msmpeg4v2_decoder = { | |
833 "msmpeg4v2", | |
834 CODEC_TYPE_VIDEO, | |
835 CODEC_ID_MSMPEG4V2, | |
836 sizeof(MpegEncContext), | |
936 | 837 ff_h263_decode_init, |
307 | 838 NULL, |
936 | 839 ff_h263_decode_end, |
840 ff_h263_decode_frame, | |
553 | 841 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
842 mpeg4_decoptions, |
307 | 843 }; |
844 | |
845 AVCodec msmpeg4v3_decoder = { | |
0 | 846 "msmpeg4", |
847 CODEC_TYPE_VIDEO, | |
307 | 848 CODEC_ID_MSMPEG4V3, |
0 | 849 sizeof(MpegEncContext), |
936 | 850 ff_h263_decode_init, |
0 | 851 NULL, |
936 | 852 ff_h263_decode_end, |
853 ff_h263_decode_frame, | |
553 | 854 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
855 .options = mpeg4_decoptions, |
0 | 856 }; |
857 | |
311 | 858 AVCodec wmv1_decoder = { |
859 "wmv1", | |
860 CODEC_TYPE_VIDEO, | |
861 CODEC_ID_WMV1, | |
862 sizeof(MpegEncContext), | |
936 | 863 ff_h263_decode_init, |
311 | 864 NULL, |
936 | 865 ff_h263_decode_end, |
866 ff_h263_decode_frame, | |
553 | 867 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
868 mpeg4_decoptions, |
498 | 869 }; |
870 | |
0 | 871 AVCodec h263i_decoder = { |
872 "h263i", | |
873 CODEC_TYPE_VIDEO, | |
874 CODEC_ID_H263I, | |
875 sizeof(MpegEncContext), | |
936 | 876 ff_h263_decode_init, |
0 | 877 NULL, |
936 | 878 ff_h263_decode_end, |
879 ff_h263_decode_frame, | |
553 | 880 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
881 mpeg4_decoptions, |
0 | 882 }; |
883 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
884 AVCodec flv_decoder = { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
885 "flv", |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
886 CODEC_TYPE_VIDEO, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
887 CODEC_ID_FLV1, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
888 sizeof(MpegEncContext), |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
889 ff_h263_decode_init, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
890 NULL, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
891 ff_h263_decode_end, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
892 ff_h263_decode_frame, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
893 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
894 }; |
1988 | 895 |
896 AVCodecParser h263_parser = { | |
897 { CODEC_ID_H263 }, | |
898 sizeof(ParseContext), | |
899 NULL, | |
900 h263_parse, | |
901 ff_parse_close, | |
902 }; |