Mercurial > libavcodec.hg
annotate h263dec.c @ 4166:eced83504436 libavcodec
mp3 header (de)compression bitstream filter
this will make mp3 frames 4 bytes smaller, it will not give you binary identical mp3 files, but it will give you mp3 files which decode to binary identical output
this will only work in containers providing at least packet size, sample_rate and number of channels
bugreports about mp3 files for which this fails are welcome
and this is experimental (dont expect compatibility and dont even expect to be able to decompress what you compressed, hell dont even expect this to work without editing the source a little)
author | michael |
---|---|
date | Fri, 10 Nov 2006 01:41:53 +0000 |
parents | 0f28fc219799 |
children | fbac0859753d |
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 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3926
diff
changeset
|
6 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3926
diff
changeset
|
7 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3926
diff
changeset
|
8 * FFmpeg is free software; you can redistribute it and/or |
429 | 9 * modify it under the terms of the GNU Lesser General Public |
10 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3926
diff
changeset
|
11 * version 2.1 of the License, or (at your option) any later version. |
0 | 12 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3926
diff
changeset
|
13 * FFmpeg is distributed in the hope that it will be useful, |
0 | 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 * Lesser General Public License for more details. | |
0 | 17 * |
429 | 18 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3926
diff
changeset
|
19 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2977
diff
changeset
|
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 21 */ |
2967 | 22 |
1106 | 23 /** |
24 * @file h263dec.c | |
25 * H.263 decoder. | |
26 */ | |
2967 | 27 |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
384
diff
changeset
|
28 #include "avcodec.h" |
0 | 29 #include "dsputil.h" |
30 #include "mpegvideo.h" | |
31 | |
32 //#define DEBUG | |
384 | 33 //#define PRINT_FRAME_TIME |
0 | 34 |
936 | 35 int ff_h263_decode_init(AVCodecContext *avctx) |
0 | 36 { |
37 MpegEncContext *s = avctx->priv_data; | |
60 | 38 |
67 | 39 s->avctx = avctx; |
0 | 40 s->out_format = FMT_H263; |
41 | |
2270 | 42 s->width = avctx->coded_width; |
43 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
|
44 s->workaround_bugs= avctx->workaround_bugs; |
0 | 45 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
46 // set defaults |
1892 | 47 MPV_decode_defaults(s); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
48 s->quant_precision=5; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
49 s->decode_mb= ff_h263_decode_mb; |
924 | 50 s->low_delay= 1; |
939 | 51 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
|
52 s->unrestricted_mv= 1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
53 |
0 | 54 /* select sub codec */ |
55 switch(avctx->codec->id) { | |
56 case CODEC_ID_H263: | |
1639 | 57 s->unrestricted_mv= 0; |
0 | 58 break; |
67 | 59 case CODEC_ID_MPEG4: |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1644
diff
changeset
|
60 s->decode_mb= ff_mpeg4_decode_mb; |
0 | 61 s->time_increment_bits = 4; /* default value for broken headers */ |
62 s->h263_pred = 1; | |
924 | 63 s->low_delay = 0; //default, might be overriden in the vol header during header parsing |
0 | 64 break; |
307 | 65 case CODEC_ID_MSMPEG4V1: |
0 | 66 s->h263_msmpeg4 = 1; |
67 s->h263_pred = 1; | |
307 | 68 s->msmpeg4_version=1; |
69 break; | |
70 case CODEC_ID_MSMPEG4V2: | |
71 s->h263_msmpeg4 = 1; | |
72 s->h263_pred = 1; | |
73 s->msmpeg4_version=2; | |
74 break; | |
75 case CODEC_ID_MSMPEG4V3: | |
76 s->h263_msmpeg4 = 1; | |
77 s->h263_pred = 1; | |
78 s->msmpeg4_version=3; | |
0 | 79 break; |
311 | 80 case CODEC_ID_WMV1: |
81 s->h263_msmpeg4 = 1; | |
82 s->h263_pred = 1; | |
83 s->msmpeg4_version=4; | |
84 break; | |
498 | 85 case CODEC_ID_WMV2: |
86 s->h263_msmpeg4 = 1; | |
87 s->h263_pred = 1; | |
88 s->msmpeg4_version=5; | |
89 break; | |
3368
19620d64a239
Fix initialization of vc1_decoder (the same as wmv3_decoder).
kostya
parents:
3185
diff
changeset
|
90 case CODEC_ID_VC1: |
2474 | 91 case CODEC_ID_WMV3: |
92 s->h263_msmpeg4 = 1; | |
93 s->h263_pred = 1; | |
94 s->msmpeg4_version=6; | |
95 break; | |
0 | 96 case CODEC_ID_H263I: |
97 break; | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
98 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
99 s->h263_flv = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
100 break; |
0 | 101 default: |
102 return -1; | |
103 } | |
344 | 104 s->codec_id= avctx->codec->id; |
553 | 105 |
0 | 106 /* 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
|
107 if (avctx->codec->id != CODEC_ID_H263 && avctx->codec->id != CODEC_ID_MPEG4) |
144 | 108 if (MPV_common_init(s) < 0) |
109 return -1; | |
0 | 110 |
111 if (s->h263_msmpeg4) | |
498 | 112 ff_msmpeg4_decode_init(s); |
0 | 113 else |
114 h263_decode_init_vlc(s); | |
2967 | 115 |
0 | 116 return 0; |
117 } | |
118 | |
936 | 119 int ff_h263_decode_end(AVCodecContext *avctx) |
0 | 120 { |
121 MpegEncContext *s = avctx->priv_data; | |
122 | |
123 MPV_common_end(s); | |
124 return 0; | |
125 } | |
126 | |
655 | 127 /** |
2764 | 128 * returns the number of bytes consumed for building the current frame |
655 | 129 */ |
130 static int get_consumed_bytes(MpegEncContext *s, int buf_size){ | |
131 int pos= (get_bits_count(&s->gb)+7)>>3; | |
2967 | 132 |
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
|
133 if(s->divx_packed){ |
655 | 134 //we would have to scan through the whole buf to handle the weird reordering ... |
2967 | 135 return buf_size; |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
136 }else if(s->flags&CODEC_FLAG_TRUNCATED){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
137 pos -= s->parse_context.last_index; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
138 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
|
139 return pos; |
655 | 140 }else{ |
141 if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...) | |
658 | 142 if(pos+10>buf_size) pos=buf_size; // oops ;) |
655 | 143 |
144 return pos; | |
145 } | |
146 } | |
147 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
148 static int decode_slice(MpegEncContext *s){ |
1144 | 149 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; |
2261 | 150 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
|
151 s->last_resync_gb= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
152 s->first_slice_line= 1; |
2967 | 153 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
154 s->resync_mb_x= s->mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
155 s->resync_mb_y= s->mb_y; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
156 |
1652 | 157 ff_set_qscale(s, s->qscale); |
2967 | 158 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
159 if(s->partitioned_frame){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
160 const int qscale= s->qscale; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
161 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
162 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
163 if(ff_mpeg4_decode_partitions(s) < 0) |
2967 | 164 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
165 } |
2967 | 166 |
1427 | 167 /* restore variables which were modified */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
168 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
169 s->mb_x= s->resync_mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
170 s->mb_y= s->resync_mb_y; |
1652 | 171 ff_set_qscale(s, qscale); |
745
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 } |
2967 | 183 |
745
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 } |
2967 | 189 |
745
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){ |
2967 | 197 s->first_slice_line=0; |
745
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 */ |
2967 | 201 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
202 s->mv_dir = MV_DIR_FORWARD; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
203 s->mv_type = MV_TYPE_16X16; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2552
diff
changeset
|
204 // s->mb_skipped = 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
205 //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
|
206 ret= s->decode_mb(s, s->block); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
207 |
1389 | 208 if (s->pict_type!=B_TYPE) |
209 ff_h263_update_motion_val(s); | |
210 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
211 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
|
212 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
|
213 if(ret==SLICE_END){ |
1338 | 214 MPV_decode_mb(s, s->block); |
1644 | 215 if(s->loop_filter) |
216 ff_h263_loop_filter(s); | |
1338 | 217 |
758 | 218 //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 | 219 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 | 220 |
221 s->padding_bug_score--; | |
2967 | 222 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
223 if(++s->mb_x >= s->mb_width){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
224 s->mb_x=0; |
2261 | 225 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
|
226 s->mb_y++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
227 } |
2967 | 228 return 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
229 }else if(ret==SLICE_NOEND){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
230 av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy); |
1144 | 231 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
|
232 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
233 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
234 av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy); |
1144 | 235 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); |
2967 | 236 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
237 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
238 } |
1338 | 239 |
240 MPV_decode_mb(s, s->block); | |
1644 | 241 if(s->loop_filter) |
242 ff_h263_loop_filter(s); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
243 } |
2967 | 244 |
2261 | 245 ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size); |
2967 | 246 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
247 s->mb_x= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
248 } |
2967 | 249 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
250 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
|
251 |
750 | 252 /* try to detect the padding bug */ |
253 if( s->codec_id==CODEC_ID_MPEG4 | |
2967 | 254 && (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
|
255 && 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
|
256 && 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
|
257 // && !s->resync_marker |
750 | 258 && !s->data_partitioning){ |
2967 | 259 |
750 | 260 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
|
261 const int bits_left = s->gb.size_in_bits - bits_count; |
2967 | 262 |
1003 | 263 if(bits_left==0){ |
264 s->padding_bug_score+=16; | |
824 | 265 } else if(bits_left != 1){ |
750 | 266 int v= show_bits(&s->gb, 8); |
267 v|= 0x7F >> (7-(bits_count&7)); | |
824 | 268 |
2350 | 269 if(v==0x7F && bits_left<=8) |
750 | 270 s->padding_bug_score--; |
2350 | 271 else if(v==0x7F && ((get_bits_count(&s->gb)+8)&8) && bits_left<=16) |
272 s->padding_bug_score+= 4; | |
750 | 273 else |
2967 | 274 s->padding_bug_score++; |
275 } | |
750 | 276 } |
2967 | 277 |
2350 | 278 if(s->workaround_bugs&FF_BUG_AUTODETECT){ |
2411
0427eb3579b6
fix decoding of http://mplayerhq.hu/~diego/problem.mov
michael
parents:
2350
diff
changeset
|
279 if(s->padding_bug_score > -2 && !s->data_partitioning /*&& (s->divx_version || !s->resync_marker)*/) |
2350 | 280 s->workaround_bugs |= FF_BUG_NO_PADDING; |
281 else | |
282 s->workaround_bugs &= ~FF_BUG_NO_PADDING; | |
283 } | |
750 | 284 |
2764 | 285 // handle formats which don't have unique end markers |
1004 | 286 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
|
287 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
|
288 int max_extra=7; |
2967 | 289 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
290 /* no markers in M$ crap */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
291 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
|
292 max_extra+= 17; |
2967 | 293 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
294 /* buggy padding but the frame should still end approximately at the bitstream end */ |
1004 | 295 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
|
296 max_extra+= 48; |
1004 | 297 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
|
298 max_extra+= 256*256*256*64; |
2967 | 299 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
300 if(left>max_extra){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
301 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
|
302 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
303 else if(left<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
304 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
|
305 }else |
1144 | 306 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); |
2967 | 307 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
308 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
309 } |
750 | 310 |
2967 | 311 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
|
312 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
|
313 show_bits(&s->gb, 24), s->padding_bug_score); |
2967 | 314 |
1144 | 315 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); |
316 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
317 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
318 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
319 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
320 /** |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
321 * finds the end of the current frame in the bitstream. |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
322 * @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
|
323 */ |
1988 | 324 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
|
325 int vop_found, i; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
326 uint32_t state; |
2967 | 327 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
328 vop_found= pc->frame_start_found; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
329 state= pc->state; |
2967 | 330 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
331 i=0; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
332 if(!vop_found){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
333 for(i=0; i<buf_size; i++){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
334 state= (state<<8) | buf[i]; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
335 if(state == 0x1B6){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
336 i++; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
337 vop_found=1; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
338 break; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
339 } |
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 } |
1211 | 342 |
1988 | 343 if(vop_found){ |
344 /* EOF considered as end of frame */ | |
345 if (buf_size == 0) | |
346 return 0; | |
347 for(; i<buf_size; i++){ | |
348 state= (state<<8) | buf[i]; | |
349 if((state&0xFFFFFF00) == 0x100){ | |
350 pc->frame_start_found=0; | |
2967 | 351 pc->state=-1; |
1988 | 352 return i-3; |
353 } | |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
354 } |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
355 } |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
356 pc->frame_start_found= vop_found; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
357 pc->state= state; |
1219 | 358 return END_NOT_FOUND; |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
359 } |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
360 |
1988 | 361 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
|
362 int vop_found, i; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
363 uint32_t state; |
2967 | 364 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
365 vop_found= pc->frame_start_found; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
366 state= pc->state; |
2967 | 367 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
368 i=0; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
369 if(!vop_found){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
370 for(i=0; i<buf_size; i++){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
371 state= (state<<8) | buf[i]; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
372 if(state>>(32-22) == 0x20){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
373 i++; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
374 vop_found=1; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
375 break; |
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 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
379 |
2967 | 380 if(vop_found){ |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
381 for(; i<buf_size; i++){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
382 state= (state<<8) | buf[i]; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
383 if(state>>(32-22) == 0x20){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
384 pc->frame_start_found=0; |
2967 | 385 pc->state=-1; |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
386 return i-3; |
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 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
389 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
390 pc->frame_start_found= vop_found; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
391 pc->state= state; |
2967 | 392 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
393 return END_NOT_FOUND; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
394 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
395 |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3368
diff
changeset
|
396 #ifdef CONFIG_H263_PARSER |
1988 | 397 static int h263_parse(AVCodecParserContext *s, |
398 AVCodecContext *avctx, | |
2967 | 399 uint8_t **poutbuf, int *poutbuf_size, |
1988 | 400 const uint8_t *buf, int buf_size) |
401 { | |
402 ParseContext *pc = s->priv_data; | |
403 int next; | |
2967 | 404 |
1988 | 405 next= h263_find_frame_end(pc, buf, buf_size); |
406 | |
407 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
408 *poutbuf = NULL; | |
409 *poutbuf_size = 0; | |
410 return buf_size; | |
411 } | |
412 | |
413 *poutbuf = (uint8_t *)buf; | |
414 *poutbuf_size = buf_size; | |
415 return next; | |
416 } | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3368
diff
changeset
|
417 #endif |
1988 | 418 |
2967 | 419 int ff_h263_decode_frame(AVCodecContext *avctx, |
0 | 420 void *data, int *data_size, |
1064 | 421 uint8_t *buf, int buf_size) |
0 | 422 { |
423 MpegEncContext *s = avctx->priv_data; | |
1453 | 424 int ret; |
2967 | 425 AVFrame *pict = data; |
426 | |
384 | 427 #ifdef PRINT_FRAME_TIME |
428 uint64_t time= rdtsc(); | |
429 #endif | |
0 | 430 #ifdef DEBUG |
3551 | 431 av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size); |
432 av_log(avctx, AV_LOG_DEBUG, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]); | |
0 | 433 #endif |
485 | 434 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1747
diff
changeset
|
435 s->flags2= avctx->flags2; |
454 | 436 |
1372 | 437 /* no supplementary picture */ |
0 | 438 if (buf_size == 0) { |
1372 | 439 /* special case for last picture */ |
440 if (s->low_delay==0 && s->next_picture_ptr) { | |
441 *pict= *(AVFrame*)s->next_picture_ptr; | |
442 s->next_picture_ptr= NULL; | |
443 | |
444 *data_size = sizeof(AVFrame); | |
445 } | |
446 | |
0 | 447 return 0; |
448 } | |
1026 | 449 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
450 if(s->flags&CODEC_FLAG_TRUNCATED){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
451 int next; |
2967 | 452 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
453 if(s->codec_id==CODEC_ID_MPEG4){ |
1988 | 454 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
|
455 }else if(s->codec_id==CODEC_ID_H263){ |
1988 | 456 next= h263_find_frame_end(&s->parse_context, buf, buf_size); |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
457 }else{ |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2552
diff
changeset
|
458 av_log(s->avctx, AV_LOG_ERROR, "this codec does not support truncated bitstreams\n"); |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
459 return -1; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
460 } |
2967 | 461 |
1988 | 462 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
|
463 return buf_size; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
464 } |
0 | 465 |
2967 | 466 |
763 | 467 retry: |
2967 | 468 |
1747 | 469 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
|
470 init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8); |
353 | 471 }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
|
472 init_get_bits(&s->gb, buf, buf_size*8); |
465 | 473 s->bitstream_buffer_size=0; |
0 | 474 |
718 | 475 if (!s->context_initialized) { |
752
97077dd24bfa
fixing alt_scan for the first frame (variable was reset)
michaelni
parents:
750
diff
changeset
|
476 if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix |
718 | 477 return -1; |
478 } | |
2967 | 479 |
1586 | 480 //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there |
481 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){ | |
482 int i= ff_find_unused_picture(s, 0); | |
483 s->current_picture_ptr= &s->picture[i]; | |
484 } | |
2967 | 485 |
0 | 486 /* let's go :-) */ |
936 | 487 if (s->msmpeg4_version==5) { |
488 ret= ff_wmv2_decode_picture_header(s); | |
489 } else if (s->msmpeg4_version) { | |
0 | 490 ret = msmpeg4_decode_picture_header(s); |
491 } 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
|
492 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
|
493 GetBitContext gb; |
2967 | 494 |
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
|
495 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
|
496 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
|
497 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
498 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
|
499 |
831 | 500 if(s->flags& CODEC_FLAG_LOW_DELAY) |
501 s->low_delay=1; | |
1687 | 502 } else if (s->codec_id == CODEC_ID_H263I) { |
0 | 503 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
|
504 } else if (s->h263_flv) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
505 ret = flv_h263_decode_picture_header(s); |
0 | 506 } else { |
507 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
|
508 } |
2967 | 509 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2552
diff
changeset
|
510 if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_size); |
1393 | 511 |
512 /* skip if the header was thrashed */ | |
513 if (ret < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
514 av_log(s->avctx, AV_LOG_ERROR, "header damaged\n"); |
1393 | 515 return -1; |
516 } | |
2967 | 517 |
924 | 518 avctx->has_b_frames= !s->low_delay; |
2967 | 519 |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
520 if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){ |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
521 if(s->stream_codec_tag == ff_get_fourcc("XVID") || |
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
522 s->codec_tag == ff_get_fourcc("XVID") || s->codec_tag == ff_get_fourcc("XVIX") || |
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
523 s->codec_tag == ff_get_fourcc("RMP4")) |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
524 s->xvid_build= -1; |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
525 #if 0 |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
526 if(s->codec_tag == ff_get_fourcc("DIVX") && s->vo_type==0 && s->vol_control_parameters==1 |
2967 | 527 && s->padding_bug_score > 0 && s->low_delay) // XVID with modified fourcc |
1457 | 528 s->xvid_build= -1; |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
529 #endif |
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
530 } |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
531 |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
532 if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){ |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
533 if(s->codec_tag == ff_get_fourcc("DIVX") && s->vo_type==0 && s->vol_control_parameters==0) |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
534 s->divx_version= 400; //divx 4 |
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
535 } |
2967 | 536 |
2299 | 537 if(s->xvid_build && s->divx_version){ |
538 s->divx_version= | |
539 s->divx_build= 0; | |
540 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
541 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
542 if(s->workaround_bugs&FF_BUG_AUTODETECT){ |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
543 if(s->codec_tag == ff_get_fourcc("XVIX")) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
544 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
|
545 |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
546 if(s->codec_tag == ff_get_fourcc("UMP4")){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
547 s->workaround_bugs|= FF_BUG_UMP4; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
548 } |
760 | 549 |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
550 if(s->divx_version>=500){ |
760 | 551 s->workaround_bugs|= FF_BUG_QPEL_CHROMA; |
552 } | |
761 | 553 |
1048 | 554 if(s->divx_version>502){ |
555 s->workaround_bugs|= FF_BUG_QPEL_CHROMA2; | |
556 } | |
557 | |
938
1e22655551b9
xvid build 3 still has the padding wrong in 1/8 of the cases :(((((
michaelni
parents:
936
diff
changeset
|
558 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
|
559 s->padding_bug_score= 256*256*256*64; |
2967 | 560 |
761 | 561 if(s->xvid_build && s->xvid_build<=1) |
562 s->workaround_bugs|= FF_BUG_QPEL_CHROMA; | |
563 | |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
564 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
|
565 s->workaround_bugs|= FF_BUG_EDGE; |
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
566 |
2004 | 567 if(s->xvid_build && s->xvid_build<=32) |
568 s->workaround_bugs|= FF_BUG_DC_CLIP; | |
569 | |
984 | 570 #define SET_QPEL_FUNC(postfix1, postfix2) \ |
571 s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\ | |
572 s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\ | |
573 s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2; | |
574 | |
575 if(s->lavc_build && s->lavc_build<4653) | |
576 s->workaround_bugs|= FF_BUG_STD_QPEL; | |
2967 | 577 |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
578 if(s->lavc_build && s->lavc_build<4655) |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
579 s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE; |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
580 |
1502 | 581 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
|
582 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
|
583 } |
2967 | 584 |
2004 | 585 if(s->lavc_build && s->lavc_build<=4712) |
586 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
|
587 |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
588 if(s->divx_version) |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
589 s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE; |
750 | 590 //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
|
591 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
|
592 s->padding_bug_score= 256*256*256*64; |
1137 | 593 |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1353
diff
changeset
|
594 if(s->divx_version && s->divx_version<500){ |
1137 | 595 s->workaround_bugs|= FF_BUG_EDGE; |
596 } | |
2967 | 597 |
1916 | 598 if(s->divx_version) |
599 s->workaround_bugs|= FF_BUG_HPEL_CHROMA; | |
750 | 600 #if 0 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
601 if(s->divx_version==500) |
1088
bb27c685fc72
fixing padding bug autodetection for some rare files, closes bug #647941
michaelni
parents:
1064
diff
changeset
|
602 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
|
603 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
604 /* 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
|
605 * lets hope this at least works |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
606 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
607 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
|
608 && 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
|
609 s->workaround_bugs|= FF_BUG_NO_PADDING; |
2967 | 610 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
611 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
|
612 s->workaround_bugs|= FF_BUG_NO_PADDING; |
750 | 613 #endif |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
614 } |
2967 | 615 |
984 | 616 if(s->workaround_bugs& FF_BUG_STD_QPEL){ |
617 SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c) | |
618 SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c) | |
619 SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c) | |
620 SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c) | |
621 SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c) | |
622 SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c) | |
623 | |
624 SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c) | |
625 SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c) | |
626 SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c) | |
627 SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c) | |
628 SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c) | |
629 SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c) | |
630 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
631 |
1457 | 632 if(avctx->debug & FF_DEBUG_BUGS) |
2967 | 633 av_log(s->avctx, AV_LOG_DEBUG, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n", |
1457 | 634 s->workaround_bugs, s->lavc_build, s->xvid_build, s->divx_version, s->divx_build, |
635 s->divx_packed ? "p" : ""); | |
2967 | 636 |
585
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
637 #if 0 // dump bits per frame / qp / complexity |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
638 { |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
639 static FILE *f=NULL; |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
640 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
|
641 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
|
642 } |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
643 #endif |
2096 | 644 |
2869 | 645 #if defined(HAVE_MMX) && defined(CONFIG_GPL) |
2977 | 646 if(s->codec_id == CODEC_ID_MPEG4 && s->xvid_build && avctx->idct_algo == FF_IDCT_AUTO && (mm_flags & MM_MMX)){ |
2869 | 647 avctx->idct_algo= FF_IDCT_XVIDMMX; |
2278 | 648 avctx->coded_width= 0; // force reinit |
2968
383eee00b898
fix custom matrix permutation if xvid idct is autoselected and you have bad luck
michael
parents:
2967
diff
changeset
|
649 // dsputil_init(&s->dsp, avctx); |
383eee00b898
fix custom matrix permutation if xvid idct is autoselected and you have bad luck
michael
parents:
2967
diff
changeset
|
650 s->picture_number=0; |
2094
9c29987380e4
use libmpeg2 idct to decode xvid videos unless the user forced some other idct
michael
parents:
2052
diff
changeset
|
651 } |
2096 | 652 #endif |
653 | |
274
d0c186bcf075
use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents:
273
diff
changeset
|
654 /* After H263 & mpeg4 header decode we have the height, width,*/ |
160 | 655 /* and other parameters. So then we could init the picture */ |
656 /* FIXME: By the way H263 decoder is evolving it should have */ | |
657 /* an H263EncContext */ | |
2967 | 658 |
659 if ( s->width != avctx->coded_width | |
2270 | 660 || s->height != avctx->coded_height) { |
553 | 661 /* H.263 could change picture size any time */ |
1536 | 662 ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat |
663 s->parse_context.buffer=0; | |
553 | 664 MPV_common_end(s); |
1536 | 665 s->parse_context= pc; |
553 | 666 } |
274
d0c186bcf075
use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents:
273
diff
changeset
|
667 if (!s->context_initialized) { |
2270 | 668 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
|
669 |
763 | 670 goto retry; |
0 | 671 } |
758 | 672 |
673 if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P)) | |
674 s->gob_index = ff_h263_get_gob_height(s); | |
2967 | 675 |
903 | 676 // for hurry_up==5 |
677 s->current_picture.pict_type= s->pict_type; | |
678 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
|
679 |
2764 | 680 /* skip B-frames if we don't have reference frames */ |
2052 | 681 if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)) return get_consumed_bytes(s, buf_size); |
345 | 682 /* 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
|
683 if(avctx->hurry_up && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size); |
2792 | 684 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE) |
685 || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE) | |
2967 | 686 || avctx->skip_frame >= AVDISCARD_ALL) |
2792 | 687 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
|
688 /* 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
|
689 if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size); |
2967 | 690 |
454 | 691 if(s->next_p_frame_damaged){ |
692 if(s->pict_type==B_TYPE) | |
655 | 693 return get_consumed_bytes(s, buf_size); |
454 | 694 else |
695 s->next_p_frame_damaged=0; | |
696 } | |
697 | |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3551
diff
changeset
|
698 if((s->avctx->flags2 & CODEC_FLAG2_FAST) && s->pict_type==B_TYPE){ |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3551
diff
changeset
|
699 s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab; |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3551
diff
changeset
|
700 s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab; |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3551
diff
changeset
|
701 }else if((!s->no_rounding) || s->pict_type==B_TYPE){ |
3926 | 702 s->me.qpel_put= s->dsp.put_qpel_pixels_tab; |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3551
diff
changeset
|
703 s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab; |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3551
diff
changeset
|
704 }else{ |
3926 | 705 s->me.qpel_put= s->dsp.put_no_rnd_qpel_pixels_tab; |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3551
diff
changeset
|
706 s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab; |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3551
diff
changeset
|
707 } |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3551
diff
changeset
|
708 |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
763
diff
changeset
|
709 if(MPV_frame_start(s, avctx) < 0) |
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
763
diff
changeset
|
710 return -1; |
0 | 711 |
712 #ifdef DEBUG | |
3177 | 713 av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale); |
0 | 714 #endif |
715 | |
1144 | 716 ff_er_frame_start(s); |
2967 | 717 |
1183 | 718 //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type |
719 //which isnt available before MPV_frame_start() | |
720 if (s->msmpeg4_version==5){ | |
721 if(ff_wmv2_decode_secondary_picture_header(s) < 0) | |
722 return -1; | |
723 } | |
724 | |
0 | 725 /* decode each macroblock */ |
2967 | 726 s->mb_x=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
727 s->mb_y=0; |
2967 | 728 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
729 decode_slice(s); |
1183 | 730 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
|
731 if(s->msmpeg4_version){ |
1183 | 732 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
|
733 break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
734 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
735 if(ff_h263_resync(s)<0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
736 break; |
454 | 737 } |
2967 | 738 |
983 | 739 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
|
740 ff_mpeg4_clean_buffers(s); |
454 | 741 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
742 decode_slice(s); |
0 | 743 } |
756 | 744 |
311 | 745 if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE) |
903 | 746 if(msmpeg4_decode_ext_header(s, buf_size) < 0){ |
747 s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR; | |
748 } | |
2967 | 749 |
333 | 750 /* 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
|
751 if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_packed){ |
454 | 752 int current_pos= get_bits_count(&s->gb)>>3; |
1747 | 753 int startcode_found=0; |
2967 | 754 |
2422 | 755 if(buf_size - current_pos > 5){ |
454 | 756 int i; |
655 | 757 for(i=current_pos; i<buf_size-3; i++){ |
454 | 758 if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){ |
759 startcode_found=1; | |
760 break; | |
761 } | |
762 } | |
1747 | 763 } |
764 if(s->gb.buffer == s->bitstream_buffer && buf_size>20){ //xvid style | |
765 startcode_found=1; | |
766 current_pos=0; | |
767 } | |
768 | |
769 if(startcode_found){ | |
2422 | 770 s->bitstream_buffer= av_fast_realloc( |
2967 | 771 s->bitstream_buffer, |
772 &s->allocated_bitstream_buffer_size, | |
2422 | 773 buf_size - current_pos + FF_INPUT_BUFFER_PADDING_SIZE); |
1747 | 774 memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos); |
775 s->bitstream_buffer_size= buf_size - current_pos; | |
454 | 776 } |
777 } | |
778 | |
1144 | 779 ff_er_frame_end(s); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
780 |
0 | 781 MPV_frame_end(s); |
984 | 782 |
1285 | 783 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type); |
784 assert(s->current_picture.pict_type == s->pict_type); | |
3185 | 785 if (s->pict_type == B_TYPE || s->low_delay) { |
786 *pict= *(AVFrame*)s->current_picture_ptr; | |
787 } else if (s->last_picture_ptr != NULL) { | |
788 *pict= *(AVFrame*)s->last_picture_ptr; | |
789 } | |
790 | |
791 if(s->last_picture_ptr || s->low_delay){ | |
792 *data_size = sizeof(AVFrame); | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1687
diff
changeset
|
793 ff_print_debug_info(s, pict); |
262 | 794 } |
931 | 795 |
231 | 796 /* Return the Picture timestamp as the frame number */ |
797 /* we substract 1 because it is added on utils.c */ | |
798 avctx->frame_number = s->picture_number - 1; | |
799 | |
384 | 800 #ifdef PRINT_FRAME_TIME |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
3947
diff
changeset
|
801 av_log(avctx, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time); |
384 | 802 #endif |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
803 |
655 | 804 return get_consumed_bytes(s, buf_size); |
0 | 805 } |
806 | |
67 | 807 AVCodec mpeg4_decoder = { |
808 "mpeg4", | |
0 | 809 CODEC_TYPE_VIDEO, |
67 | 810 CODEC_ID_MPEG4, |
0 | 811 sizeof(MpegEncContext), |
936 | 812 ff_h263_decode_init, |
0 | 813 NULL, |
936 | 814 ff_h263_decode_end, |
815 ff_h263_decode_frame, | |
2453 | 816 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
1368 | 817 .flush= ff_mpeg_flush, |
0 | 818 }; |
819 | |
820 AVCodec h263_decoder = { | |
821 "h263", | |
822 CODEC_TYPE_VIDEO, | |
823 CODEC_ID_H263, | |
824 sizeof(MpegEncContext), | |
936 | 825 ff_h263_decode_init, |
0 | 826 NULL, |
936 | 827 ff_h263_decode_end, |
828 ff_h263_decode_frame, | |
2453 | 829 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
1368 | 830 .flush= ff_mpeg_flush, |
0 | 831 }; |
832 | |
307 | 833 AVCodec msmpeg4v1_decoder = { |
834 "msmpeg4v1", | |
835 CODEC_TYPE_VIDEO, | |
836 CODEC_ID_MSMPEG4V1, | |
837 sizeof(MpegEncContext), | |
936 | 838 ff_h263_decode_init, |
307 | 839 NULL, |
936 | 840 ff_h263_decode_end, |
841 ff_h263_decode_frame, | |
553 | 842 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
307 | 843 }; |
844 | |
845 AVCodec msmpeg4v2_decoder = { | |
846 "msmpeg4v2", | |
847 CODEC_TYPE_VIDEO, | |
848 CODEC_ID_MSMPEG4V2, | |
849 sizeof(MpegEncContext), | |
936 | 850 ff_h263_decode_init, |
307 | 851 NULL, |
936 | 852 ff_h263_decode_end, |
853 ff_h263_decode_frame, | |
553 | 854 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
307 | 855 }; |
856 | |
857 AVCodec msmpeg4v3_decoder = { | |
0 | 858 "msmpeg4", |
859 CODEC_TYPE_VIDEO, | |
307 | 860 CODEC_ID_MSMPEG4V3, |
0 | 861 sizeof(MpegEncContext), |
936 | 862 ff_h263_decode_init, |
0 | 863 NULL, |
936 | 864 ff_h263_decode_end, |
865 ff_h263_decode_frame, | |
553 | 866 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
0 | 867 }; |
868 | |
311 | 869 AVCodec wmv1_decoder = { |
870 "wmv1", | |
871 CODEC_TYPE_VIDEO, | |
872 CODEC_ID_WMV1, | |
873 sizeof(MpegEncContext), | |
936 | 874 ff_h263_decode_init, |
311 | 875 NULL, |
936 | 876 ff_h263_decode_end, |
877 ff_h263_decode_frame, | |
553 | 878 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
498 | 879 }; |
880 | |
0 | 881 AVCodec h263i_decoder = { |
882 "h263i", | |
883 CODEC_TYPE_VIDEO, | |
884 CODEC_ID_H263I, | |
885 sizeof(MpegEncContext), | |
936 | 886 ff_h263_decode_init, |
0 | 887 NULL, |
936 | 888 ff_h263_decode_end, |
889 ff_h263_decode_frame, | |
553 | 890 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
0 | 891 }; |
892 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
893 AVCodec flv_decoder = { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
894 "flv", |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
895 CODEC_TYPE_VIDEO, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
896 CODEC_ID_FLV1, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
897 sizeof(MpegEncContext), |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
898 ff_h263_decode_init, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
899 NULL, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
900 ff_h263_decode_end, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
901 ff_h263_decode_frame, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
902 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
|
903 }; |
1988 | 904 |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3368
diff
changeset
|
905 #ifdef CONFIG_H263_PARSER |
1988 | 906 AVCodecParser h263_parser = { |
907 { CODEC_ID_H263 }, | |
908 sizeof(ParseContext), | |
909 NULL, | |
910 h263_parse, | |
911 ff_parse_close, | |
912 }; | |
3455
cc4b4ea83e29
--enable/disable parsers. Warning: some combinations are broken.
mru
parents:
3368
diff
changeset
|
913 #endif |