Mercurial > libavcodec.hg
annotate h263dec.c @ 8991:ca768cb2bfb6 libavcodec
Use last decoded SPS as current SPS in order to parse picture timing SEI
correctly. This works around an apparent H.264 standard deficiency.
Patch by Ivan Schreter, schreter gmx net
author | cehoyos |
---|---|
date | Fri, 20 Feb 2009 16:20:01 +0000 |
parents | 8ec0175bbcb5 |
children | 15a3df8c01fd |
rev | line source |
---|---|
0 | 1 /* |
1106 | 2 * H.263 decoder |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8612
diff
changeset
|
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 /** |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8672
diff
changeset
|
24 * @file libavcodec/h263dec.c |
1106 | 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" | |
4938 | 31 #include "h263_parser.h" |
4957
3fcb2f0d9ef1
move ff_mpeg4_find_frame_end() from h263dec.c to mpeg4video_parser.c
aurel
parents:
4938
diff
changeset
|
32 #include "mpeg4video_parser.h" |
4967
6d45158e0249
disable reference to msmpeg4 and wmv2 code when those codecs are not compiled in
aurel
parents:
4957
diff
changeset
|
33 #include "msmpeg4.h" |
0 | 34 |
35 //#define DEBUG | |
384 | 36 //#define PRINT_FRAME_TIME |
0 | 37 |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6481
diff
changeset
|
38 av_cold int ff_h263_decode_init(AVCodecContext *avctx) |
0 | 39 { |
40 MpegEncContext *s = avctx->priv_data; | |
60 | 41 |
67 | 42 s->avctx = avctx; |
0 | 43 s->out_format = FMT_H263; |
44 | |
2270 | 45 s->width = avctx->coded_width; |
46 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
|
47 s->workaround_bugs= avctx->workaround_bugs; |
0 | 48 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
49 // set defaults |
1892 | 50 MPV_decode_defaults(s); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
51 s->quant_precision=5; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
52 s->decode_mb= ff_h263_decode_mb; |
924 | 53 s->low_delay= 1; |
939 | 54 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
|
55 s->unrestricted_mv= 1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
56 |
0 | 57 /* select sub codec */ |
58 switch(avctx->codec->id) { | |
59 case CODEC_ID_H263: | |
1639 | 60 s->unrestricted_mv= 0; |
0 | 61 break; |
67 | 62 case CODEC_ID_MPEG4: |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1644
diff
changeset
|
63 s->decode_mb= ff_mpeg4_decode_mb; |
0 | 64 s->time_increment_bits = 4; /* default value for broken headers */ |
65 s->h263_pred = 1; | |
924 | 66 s->low_delay = 0; //default, might be overriden in the vol header during header parsing |
0 | 67 break; |
307 | 68 case CODEC_ID_MSMPEG4V1: |
0 | 69 s->h263_msmpeg4 = 1; |
70 s->h263_pred = 1; | |
307 | 71 s->msmpeg4_version=1; |
72 break; | |
73 case CODEC_ID_MSMPEG4V2: | |
74 s->h263_msmpeg4 = 1; | |
75 s->h263_pred = 1; | |
76 s->msmpeg4_version=2; | |
77 break; | |
78 case CODEC_ID_MSMPEG4V3: | |
79 s->h263_msmpeg4 = 1; | |
80 s->h263_pred = 1; | |
81 s->msmpeg4_version=3; | |
0 | 82 break; |
311 | 83 case CODEC_ID_WMV1: |
84 s->h263_msmpeg4 = 1; | |
85 s->h263_pred = 1; | |
86 s->msmpeg4_version=4; | |
87 break; | |
498 | 88 case CODEC_ID_WMV2: |
89 s->h263_msmpeg4 = 1; | |
90 s->h263_pred = 1; | |
91 s->msmpeg4_version=5; | |
92 break; | |
3368
19620d64a239
Fix initialization of vc1_decoder (the same as wmv3_decoder).
kostya
parents:
3185
diff
changeset
|
93 case CODEC_ID_VC1: |
2474 | 94 case CODEC_ID_WMV3: |
95 s->h263_msmpeg4 = 1; | |
96 s->h263_pred = 1; | |
97 s->msmpeg4_version=6; | |
98 break; | |
0 | 99 case CODEC_ID_H263I: |
100 break; | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
101 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
102 s->h263_flv = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
103 break; |
0 | 104 default: |
105 return -1; | |
106 } | |
344 | 107 s->codec_id= avctx->codec->id; |
553 | 108 |
0 | 109 /* 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
|
110 if (avctx->codec->id != CODEC_ID_H263 && avctx->codec->id != CODEC_ID_MPEG4) |
144 | 111 if (MPV_common_init(s) < 0) |
112 return -1; | |
0 | 113 |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
114 if (CONFIG_MSMPEG4_DECODER && s->h263_msmpeg4) |
498 | 115 ff_msmpeg4_decode_init(s); |
0 | 116 else |
117 h263_decode_init_vlc(s); | |
2967 | 118 |
0 | 119 return 0; |
120 } | |
121 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6481
diff
changeset
|
122 av_cold int ff_h263_decode_end(AVCodecContext *avctx) |
0 | 123 { |
124 MpegEncContext *s = avctx->priv_data; | |
125 | |
126 MPV_common_end(s); | |
127 return 0; | |
128 } | |
129 | |
655 | 130 /** |
2764 | 131 * returns the number of bytes consumed for building the current frame |
655 | 132 */ |
133 static int get_consumed_bytes(MpegEncContext *s, int buf_size){ | |
134 int pos= (get_bits_count(&s->gb)+7)>>3; | |
2967 | 135 |
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
|
136 if(s->divx_packed){ |
655 | 137 //we would have to scan through the whole buf to handle the weird reordering ... |
2967 | 138 return buf_size; |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
139 }else if(s->flags&CODEC_FLAG_TRUNCATED){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
140 pos -= s->parse_context.last_index; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
141 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
|
142 return pos; |
655 | 143 }else{ |
5127 | 144 if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...) |
658 | 145 if(pos+10>buf_size) pos=buf_size; // oops ;) |
655 | 146 |
147 return pos; | |
148 } | |
149 } | |
150 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
151 static int decode_slice(MpegEncContext *s){ |
1144 | 152 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; |
2261 | 153 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
|
154 s->last_resync_gb= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
155 s->first_slice_line= 1; |
2967 | 156 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
157 s->resync_mb_x= s->mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
158 s->resync_mb_y= s->mb_y; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
159 |
1652 | 160 ff_set_qscale(s, s->qscale); |
2967 | 161 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
162 if(s->partitioned_frame){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
163 const int qscale= s->qscale; |
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 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
166 if(ff_mpeg4_decode_partitions(s) < 0) |
2967 | 167 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
168 } |
2967 | 169 |
1427 | 170 /* restore variables which were modified */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
171 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
172 s->mb_x= s->resync_mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
173 s->mb_y= s->resync_mb_y; |
1652 | 174 ff_set_qscale(s, qscale); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
175 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
176 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
177 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
|
178 /* per-row end of slice checks */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
179 if(s->msmpeg4_version){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
180 if(s->resync_mb_y + s->slice_height == s->mb_y){ |
1144 | 181 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); |
182 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
183 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
184 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
185 } |
2967 | 186 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
187 if(s->msmpeg4_version==1){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
188 s->last_dc[0]= |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
189 s->last_dc[1]= |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
190 s->last_dc[2]= 128; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
191 } |
2967 | 192 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
193 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
194 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
|
195 int ret; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
196 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
197 ff_update_block_index(s); |
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 if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){ |
2967 | 200 s->first_slice_line=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
201 } |
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 /* DCT & quantize */ |
2967 | 204 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
205 s->mv_dir = MV_DIR_FORWARD; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
206 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
|
207 // s->mb_skipped = 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
208 //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
|
209 ret= s->decode_mb(s, s->block); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
210 |
6481 | 211 if (s->pict_type!=FF_B_TYPE) |
1389 | 212 ff_h263_update_motion_val(s); |
213 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
214 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
|
215 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
|
216 if(ret==SLICE_END){ |
1338 | 217 MPV_decode_mb(s, s->block); |
1644 | 218 if(s->loop_filter) |
219 ff_h263_loop_filter(s); | |
1338 | 220 |
758 | 221 //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 | 222 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 | 223 |
224 s->padding_bug_score--; | |
2967 | 225 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
226 if(++s->mb_x >= s->mb_width){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
227 s->mb_x=0; |
2261 | 228 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
|
229 s->mb_y++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
230 } |
2967 | 231 return 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
232 }else if(ret==SLICE_NOEND){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
233 av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy); |
1144 | 234 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
|
235 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
236 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
237 av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy); |
1144 | 238 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 | 239 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
240 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
241 } |
1338 | 242 |
243 MPV_decode_mb(s, s->block); | |
1644 | 244 if(s->loop_filter) |
245 ff_h263_loop_filter(s); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
246 } |
2967 | 247 |
2261 | 248 ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size); |
2967 | 249 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
250 s->mb_x= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
251 } |
2967 | 252 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
253 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
|
254 |
750 | 255 /* try to detect the padding bug */ |
256 if( s->codec_id==CODEC_ID_MPEG4 | |
2967 | 257 && (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
|
258 && 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
|
259 && 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
|
260 // && !s->resync_marker |
750 | 261 && !s->data_partitioning){ |
2967 | 262 |
750 | 263 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
|
264 const int bits_left = s->gb.size_in_bits - bits_count; |
2967 | 265 |
1003 | 266 if(bits_left==0){ |
267 s->padding_bug_score+=16; | |
824 | 268 } else if(bits_left != 1){ |
750 | 269 int v= show_bits(&s->gb, 8); |
270 v|= 0x7F >> (7-(bits_count&7)); | |
824 | 271 |
2350 | 272 if(v==0x7F && bits_left<=8) |
750 | 273 s->padding_bug_score--; |
2350 | 274 else if(v==0x7F && ((get_bits_count(&s->gb)+8)&8) && bits_left<=16) |
275 s->padding_bug_score+= 4; | |
750 | 276 else |
2967 | 277 s->padding_bug_score++; |
278 } | |
750 | 279 } |
2967 | 280 |
2350 | 281 if(s->workaround_bugs&FF_BUG_AUTODETECT){ |
2411
0427eb3579b6
fix decoding of http://mplayerhq.hu/~diego/problem.mov
michael
parents:
2350
diff
changeset
|
282 if(s->padding_bug_score > -2 && !s->data_partitioning /*&& (s->divx_version || !s->resync_marker)*/) |
2350 | 283 s->workaround_bugs |= FF_BUG_NO_PADDING; |
284 else | |
285 s->workaround_bugs &= ~FF_BUG_NO_PADDING; | |
286 } | |
750 | 287 |
2764 | 288 // handle formats which don't have unique end markers |
1004 | 289 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
|
290 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
|
291 int max_extra=7; |
2967 | 292 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
293 /* no markers in M$ crap */ |
6481 | 294 if(s->msmpeg4_version && s->pict_type==FF_I_TYPE) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
295 max_extra+= 17; |
2967 | 296 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
297 /* buggy padding but the frame should still end approximately at the bitstream end */ |
7831 | 298 if((s->workaround_bugs&FF_BUG_NO_PADDING) && s->error_recognition>=3) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
299 max_extra+= 48; |
1004 | 300 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
|
301 max_extra+= 256*256*256*64; |
2967 | 302 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
303 if(left>max_extra){ |
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, "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
|
305 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
306 else if(left<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
307 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
|
308 }else |
1144 | 309 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 | 310 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
311 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
312 } |
750 | 313 |
2967 | 314 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
|
315 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
|
316 show_bits(&s->gb, 24), s->padding_bug_score); |
2967 | 317 |
1144 | 318 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); |
319 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
320 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
321 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
322 |
2967 | 323 int ff_h263_decode_frame(AVCodecContext *avctx, |
0 | 324 void *data, int *data_size, |
6269 | 325 const uint8_t *buf, int buf_size) |
0 | 326 { |
327 MpegEncContext *s = avctx->priv_data; | |
1453 | 328 int ret; |
2967 | 329 AVFrame *pict = data; |
330 | |
384 | 331 #ifdef PRINT_FRAME_TIME |
332 uint64_t time= rdtsc(); | |
333 #endif | |
0 | 334 #ifdef DEBUG |
3551 | 335 av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size); |
4636 | 336 if(buf_size>0) |
337 av_log(avctx, AV_LOG_DEBUG, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]); | |
0 | 338 #endif |
485 | 339 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1747
diff
changeset
|
340 s->flags2= avctx->flags2; |
454 | 341 |
1372 | 342 /* no supplementary picture */ |
0 | 343 if (buf_size == 0) { |
1372 | 344 /* special case for last picture */ |
345 if (s->low_delay==0 && s->next_picture_ptr) { | |
346 *pict= *(AVFrame*)s->next_picture_ptr; | |
347 s->next_picture_ptr= NULL; | |
348 | |
349 *data_size = sizeof(AVFrame); | |
350 } | |
351 | |
0 | 352 return 0; |
353 } | |
1026 | 354 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
355 if(s->flags&CODEC_FLAG_TRUNCATED){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
356 int next; |
2967 | 357 |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
358 if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){ |
1988 | 359 next= ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size); |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
360 }else if(CONFIG_H263_DECODER && s->codec_id==CODEC_ID_H263){ |
4938 | 361 next= ff_h263_find_frame_end(&s->parse_context, buf, buf_size); |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
362 }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
|
363 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
|
364 return -1; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
365 } |
2967 | 366 |
4931
0d1cc37d9430
make some parser parameters const to avoid casting const to non-const
aurel
parents:
4636
diff
changeset
|
367 if( ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 ) |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
368 return buf_size; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
369 } |
0 | 370 |
2967 | 371 |
763 | 372 retry: |
2967 | 373 |
1747 | 374 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
|
375 init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8); |
353 | 376 }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
|
377 init_get_bits(&s->gb, buf, buf_size*8); |
465 | 378 s->bitstream_buffer_size=0; |
0 | 379 |
718 | 380 if (!s->context_initialized) { |
752
97077dd24bfa
fixing alt_scan for the first frame (variable was reset)
michaelni
parents:
750
diff
changeset
|
381 if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix |
718 | 382 return -1; |
383 } | |
2967 | 384 |
5127 | 385 /* We need to set current_picture_ptr before reading the header, |
386 * otherwise we cannot store anyting in there */ | |
1586 | 387 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){ |
388 int i= ff_find_unused_picture(s, 0); | |
389 s->current_picture_ptr= &s->picture[i]; | |
390 } | |
2967 | 391 |
0 | 392 /* let's go :-) */ |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
393 if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5) { |
936 | 394 ret= ff_wmv2_decode_picture_header(s); |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
395 } else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) { |
0 | 396 ret = msmpeg4_decode_picture_header(s); |
397 } 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
|
398 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
|
399 GetBitContext gb; |
2967 | 400 |
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
|
401 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
|
402 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
|
403 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
404 ret = ff_mpeg4_decode_picture_header(s, &s->gb); |
1687 | 405 } else if (s->codec_id == CODEC_ID_H263I) { |
0 | 406 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
|
407 } else if (s->h263_flv) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
408 ret = flv_h263_decode_picture_header(s); |
0 | 409 } else { |
410 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
|
411 } |
2967 | 412 |
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
|
413 if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_size); |
1393 | 414 |
415 /* skip if the header was thrashed */ | |
416 if (ret < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
417 av_log(s->avctx, AV_LOG_ERROR, "header damaged\n"); |
1393 | 418 return -1; |
419 } | |
2967 | 420 |
924 | 421 avctx->has_b_frames= !s->low_delay; |
2967 | 422 |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
423 if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){ |
8612 | 424 if(s->stream_codec_tag == AV_RL32("XVID") || |
425 s->codec_tag == AV_RL32("XVID") || s->codec_tag == AV_RL32("XVIX") || | |
426 s->codec_tag == AV_RL32("RMP4")) | |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
427 s->xvid_build= -1; |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
428 #if 0 |
8612 | 429 if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==1 |
2967 | 430 && s->padding_bug_score > 0 && s->low_delay) // XVID with modified fourcc |
1457 | 431 s->xvid_build= -1; |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
432 #endif |
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
433 } |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
434 |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
435 if(s->xvid_build==0 && s->divx_version==0 && s->lavc_build==0){ |
8612 | 436 if(s->codec_tag == AV_RL32("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
|
437 s->divx_version= 400; //divx 4 |
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
438 } |
2967 | 439 |
2299 | 440 if(s->xvid_build && s->divx_version){ |
441 s->divx_version= | |
442 s->divx_build= 0; | |
443 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
444 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
445 if(s->workaround_bugs&FF_BUG_AUTODETECT){ |
8612 | 446 if(s->codec_tag == AV_RL32("XVIX")) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
447 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
|
448 |
8612 | 449 if(s->codec_tag == AV_RL32("UMP4")){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
450 s->workaround_bugs|= FF_BUG_UMP4; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
451 } |
760 | 452 |
5136 | 453 if(s->divx_version>=500 && s->divx_build<1814){ |
760 | 454 s->workaround_bugs|= FF_BUG_QPEL_CHROMA; |
455 } | |
761 | 456 |
5136 | 457 if(s->divx_version>502 && s->divx_build<1814){ |
1048 | 458 s->workaround_bugs|= FF_BUG_QPEL_CHROMA2; |
459 } | |
460 | |
938
1e22655551b9
xvid build 3 still has the padding wrong in 1/8 of the cases :(((((
michaelni
parents:
936
diff
changeset
|
461 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
|
462 s->padding_bug_score= 256*256*256*64; |
2967 | 463 |
761 | 464 if(s->xvid_build && s->xvid_build<=1) |
465 s->workaround_bugs|= FF_BUG_QPEL_CHROMA; | |
466 | |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
467 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
|
468 s->workaround_bugs|= FF_BUG_EDGE; |
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
469 |
2004 | 470 if(s->xvid_build && s->xvid_build<=32) |
471 s->workaround_bugs|= FF_BUG_DC_CLIP; | |
472 | |
984 | 473 #define SET_QPEL_FUNC(postfix1, postfix2) \ |
474 s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\ | |
475 s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\ | |
476 s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2; | |
477 | |
478 if(s->lavc_build && s->lavc_build<4653) | |
479 s->workaround_bugs|= FF_BUG_STD_QPEL; | |
2967 | 480 |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
481 if(s->lavc_build && s->lavc_build<4655) |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
482 s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE; |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
483 |
1502 | 484 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
|
485 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
|
486 } |
2967 | 487 |
2004 | 488 if(s->lavc_build && s->lavc_build<=4712) |
489 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
|
490 |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
491 if(s->divx_version) |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
492 s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE; |
750 | 493 //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
|
494 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
|
495 s->padding_bug_score= 256*256*256*64; |
1137 | 496 |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1353
diff
changeset
|
497 if(s->divx_version && s->divx_version<500){ |
1137 | 498 s->workaround_bugs|= FF_BUG_EDGE; |
499 } | |
2967 | 500 |
1916 | 501 if(s->divx_version) |
502 s->workaround_bugs|= FF_BUG_HPEL_CHROMA; | |
750 | 503 #if 0 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
504 if(s->divx_version==500) |
1088
bb27c685fc72
fixing padding bug autodetection for some rare files, closes bug #647941
michaelni
parents:
1064
diff
changeset
|
505 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
|
506 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
507 /* very ugly XVID padding bug detection FIXME/XXX solve this differently |
7377
3f819263176e
cosmetics: Fix two common typos: wont --> will not, lets --> let us.
diego
parents:
7040
diff
changeset
|
508 * Let us hope this at least works. |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
509 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
510 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
|
511 && 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
|
512 s->workaround_bugs|= FF_BUG_NO_PADDING; |
2967 | 513 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
514 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
|
515 s->workaround_bugs|= FF_BUG_NO_PADDING; |
750 | 516 #endif |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
517 } |
2967 | 518 |
984 | 519 if(s->workaround_bugs& FF_BUG_STD_QPEL){ |
520 SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c) | |
521 SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c) | |
522 SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c) | |
523 SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c) | |
524 SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c) | |
525 SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c) | |
526 | |
527 SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c) | |
528 SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c) | |
529 SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c) | |
530 SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c) | |
531 SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c) | |
532 SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c) | |
533 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
534 |
1457 | 535 if(avctx->debug & FF_DEBUG_BUGS) |
2967 | 536 av_log(s->avctx, AV_LOG_DEBUG, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n", |
1457 | 537 s->workaround_bugs, s->lavc_build, s->xvid_build, s->divx_version, s->divx_build, |
538 s->divx_packed ? "p" : ""); | |
2967 | 539 |
585
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
540 #if 0 // dump bits per frame / qp / complexity |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
541 { |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
542 static FILE *f=NULL; |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
543 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
|
544 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
|
545 } |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
546 #endif |
2096 | 547 |
8590 | 548 #if HAVE_MMX |
8104
0d108ec85620
Remove duplicated MM_* macros for CPU capabilities from dsputil.h.
rathann
parents:
7831
diff
changeset
|
549 if(s->codec_id == CODEC_ID_MPEG4 && s->xvid_build && avctx->idct_algo == FF_IDCT_AUTO && (mm_flags & FF_MM_MMX)){ |
2869 | 550 avctx->idct_algo= FF_IDCT_XVIDMMX; |
2278 | 551 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
|
552 // 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
|
553 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
|
554 } |
2096 | 555 #endif |
556 | |
274
d0c186bcf075
use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents:
273
diff
changeset
|
557 /* After H263 & mpeg4 header decode we have the height, width,*/ |
160 | 558 /* and other parameters. So then we could init the picture */ |
559 /* FIXME: By the way H263 decoder is evolving it should have */ | |
560 /* an H263EncContext */ | |
2967 | 561 |
562 if ( s->width != avctx->coded_width | |
2270 | 563 || s->height != avctx->coded_height) { |
553 | 564 /* H.263 could change picture size any time */ |
1536 | 565 ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat |
566 s->parse_context.buffer=0; | |
553 | 567 MPV_common_end(s); |
1536 | 568 s->parse_context= pc; |
553 | 569 } |
274
d0c186bcf075
use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents:
273
diff
changeset
|
570 if (!s->context_initialized) { |
2270 | 571 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
|
572 |
763 | 573 goto retry; |
0 | 574 } |
758 | 575 |
8800
8ec0175bbcb5
Initialize s->gob_index for Intel variant of H.263 too
kostya
parents:
8718
diff
changeset
|
576 if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P || s->codec_id == CODEC_ID_H263I)) |
758 | 577 s->gob_index = ff_h263_get_gob_height(s); |
2967 | 578 |
903 | 579 // for hurry_up==5 |
580 s->current_picture.pict_type= s->pict_type; | |
6481 | 581 s->current_picture.key_frame= s->pict_type == FF_I_TYPE; |
845
32de034be20e
hurry_up>=5 -> skip everything except header & set pict_type&key_frame
michaelni
parents:
842
diff
changeset
|
582 |
2764 | 583 /* skip B-frames if we don't have reference frames */ |
6481 | 584 if(s->last_picture_ptr==NULL && (s->pict_type==FF_B_TYPE || s->dropable)) return get_consumed_bytes(s, buf_size); |
345 | 585 /* skip b frames if we are in a hurry */ |
6481 | 586 if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return get_consumed_bytes(s, buf_size); |
587 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE) | |
588 || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE) | |
2967 | 589 || avctx->skip_frame >= AVDISCARD_ALL) |
2792 | 590 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
|
591 /* 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
|
592 if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size); |
2967 | 593 |
454 | 594 if(s->next_p_frame_damaged){ |
6481 | 595 if(s->pict_type==FF_B_TYPE) |
655 | 596 return get_consumed_bytes(s, buf_size); |
454 | 597 else |
598 s->next_p_frame_damaged=0; | |
599 } | |
600 | |
6481 | 601 if((s->avctx->flags2 & CODEC_FLAG2_FAST) && s->pict_type==FF_B_TYPE){ |
3807
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3551
diff
changeset
|
602 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
|
603 s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab; |
6481 | 604 }else if((!s->no_rounding) || s->pict_type==FF_B_TYPE){ |
3926 | 605 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
|
606 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
|
607 }else{ |
3926 | 608 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
|
609 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
|
610 } |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3551
diff
changeset
|
611 |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
763
diff
changeset
|
612 if(MPV_frame_start(s, avctx) < 0) |
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
763
diff
changeset
|
613 return -1; |
0 | 614 |
615 #ifdef DEBUG | |
3177 | 616 av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale); |
0 | 617 #endif |
618 | |
1144 | 619 ff_er_frame_start(s); |
2967 | 620 |
1183 | 621 //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type |
5127 | 622 //which is not available before MPV_frame_start() |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
623 if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5){ |
5887 | 624 ret = ff_wmv2_decode_secondary_picture_header(s); |
625 if(ret<0) return ret; | |
626 if(ret==1) goto intrax8_decoded; | |
1183 | 627 } |
628 | |
0 | 629 /* decode each macroblock */ |
2967 | 630 s->mb_x=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
631 s->mb_y=0; |
2967 | 632 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
633 decode_slice(s); |
1183 | 634 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
|
635 if(s->msmpeg4_version){ |
4386 | 636 if(s->slice_height==0 || s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_count(&s->gb) > s->gb.size_in_bits) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
637 break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
638 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
639 if(ff_h263_resync(s)<0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
640 break; |
454 | 641 } |
2967 | 642 |
983 | 643 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
|
644 ff_mpeg4_clean_buffers(s); |
454 | 645 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
646 decode_slice(s); |
0 | 647 } |
756 | 648 |
6481 | 649 if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==FF_I_TYPE) |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
650 if(!CONFIG_MSMPEG4_DECODER || msmpeg4_decode_ext_header(s, buf_size) < 0){ |
903 | 651 s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR; |
652 } | |
2967 | 653 |
333 | 654 /* 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
|
655 if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_packed){ |
454 | 656 int current_pos= get_bits_count(&s->gb)>>3; |
1747 | 657 int startcode_found=0; |
2967 | 658 |
2422 | 659 if(buf_size - current_pos > 5){ |
454 | 660 int i; |
655 | 661 for(i=current_pos; i<buf_size-3; i++){ |
454 | 662 if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){ |
663 startcode_found=1; | |
664 break; | |
665 } | |
666 } | |
1747 | 667 } |
668 if(s->gb.buffer == s->bitstream_buffer && buf_size>20){ //xvid style | |
669 startcode_found=1; | |
670 current_pos=0; | |
671 } | |
672 | |
673 if(startcode_found){ | |
2422 | 674 s->bitstream_buffer= av_fast_realloc( |
2967 | 675 s->bitstream_buffer, |
676 &s->allocated_bitstream_buffer_size, | |
2422 | 677 buf_size - current_pos + FF_INPUT_BUFFER_PADDING_SIZE); |
1747 | 678 memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos); |
679 s->bitstream_buffer_size= buf_size - current_pos; | |
454 | 680 } |
681 } | |
682 | |
5887 | 683 intrax8_decoded: |
1144 | 684 ff_er_frame_end(s); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
685 |
0 | 686 MPV_frame_end(s); |
984 | 687 |
1285 | 688 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type); |
689 assert(s->current_picture.pict_type == s->pict_type); | |
6481 | 690 if (s->pict_type == FF_B_TYPE || s->low_delay) { |
3185 | 691 *pict= *(AVFrame*)s->current_picture_ptr; |
692 } else if (s->last_picture_ptr != NULL) { | |
693 *pict= *(AVFrame*)s->last_picture_ptr; | |
694 } | |
695 | |
696 if(s->last_picture_ptr || s->low_delay){ | |
697 *data_size = sizeof(AVFrame); | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1687
diff
changeset
|
698 ff_print_debug_info(s, pict); |
262 | 699 } |
931 | 700 |
231 | 701 /* Return the Picture timestamp as the frame number */ |
5963 | 702 /* we subtract 1 because it is added on utils.c */ |
231 | 703 avctx->frame_number = s->picture_number - 1; |
704 | |
384 | 705 #ifdef PRINT_FRAME_TIME |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
3947
diff
changeset
|
706 av_log(avctx, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time); |
384 | 707 #endif |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
708 |
655 | 709 return get_consumed_bytes(s, buf_size); |
0 | 710 } |
711 | |
67 | 712 AVCodec mpeg4_decoder = { |
713 "mpeg4", | |
0 | 714 CODEC_TYPE_VIDEO, |
67 | 715 CODEC_ID_MPEG4, |
0 | 716 sizeof(MpegEncContext), |
936 | 717 ff_h263_decode_init, |
0 | 718 NULL, |
936 | 719 ff_h263_decode_end, |
720 ff_h263_decode_frame, | |
2453 | 721 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
1368 | 722 .flush= ff_mpeg_flush, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6718
diff
changeset
|
723 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"), |
0 | 724 }; |
725 | |
726 AVCodec h263_decoder = { | |
727 "h263", | |
728 CODEC_TYPE_VIDEO, | |
729 CODEC_ID_H263, | |
730 sizeof(MpegEncContext), | |
936 | 731 ff_h263_decode_init, |
0 | 732 NULL, |
936 | 733 ff_h263_decode_end, |
734 ff_h263_decode_frame, | |
2453 | 735 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
1368 | 736 .flush= ff_mpeg_flush, |
8665
5094ddbe4476
Make more descriptive the long names for the various variants of H.263.
stefano
parents:
8629
diff
changeset
|
737 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998"), |
0 | 738 }; |
739 | |
307 | 740 AVCodec msmpeg4v1_decoder = { |
741 "msmpeg4v1", | |
742 CODEC_TYPE_VIDEO, | |
743 CODEC_ID_MSMPEG4V1, | |
744 sizeof(MpegEncContext), | |
936 | 745 ff_h263_decode_init, |
307 | 746 NULL, |
936 | 747 ff_h263_decode_end, |
748 ff_h263_decode_frame, | |
553 | 749 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6718
diff
changeset
|
750 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"), |
307 | 751 }; |
752 | |
753 AVCodec msmpeg4v2_decoder = { | |
754 "msmpeg4v2", | |
755 CODEC_TYPE_VIDEO, | |
756 CODEC_ID_MSMPEG4V2, | |
757 sizeof(MpegEncContext), | |
936 | 758 ff_h263_decode_init, |
307 | 759 NULL, |
936 | 760 ff_h263_decode_end, |
761 ff_h263_decode_frame, | |
553 | 762 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6718
diff
changeset
|
763 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"), |
307 | 764 }; |
765 | |
766 AVCodec msmpeg4v3_decoder = { | |
0 | 767 "msmpeg4", |
768 CODEC_TYPE_VIDEO, | |
307 | 769 CODEC_ID_MSMPEG4V3, |
0 | 770 sizeof(MpegEncContext), |
936 | 771 ff_h263_decode_init, |
0 | 772 NULL, |
936 | 773 ff_h263_decode_end, |
774 ff_h263_decode_frame, | |
553 | 775 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6718
diff
changeset
|
776 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"), |
0 | 777 }; |
778 | |
311 | 779 AVCodec wmv1_decoder = { |
780 "wmv1", | |
781 CODEC_TYPE_VIDEO, | |
782 CODEC_ID_WMV1, | |
783 sizeof(MpegEncContext), | |
936 | 784 ff_h263_decode_init, |
311 | 785 NULL, |
936 | 786 ff_h263_decode_end, |
787 ff_h263_decode_frame, | |
553 | 788 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6718
diff
changeset
|
789 .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"), |
498 | 790 }; |
791 | |
0 | 792 AVCodec h263i_decoder = { |
793 "h263i", | |
794 CODEC_TYPE_VIDEO, | |
795 CODEC_ID_H263I, | |
796 sizeof(MpegEncContext), | |
936 | 797 ff_h263_decode_init, |
0 | 798 NULL, |
936 | 799 ff_h263_decode_end, |
800 ff_h263_decode_frame, | |
553 | 801 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
8672 | 802 .long_name = NULL_IF_CONFIG_SMALL("Intel H.263"), |
0 | 803 }; |
804 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
805 AVCodec flv_decoder = { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
806 "flv", |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
807 CODEC_TYPE_VIDEO, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
808 CODEC_ID_FLV1, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
809 sizeof(MpegEncContext), |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
810 ff_h263_decode_init, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
811 NULL, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
812 ff_h263_decode_end, |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
813 ff_h263_decode_frame, |
6713 | 814 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6718
diff
changeset
|
815 .long_name= NULL_IF_CONFIG_SMALL("Flash Video"), |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1338
diff
changeset
|
816 }; |