Mercurial > libavcodec.hg
annotate h263dec.c @ 1352:e8ff4783f188 libavcodec
1) remove TBL support in PPC performance. It's much more useful to use the
PMCs, and with Apple's CHUD it's fairly easy too. No reason to keep useless
code around
2) make the PPC perf stuff a configure option
3) make put_pixels16_altivec a bit faster by unrolling the loop by 4
patch by (Romain Dolbeau <dolbeau at irisa dot fr>)
author | michaelni |
---|---|
date | Wed, 09 Jul 2003 20:18:13 +0000 |
parents | e0e5483c32c5 |
children | cfc80b3a4ada |
rev | line source |
---|---|
0 | 1 /* |
1106 | 2 * H.263 decoder |
429 | 3 * Copyright (c) 2001 Fabrice Bellard. |
0 | 4 * |
429 | 5 * This library is free software; you can redistribute it and/or |
6 * modify it under the terms of the GNU Lesser General Public | |
7 * License as published by the Free Software Foundation; either | |
8 * version 2 of the License, or (at your option) any later version. | |
0 | 9 * |
429 | 10 * This library is distributed in the hope that it will be useful, |
0 | 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 * Lesser General Public License for more details. | |
0 | 14 * |
429 | 15 * You should have received a copy of the GNU Lesser General Public |
16 * License along with this library; if not, write to the Free Software | |
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
0 | 18 */ |
1106 | 19 |
20 /** | |
21 * @file h263dec.c | |
22 * H.263 decoder. | |
23 */ | |
24 | |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
384
diff
changeset
|
25 #include "avcodec.h" |
0 | 26 #include "dsputil.h" |
27 #include "mpegvideo.h" | |
28 | |
29 //#define DEBUG | |
384 | 30 //#define PRINT_FRAME_TIME |
31 #ifdef PRINT_FRAME_TIME | |
32 static inline long long rdtsc() | |
33 { | |
34 long long l; | |
35 asm volatile( "rdtsc\n\t" | |
36 : "=A" (l) | |
37 ); | |
38 // printf("%d\n", int(l/1000)); | |
39 return l; | |
40 } | |
41 #endif | |
0 | 42 |
936 | 43 int ff_h263_decode_init(AVCodecContext *avctx) |
0 | 44 { |
45 MpegEncContext *s = avctx->priv_data; | |
60 | 46 |
67 | 47 s->avctx = avctx; |
0 | 48 s->out_format = FMT_H263; |
49 | |
50 s->width = avctx->width; | |
51 s->height = avctx->height; | |
411
5c8b3a717929
workaround dc_scale bug in old ffmpeg msmpeg4v3 encoder (set workaround_bugs=1 for this)
michaelni
parents:
396
diff
changeset
|
52 s->workaround_bugs= avctx->workaround_bugs; |
0 | 53 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
54 // set defaults |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
55 s->quant_precision=5; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
56 s->progressive_sequence=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
57 s->decode_mb= ff_h263_decode_mb; |
924 | 58 s->low_delay= 1; |
939 | 59 avctx->pix_fmt= PIX_FMT_YUV420P; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
60 |
0 | 61 /* select sub codec */ |
62 switch(avctx->codec->id) { | |
63 case CODEC_ID_H263: | |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
64 s->gob_number = 0; |
0 | 65 break; |
67 | 66 case CODEC_ID_MPEG4: |
0 | 67 s->time_increment_bits = 4; /* default value for broken headers */ |
68 s->h263_pred = 1; | |
924 | 69 s->low_delay = 0; //default, might be overriden in the vol header during header parsing |
0 | 70 break; |
307 | 71 case CODEC_ID_MSMPEG4V1: |
0 | 72 s->h263_msmpeg4 = 1; |
73 s->h263_pred = 1; | |
307 | 74 s->msmpeg4_version=1; |
75 break; | |
76 case CODEC_ID_MSMPEG4V2: | |
77 s->h263_msmpeg4 = 1; | |
78 s->h263_pred = 1; | |
79 s->msmpeg4_version=2; | |
80 break; | |
81 case CODEC_ID_MSMPEG4V3: | |
82 s->h263_msmpeg4 = 1; | |
83 s->h263_pred = 1; | |
84 s->msmpeg4_version=3; | |
0 | 85 break; |
311 | 86 case CODEC_ID_WMV1: |
87 s->h263_msmpeg4 = 1; | |
88 s->h263_pred = 1; | |
89 s->msmpeg4_version=4; | |
90 break; | |
498 | 91 case CODEC_ID_WMV2: |
92 s->h263_msmpeg4 = 1; | |
93 s->h263_pred = 1; | |
94 s->msmpeg4_version=5; | |
95 break; | |
0 | 96 case CODEC_ID_H263I: |
97 s->h263_intel = 1; | |
98 break; | |
99 default: | |
100 return -1; | |
101 } | |
344 | 102 s->codec_id= avctx->codec->id; |
553 | 103 |
0 | 104 /* 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
|
105 if (avctx->codec->id != CODEC_ID_H263 && avctx->codec->id != CODEC_ID_MPEG4) |
144 | 106 if (MPV_common_init(s) < 0) |
107 return -1; | |
0 | 108 |
109 if (s->h263_msmpeg4) | |
498 | 110 ff_msmpeg4_decode_init(s); |
0 | 111 else |
112 h263_decode_init_vlc(s); | |
113 | |
114 return 0; | |
115 } | |
116 | |
936 | 117 int ff_h263_decode_end(AVCodecContext *avctx) |
0 | 118 { |
119 MpegEncContext *s = avctx->priv_data; | |
120 | |
121 MPV_common_end(s); | |
122 return 0; | |
123 } | |
124 | |
655 | 125 /** |
126 * retunrs the number of bytes consumed for building the current frame | |
127 */ | |
128 static int get_consumed_bytes(MpegEncContext *s, int buf_size){ | |
129 int pos= (get_bits_count(&s->gb)+7)>>3; | |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
130 |
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
|
131 if(s->divx_packed){ |
655 | 132 //we would have to scan through the whole buf to handle the weird reordering ... |
133 return buf_size; | |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
134 }else if(s->flags&CODEC_FLAG_TRUNCATED){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
135 pos -= s->parse_context.last_index; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
136 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
|
137 return pos; |
655 | 138 }else{ |
139 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
658 | 140 if(pos+10>buf_size) pos=buf_size; // oops ;) |
655 | 141 |
142 return pos; | |
143 } | |
144 } | |
145 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
146 static int decode_slice(MpegEncContext *s){ |
1144 | 147 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; |
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 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
154 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
155 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
156 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
157 if(s->partitioned_frame){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
158 const int qscale= s->qscale; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
159 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
160 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
161 if(ff_mpeg4_decode_partitions(s) < 0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
162 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
163 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
164 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
165 /* restore variables which where modified */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
166 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
167 s->mb_x= s->resync_mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
168 s->mb_y= s->resync_mb_y; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
169 s->qscale= qscale; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
170 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
171 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
172 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
173 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
174 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
|
175 /* per-row end of slice checks */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
176 if(s->msmpeg4_version){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
177 if(s->resync_mb_y + s->slice_height == s->mb_y){ |
1144 | 178 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); |
179 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
180 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
181 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
182 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
183 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
184 if(s->msmpeg4_version==1){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
185 s->last_dc[0]= |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
186 s->last_dc[1]= |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
187 s->last_dc[2]= 128; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
188 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
189 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
190 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
191 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
|
192 int ret; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
193 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
194 ff_update_block_index(s); |
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 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
|
197 s->first_slice_line=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
198 } |
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 /* DCT & quantize */ |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
845
diff
changeset
|
201 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
|
202 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
203 s->mv_dir = MV_DIR_FORWARD; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
204 s->mv_type = MV_TYPE_16X16; |
903 | 205 // s->mb_skiped = 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
206 //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
|
207 ret= s->decode_mb(s, s->block); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
208 |
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); |
213 | |
758 | 214 //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 | 215 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 | 216 |
217 s->padding_bug_score--; | |
218 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
219 if(++s->mb_x >= s->mb_width){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
220 s->mb_x=0; |
1098
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1088
diff
changeset
|
221 ff_draw_horiz_band(s, s->mb_y*16, 16); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
222 s->mb_y++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
223 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
224 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
225 }else if(ret==SLICE_NOEND){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
226 fprintf(stderr,"Slice mismatch at MB: %d\n", xy); |
1144 | 227 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
|
228 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
229 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
230 fprintf(stderr,"Error at MB: %d\n", xy); |
1144 | 231 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
|
232 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
233 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
234 } |
1338 | 235 |
236 MPV_decode_mb(s, s->block); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
237 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
238 |
1098
b7f267d168b7
mpeg2 field pictures + sliced mode (doesnt work with mplayer though, dunno why)
michaelni
parents:
1088
diff
changeset
|
239 ff_draw_horiz_band(s, s->mb_y*16, 16); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
240 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
241 s->mb_x= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
242 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
243 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
244 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
|
245 |
750 | 246 /* try to detect the padding bug */ |
247 if( s->codec_id==CODEC_ID_MPEG4 | |
248 && (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
|
249 && 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
|
250 && 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
|
251 // && !s->resync_marker |
750 | 252 && !s->data_partitioning){ |
253 | |
254 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
|
255 const int bits_left = s->gb.size_in_bits - bits_count; |
750 | 256 |
1003 | 257 if(bits_left==0){ |
258 s->padding_bug_score+=16; | |
259 }else if(bits_left>8){ | |
750 | 260 s->padding_bug_score++; |
824 | 261 } else if(bits_left != 1){ |
750 | 262 int v= show_bits(&s->gb, 8); |
263 v|= 0x7F >> (7-(bits_count&7)); | |
824 | 264 |
750 | 265 if(v==0x7F) |
266 s->padding_bug_score--; | |
267 else | |
268 s->padding_bug_score++; | |
1003 | 269 } |
750 | 270 } |
271 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
272 // handle formats which dont have unique end markers |
1004 | 273 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
|
274 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
|
275 int max_extra=7; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
276 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
277 /* no markers in M$ crap */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
278 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
|
279 max_extra+= 17; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
280 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
281 /* buggy padding but the frame should still end approximately at the bitstream end */ |
1004 | 282 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
|
283 max_extra+= 48; |
1004 | 284 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
|
285 max_extra+= 256*256*256*64; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
286 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
287 if(left>max_extra){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
288 fprintf(stderr, "discarding %d junk bits at end, next would be %X\n", left, show_bits(&s->gb, 24)); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
289 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
290 else if(left<0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
291 fprintf(stderr, "overreading %d bits\n", -left); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
292 }else |
1144 | 293 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
|
294 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
295 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
296 } |
750 | 297 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
298 fprintf(stderr, "slice end not reached but screenspace end (%d left %06X)\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
|
299 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
|
300 show_bits(&s->gb, 24)); |
1144 | 301 |
302 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); | |
303 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
304 return -1; |
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 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
307 /** |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
308 * finds the end of the current frame in the bitstream. |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
309 * @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
|
310 */ |
1064 | 311 static int mpeg4_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){ |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
312 ParseContext *pc= &s->parse_context; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
313 int vop_found, i; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
314 uint32_t state; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
315 |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
316 vop_found= pc->frame_start_found; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
317 state= pc->state; |
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 i=0; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
320 if(!vop_found){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
321 for(i=0; i<buf_size; i++){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
322 state= (state<<8) | buf[i]; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
323 if(state == 0x1B6){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
324 i++; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
325 vop_found=1; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
326 break; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
327 } |
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 } |
1211 | 330 |
331 if(vop_found){ | |
332 for(; i<buf_size; i++){ | |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
333 state= (state<<8) | buf[i]; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
334 if((state&0xFFFFFF00) == 0x100){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
335 pc->frame_start_found=0; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
336 pc->state=-1; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
337 return i-3; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
338 } |
1211 | 339 } |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
340 } |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
341 pc->frame_start_found= vop_found; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
342 pc->state= state; |
1219 | 343 return END_NOT_FOUND; |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
344 } |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
345 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
346 static int h263_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
347 ParseContext *pc= &s->parse_context; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
348 int vop_found, i; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
349 uint32_t state; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
350 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
351 vop_found= pc->frame_start_found; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
352 state= pc->state; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
353 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
354 i=0; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
355 if(!vop_found){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
356 for(i=0; i<buf_size; i++){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
357 state= (state<<8) | buf[i]; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
358 if(state>>(32-22) == 0x20){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
359 i++; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
360 vop_found=1; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
361 break; |
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 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
364 } |
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 if(vop_found){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
367 for(; i<buf_size; i++){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
368 state= (state<<8) | buf[i]; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
369 if(state>>(32-22) == 0x20){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
370 pc->frame_start_found=0; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
371 pc->state=-1; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
372 return i-3; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
373 } |
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 pc->frame_start_found= vop_found; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
377 pc->state= state; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
378 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
379 return END_NOT_FOUND; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
380 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
381 |
936 | 382 int ff_h263_decode_frame(AVCodecContext *avctx, |
0 | 383 void *data, int *data_size, |
1064 | 384 uint8_t *buf, int buf_size) |
0 | 385 { |
386 MpegEncContext *s = avctx->priv_data; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
387 int ret,i; |
925 | 388 AVFrame *pict = data; |
880 | 389 float new_aspect; |
390 | |
384 | 391 #ifdef PRINT_FRAME_TIME |
392 uint64_t time= rdtsc(); | |
393 #endif | |
0 | 394 #ifdef DEBUG |
395 printf("*****frame %d size=%d\n", avctx->frame_number, buf_size); | |
396 printf("bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]); | |
397 #endif | |
485 | 398 s->flags= avctx->flags; |
454 | 399 |
657 | 400 *data_size = 0; |
401 | |
402 /* no supplementary picture */ | |
0 | 403 if (buf_size == 0) { |
404 return 0; | |
405 } | |
1026 | 406 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
407 if(s->flags&CODEC_FLAG_TRUNCATED){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
408 int next; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
409 |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
410 if(s->codec_id==CODEC_ID_MPEG4){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
411 next= mpeg4_find_frame_end(s, buf, buf_size); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
412 }else if(s->codec_id==CODEC_ID_H263){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
413 next= h263_find_frame_end(s, buf, buf_size); |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
414 }else{ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
415 fprintf(stderr, "this codec doesnt support truncated bitstreams\n"); |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
416 return -1; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
417 } |
1026 | 418 |
419 if( ff_combine_frame(s, next, &buf, &buf_size) < 0 ) | |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
420 return buf_size; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
421 } |
0 | 422 |
763 | 423 retry: |
424 | |
465 | 425 if(s->bitstream_buffer_size && buf_size<20){ //divx 5.01+ 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
|
426 init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8); |
353 | 427 }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
|
428 init_get_bits(&s->gb, buf, buf_size*8); |
465 | 429 s->bitstream_buffer_size=0; |
0 | 430 |
718 | 431 if (!s->context_initialized) { |
752
97077dd24bfa
fixing alt_scan for the first frame (variable was reset)
michaelni
parents:
750
diff
changeset
|
432 if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix |
718 | 433 return -1; |
434 } | |
936 | 435 |
0 | 436 /* let's go :-) */ |
936 | 437 if (s->msmpeg4_version==5) { |
438 ret= ff_wmv2_decode_picture_header(s); | |
439 } else if (s->msmpeg4_version) { | |
0 | 440 ret = msmpeg4_decode_picture_header(s); |
441 } 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
|
442 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
|
443 GetBitContext gb; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
444 |
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
|
445 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
|
446 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
|
447 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
448 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
|
449 |
831 | 450 if(s->flags& CODEC_FLAG_LOW_DELAY) |
451 s->low_delay=1; | |
0 | 452 } else if (s->h263_intel) { |
453 ret = intel_h263_decode_picture_header(s); | |
454 } else { | |
455 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
|
456 } |
924 | 457 avctx->has_b_frames= !s->low_delay; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
458 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
459 if(s->workaround_bugs&FF_BUG_AUTODETECT){ |
1175
d2fd27d01df8
fixing slice decoding, dunno why the regression tests didnt catch that ...
michaelni
parents:
1145
diff
changeset
|
460 if(s->padding_bug_score > -2 && !s->data_partitioning && !s->resync_marker) |
1004 | 461 s->workaround_bugs |= FF_BUG_NO_PADDING; |
462 else | |
463 s->workaround_bugs &= ~FF_BUG_NO_PADDING; | |
464 | |
1116 | 465 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
|
466 s->workaround_bugs|= FF_BUG_XVID_ILACE; |
921 | 467 #if 0 |
1116 | 468 if(s->avctx->codec_tag == ff_get_fourcc("MP4S")) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
469 s->workaround_bugs|= FF_BUG_AC_VLC; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
470 |
1116 | 471 if(s->avctx->codec_tag == ff_get_fourcc("M4S2")) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
472 s->workaround_bugs|= FF_BUG_AC_VLC; |
921 | 473 #endif |
1116 | 474 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
|
475 s->workaround_bugs|= FF_BUG_UMP4; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
476 s->workaround_bugs|= FF_BUG_AC_VLC; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
477 } |
760 | 478 |
479 if(s->divx_version){ | |
480 s->workaround_bugs|= FF_BUG_QPEL_CHROMA; | |
481 } | |
761 | 482 |
1048 | 483 if(s->divx_version>502){ |
484 s->workaround_bugs|= FF_BUG_QPEL_CHROMA2; | |
485 } | |
486 | |
1116 | 487 if(s->avctx->codec_tag == ff_get_fourcc("XVID") && s->xvid_build==0) |
761 | 488 s->workaround_bugs|= FF_BUG_QPEL_CHROMA; |
489 | |
1116 | 490 if(s->avctx->codec_tag == ff_get_fourcc("XVID") && s->xvid_build==0) |
907 | 491 s->padding_bug_score= 256*256*256*64; |
492 | |
938
1e22655551b9
xvid build 3 still has the padding wrong in 1/8 of the cases :(((((
michaelni
parents:
936
diff
changeset
|
493 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
|
494 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
|
495 |
761 | 496 if(s->xvid_build && s->xvid_build<=1) |
497 s->workaround_bugs|= FF_BUG_QPEL_CHROMA; | |
498 | |
984 | 499 #define SET_QPEL_FUNC(postfix1, postfix2) \ |
500 s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\ | |
501 s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\ | |
502 s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2; | |
503 | |
504 if(s->lavc_build && s->lavc_build<4653) | |
505 s->workaround_bugs|= FF_BUG_STD_QPEL; | |
506 | |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
507 if(s->lavc_build && s->lavc_build<4655) |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
508 s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE; |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
509 |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
510 if(s->divx_version) |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
511 s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE; |
750 | 512 //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
|
513 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
|
514 s->padding_bug_score= 256*256*256*64; |
1137 | 515 |
516 if(s->divx_version>=500){ | |
517 s->workaround_bugs|= FF_BUG_EDGE; | |
518 } | |
519 | |
750 | 520 #if 0 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
521 if(s->divx_version==500) |
1088
bb27c685fc72
fixing padding bug autodetection for some rare files, closes bug #647941
michaelni
parents:
1064
diff
changeset
|
522 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
|
523 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
524 /* 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
|
525 * lets hope this at least works |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
526 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
527 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
|
528 && 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
|
529 s->workaround_bugs|= FF_BUG_NO_PADDING; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
530 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
531 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
|
532 s->workaround_bugs|= FF_BUG_NO_PADDING; |
750 | 533 #endif |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
534 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
535 |
984 | 536 if(s->workaround_bugs& FF_BUG_STD_QPEL){ |
537 SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c) | |
538 SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c) | |
539 SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c) | |
540 SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c) | |
541 SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c) | |
542 SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c) | |
543 | |
544 SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c) | |
545 SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c) | |
546 SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c) | |
547 SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c) | |
548 SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c) | |
549 SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c) | |
550 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
551 |
585
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
552 #if 0 // dump bits per frame / qp / complexity |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
553 { |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
554 static FILE *f=NULL; |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
555 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
|
556 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
|
557 } |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
558 #endif |
553 | 559 |
274
d0c186bcf075
use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents:
273
diff
changeset
|
560 /* After H263 & mpeg4 header decode we have the height, width,*/ |
160 | 561 /* and other parameters. So then we could init the picture */ |
562 /* FIXME: By the way H263 decoder is evolving it should have */ | |
563 /* an H263EncContext */ | |
880 | 564 if(s->aspected_height) |
887 | 565 new_aspect= s->aspected_width*s->width / (float)(s->height*s->aspected_height); |
880 | 566 else |
567 new_aspect=0; | |
887 | 568 |
718 | 569 if ( s->width != avctx->width || s->height != avctx->height |
880 | 570 || ABS(new_aspect - avctx->aspect_ratio) > 0.001) { |
553 | 571 /* H.263 could change picture size any time */ |
572 MPV_common_end(s); | |
573 } | |
274
d0c186bcf075
use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents:
273
diff
changeset
|
574 if (!s->context_initialized) { |
888 | 575 avctx->width = s->width; |
576 avctx->height = s->height; | |
880 | 577 avctx->aspect_ratio= new_aspect; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
578 |
763 | 579 goto retry; |
0 | 580 } |
758 | 581 |
582 if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)) | |
583 s->gob_index = ff_h263_get_gob_height(s); | |
584 | |
655 | 585 if(ret==FRAME_SKIPED) return get_consumed_bytes(s, buf_size); |
454 | 586 /* skip if the header was thrashed */ |
498 | 587 if (ret < 0){ |
588 fprintf(stderr, "header damaged\n"); | |
0 | 589 return -1; |
498 | 590 } |
845
32de034be20e
hurry_up>=5 -> skip everything except header & set pict_type&key_frame
michaelni
parents:
842
diff
changeset
|
591 |
903 | 592 // for hurry_up==5 |
593 s->current_picture.pict_type= s->pict_type; | |
594 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
|
595 |
341 | 596 /* skip b frames if we dont have reference frames */ |
1138 | 597 if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size); |
345 | 598 /* 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
|
599 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
|
600 /* 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
|
601 if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size); |
454 | 602 |
603 if(s->next_p_frame_damaged){ | |
604 if(s->pict_type==B_TYPE) | |
655 | 605 return get_consumed_bytes(s, buf_size); |
454 | 606 else |
607 s->next_p_frame_damaged=0; | |
608 } | |
609 | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
763
diff
changeset
|
610 if(MPV_frame_start(s, avctx) < 0) |
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
763
diff
changeset
|
611 return -1; |
0 | 612 |
613 #ifdef DEBUG | |
614 printf("qscale=%d\n", s->qscale); | |
615 #endif | |
616 | |
1144 | 617 ff_er_frame_start(s); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
618 |
1183 | 619 //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type |
620 //which isnt available before MPV_frame_start() | |
621 if (s->msmpeg4_version==5){ | |
622 if(ff_wmv2_decode_secondary_picture_header(s) < 0) | |
623 return -1; | |
624 } | |
625 | |
0 | 626 /* decode each macroblock */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
627 s->mb_x=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
628 s->mb_y=0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
629 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
630 decode_slice(s); |
1183 | 631 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
|
632 if(s->msmpeg4_version){ |
1183 | 633 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
|
634 break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
635 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
636 if(ff_h263_resync(s)<0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
637 break; |
454 | 638 } |
639 | |
983 | 640 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
|
641 ff_mpeg4_clean_buffers(s); |
454 | 642 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
643 decode_slice(s); |
0 | 644 } |
756 | 645 |
311 | 646 if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE) |
903 | 647 if(msmpeg4_decode_ext_header(s, buf_size) < 0){ |
648 s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR; | |
649 } | |
333 | 650 |
651 /* 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
|
652 if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_packed){ |
454 | 653 int current_pos= get_bits_count(&s->gb)>>3; |
654 | |
333 | 655 if( buf_size - current_pos > 5 |
656 && buf_size - current_pos < BITSTREAM_BUFFER_SIZE){ | |
454 | 657 int i; |
658 int startcode_found=0; | |
655 | 659 for(i=current_pos; i<buf_size-3; i++){ |
454 | 660 if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){ |
661 startcode_found=1; | |
662 break; | |
663 } | |
664 } | |
665 if(startcode_found){ | |
666 memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos); | |
667 s->bitstream_buffer_size= buf_size - current_pos; | |
668 } | |
669 } | |
670 } | |
671 | |
1144 | 672 ff_er_frame_end(s); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
673 |
0 | 674 MPV_frame_end(s); |
984 | 675 |
1285 | 676 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type); |
677 assert(s->current_picture.pict_type == s->pict_type); | |
924 | 678 if(s->pict_type==B_TYPE || s->low_delay){ |
925 | 679 *pict= *(AVFrame*)&s->current_picture; |
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
|
680 ff_print_debug_info(s, s->current_picture_ptr); |
262 | 681 } else { |
925 | 682 *pict= *(AVFrame*)&s->last_picture; |
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
|
683 ff_print_debug_info(s, s->last_picture_ptr); |
262 | 684 } |
931 | 685 |
231 | 686 /* Return the Picture timestamp as the frame number */ |
687 /* we substract 1 because it is added on utils.c */ | |
688 avctx->frame_number = s->picture_number - 1; | |
689 | |
924 | 690 /* dont output the last pic after seeking */ |
1138 | 691 if(s->last_picture_ptr || s->low_delay) |
925 | 692 *data_size = sizeof(AVFrame); |
384 | 693 #ifdef PRINT_FRAME_TIME |
694 printf("%Ld\n", rdtsc()-time); | |
695 #endif | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
696 |
655 | 697 return get_consumed_bytes(s, buf_size); |
0 | 698 } |
699 | |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
700 static const AVOption mpeg4_decoptions[] = |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
701 { |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
702 AVOPTION_SUB(avoptions_workaround_bug), |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
703 AVOPTION_END() |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
704 }; |
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
705 |
67 | 706 AVCodec mpeg4_decoder = { |
707 "mpeg4", | |
0 | 708 CODEC_TYPE_VIDEO, |
67 | 709 CODEC_ID_MPEG4, |
0 | 710 sizeof(MpegEncContext), |
936 | 711 ff_h263_decode_init, |
0 | 712 NULL, |
936 | 713 ff_h263_decode_end, |
714 ff_h263_decode_frame, | |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
715 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED, |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
716 .options = mpeg4_decoptions, |
0 | 717 }; |
718 | |
719 AVCodec h263_decoder = { | |
720 "h263", | |
721 CODEC_TYPE_VIDEO, | |
722 CODEC_ID_H263, | |
723 sizeof(MpegEncContext), | |
936 | 724 ff_h263_decode_init, |
0 | 725 NULL, |
936 | 726 ff_h263_decode_end, |
727 ff_h263_decode_frame, | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
728 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED, |
0 | 729 }; |
730 | |
307 | 731 AVCodec msmpeg4v1_decoder = { |
732 "msmpeg4v1", | |
733 CODEC_TYPE_VIDEO, | |
734 CODEC_ID_MSMPEG4V1, | |
735 sizeof(MpegEncContext), | |
936 | 736 ff_h263_decode_init, |
307 | 737 NULL, |
936 | 738 ff_h263_decode_end, |
739 ff_h263_decode_frame, | |
553 | 740 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
741 mpeg4_decoptions, |
307 | 742 }; |
743 | |
744 AVCodec msmpeg4v2_decoder = { | |
745 "msmpeg4v2", | |
746 CODEC_TYPE_VIDEO, | |
747 CODEC_ID_MSMPEG4V2, | |
748 sizeof(MpegEncContext), | |
936 | 749 ff_h263_decode_init, |
307 | 750 NULL, |
936 | 751 ff_h263_decode_end, |
752 ff_h263_decode_frame, | |
553 | 753 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
754 mpeg4_decoptions, |
307 | 755 }; |
756 | |
757 AVCodec msmpeg4v3_decoder = { | |
0 | 758 "msmpeg4", |
759 CODEC_TYPE_VIDEO, | |
307 | 760 CODEC_ID_MSMPEG4V3, |
0 | 761 sizeof(MpegEncContext), |
936 | 762 ff_h263_decode_init, |
0 | 763 NULL, |
936 | 764 ff_h263_decode_end, |
765 ff_h263_decode_frame, | |
553 | 766 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
767 .options = mpeg4_decoptions, |
0 | 768 }; |
769 | |
311 | 770 AVCodec wmv1_decoder = { |
771 "wmv1", | |
772 CODEC_TYPE_VIDEO, | |
773 CODEC_ID_WMV1, | |
774 sizeof(MpegEncContext), | |
936 | 775 ff_h263_decode_init, |
311 | 776 NULL, |
936 | 777 ff_h263_decode_end, |
778 ff_h263_decode_frame, | |
553 | 779 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
780 mpeg4_decoptions, |
498 | 781 }; |
782 | |
0 | 783 AVCodec h263i_decoder = { |
784 "h263i", | |
785 CODEC_TYPE_VIDEO, | |
786 CODEC_ID_H263I, | |
787 sizeof(MpegEncContext), | |
936 | 788 ff_h263_decode_init, |
0 | 789 NULL, |
936 | 790 ff_h263_decode_end, |
791 ff_h263_decode_frame, | |
553 | 792 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
1124
64c7c76ed17c
* 'externaly' visible option list begins avoptions_ prefix
kabi
parents:
1116
diff
changeset
|
793 mpeg4_decoptions, |
0 | 794 }; |
795 |