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