Mercurial > libavcodec.hg
annotate h263dec.c @ 12483:0159a19bfff7 libavcodec
aacdec: Rework channel mapping compatibility hacks.
For a PCE based configuration map the channels solely based on tags.
For an indexed configuration map the channels solely based on position.
This works with all known exotic samples including al17, elem_id0, bad_concat,
and lfe_is_sce.
author | alexc |
---|---|
date | Fri, 10 Sep 2010 18:01:48 +0000 |
parents | 9fef0a8ddd63 |
children |
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 /** |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11560
diff
changeset
|
24 * @file |
1106 | 25 * H.263 decoder. |
26 */ | |
2967 | 27 |
12475
9fef0a8ddd63
Move mm_support() from libavcodec to libavutil, make it a public
stefano
parents:
12456
diff
changeset
|
28 #include "libavutil/cpu.h" |
9012
15a3df8c01fd
More approved hunks for VAAPI & our new and cleaner hwaccel API.
michael
parents:
8800
diff
changeset
|
29 #include "internal.h" |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
384
diff
changeset
|
30 #include "avcodec.h" |
0 | 31 #include "dsputil.h" |
32 #include "mpegvideo.h" | |
10828 | 33 #include "h263.h" |
4938 | 34 #include "h263_parser.h" |
4957
3fcb2f0d9ef1
move ff_mpeg4_find_frame_end() from h263dec.c to mpeg4video_parser.c
aurel
parents:
4938
diff
changeset
|
35 #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
|
36 #include "msmpeg4.h" |
10509
cdf5b1ed3500
Add VDPAU hardware accelerated decoding for MPEG-4 ASP which can be used
cehoyos
parents:
10443
diff
changeset
|
37 #include "vdpau_internal.h" |
10788 | 38 #include "flv.h" |
10803 | 39 #include "mpeg4video.h" |
0 | 40 |
41 //#define DEBUG | |
384 | 42 //#define PRINT_FRAME_TIME |
0 | 43 |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6481
diff
changeset
|
44 av_cold int ff_h263_decode_init(AVCodecContext *avctx) |
0 | 45 { |
46 MpegEncContext *s = avctx->priv_data; | |
60 | 47 |
67 | 48 s->avctx = avctx; |
0 | 49 s->out_format = FMT_H263; |
50 | |
2270 | 51 s->width = avctx->coded_width; |
52 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
|
53 s->workaround_bugs= avctx->workaround_bugs; |
0 | 54 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
55 // set defaults |
1892 | 56 MPV_decode_defaults(s); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
57 s->quant_precision=5; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
58 s->decode_mb= ff_h263_decode_mb; |
924 | 59 s->low_delay= 1; |
9028 | 60 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
|
61 s->unrestricted_mv= 1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
62 |
0 | 63 /* select sub codec */ |
64 switch(avctx->codec->id) { | |
65 case CODEC_ID_H263: | |
1639 | 66 s->unrestricted_mv= 0; |
9626
bd3e11b60ccd
Add a chroma_sample_location field to define positioning of chroma samples
conrad
parents:
9415
diff
changeset
|
67 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER; |
0 | 68 break; |
67 | 69 case CODEC_ID_MPEG4: |
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 |
119 h263_decode_init_vlc(s); | |
2967 | 120 |
0 | 121 return 0; |
122 } | |
123 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6481
diff
changeset
|
124 av_cold int ff_h263_decode_end(AVCodecContext *avctx) |
0 | 125 { |
126 MpegEncContext *s = avctx->priv_data; | |
127 | |
128 MPV_common_end(s); | |
129 return 0; | |
130 } | |
131 | |
655 | 132 /** |
2764 | 133 * returns the number of bytes consumed for building the current frame |
655 | 134 */ |
135 static int get_consumed_bytes(MpegEncContext *s, int buf_size){ | |
136 int pos= (get_bits_count(&s->gb)+7)>>3; | |
2967 | 137 |
9027
3c141db76660
Approved hunk from the AVHWaccel patch by Gwenole Beauchesne.
michael
parents:
9012
diff
changeset
|
138 if(s->divx_packed || s->avctx->hwaccel){ |
655 | 139 //we would have to scan through the whole buf to handle the weird reordering ... |
2967 | 140 return buf_size; |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
141 }else if(s->flags&CODEC_FLAG_TRUNCATED){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
142 pos -= s->parse_context.last_index; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
143 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
|
144 return pos; |
655 | 145 }else{ |
5127 | 146 if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...) |
658 | 147 if(pos+10>buf_size) pos=buf_size; // oops ;) |
655 | 148 |
149 return pos; | |
150 } | |
151 } | |
152 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
153 static int decode_slice(MpegEncContext *s){ |
1144 | 154 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; |
2261 | 155 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
|
156 s->last_resync_gb= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
157 s->first_slice_line= 1; |
2967 | 158 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
159 s->resync_mb_x= s->mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
160 s->resync_mb_y= s->mb_y; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
161 |
1652 | 162 ff_set_qscale(s, s->qscale); |
2967 | 163 |
9064
ca19176df986
Add HW acceleration hooks for MPEG-4 / H.263 decoding.
benoit
parents:
9033
diff
changeset
|
164 if (s->avctx->hwaccel) { |
ca19176df986
Add HW acceleration hooks for MPEG-4 / H.263 decoding.
benoit
parents:
9033
diff
changeset
|
165 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
|
166 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
|
167 skip_bits_long(&s->gb, 8*(end - start)); |
ca19176df986
Add HW acceleration hooks for MPEG-4 / H.263 decoding.
benoit
parents:
9033
diff
changeset
|
168 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
|
169 } |
9012
15a3df8c01fd
More approved hunks for VAAPI & our new and cleaner hwaccel API.
michael
parents:
8800
diff
changeset
|
170 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
171 if(s->partitioned_frame){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
172 const int qscale= s->qscale; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
173 |
10804
c03a8c6c755b
Add a few CONFIG_MPEG4_DECODER that should be there.
michael
parents:
10803
diff
changeset
|
174 if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
175 if(ff_mpeg4_decode_partitions(s) < 0) |
2967 | 176 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
177 } |
2967 | 178 |
1427 | 179 /* restore variables which were modified */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
180 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
181 s->mb_x= s->resync_mb_x; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
182 s->mb_y= s->resync_mb_y; |
1652 | 183 ff_set_qscale(s, qscale); |
745
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 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
186 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
|
187 /* per-row end of slice checks */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
188 if(s->msmpeg4_version){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
189 if(s->resync_mb_y + s->slice_height == s->mb_y){ |
1144 | 190 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); |
191 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
192 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
193 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
194 } |
2967 | 195 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
196 if(s->msmpeg4_version==1){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
197 s->last_dc[0]= |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
198 s->last_dc[1]= |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
199 s->last_dc[2]= 128; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
200 } |
2967 | 201 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
202 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
203 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
|
204 int ret; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
205 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
206 ff_update_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
207 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
208 if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){ |
2967 | 209 s->first_slice_line=0; |
745
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 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
212 /* DCT & quantize */ |
2967 | 213 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
214 s->mv_dir = MV_DIR_FORWARD; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
215 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
|
216 // s->mb_skipped = 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
217 //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
|
218 ret= s->decode_mb(s, s->block); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
219 |
6481 | 220 if (s->pict_type!=FF_B_TYPE) |
1389 | 221 ff_h263_update_motion_val(s); |
222 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
223 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
|
224 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
|
225 if(ret==SLICE_END){ |
1338 | 226 MPV_decode_mb(s, s->block); |
1644 | 227 if(s->loop_filter) |
228 ff_h263_loop_filter(s); | |
1338 | 229 |
758 | 230 //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 | 231 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 | 232 |
233 s->padding_bug_score--; | |
2967 | 234 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
235 if(++s->mb_x >= s->mb_width){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
236 s->mb_x=0; |
2261 | 237 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
|
238 s->mb_y++; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
239 } |
2967 | 240 return 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
241 }else if(ret==SLICE_NOEND){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
242 av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy); |
1144 | 243 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
|
244 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
245 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
246 av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy); |
1144 | 247 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 | 248 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
249 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
250 } |
1338 | 251 |
252 MPV_decode_mb(s, s->block); | |
1644 | 253 if(s->loop_filter) |
254 ff_h263_loop_filter(s); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
255 } |
2967 | 256 |
2261 | 257 ff_draw_horiz_band(s, s->mb_y*mb_size, mb_size); |
2967 | 258 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
259 s->mb_x= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
260 } |
2967 | 261 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
262 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
|
263 |
750 | 264 /* try to detect the padding bug */ |
265 if( s->codec_id==CODEC_ID_MPEG4 | |
2967 | 266 && (s->workaround_bugs&FF_BUG_AUTODETECT) |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
10509
diff
changeset
|
267 && get_bits_left(&s->gb) >=0 |
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
10509
diff
changeset
|
268 && get_bits_left(&s->gb) < 48 |
928
5627a7b7ce83
fixing playback of DaveMatthews_Crash_PocketPC.avi
michaelni
parents:
925
diff
changeset
|
269 // && !s->resync_marker |
750 | 270 && !s->data_partitioning){ |
2967 | 271 |
750 | 272 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
|
273 const int bits_left = s->gb.size_in_bits - bits_count; |
2967 | 274 |
1003 | 275 if(bits_left==0){ |
276 s->padding_bug_score+=16; | |
824 | 277 } else if(bits_left != 1){ |
750 | 278 int v= show_bits(&s->gb, 8); |
279 v|= 0x7F >> (7-(bits_count&7)); | |
824 | 280 |
2350 | 281 if(v==0x7F && bits_left<=8) |
750 | 282 s->padding_bug_score--; |
2350 | 283 else if(v==0x7F && ((get_bits_count(&s->gb)+8)&8) && bits_left<=16) |
284 s->padding_bug_score+= 4; | |
750 | 285 else |
2967 | 286 s->padding_bug_score++; |
287 } | |
750 | 288 } |
2967 | 289 |
2350 | 290 if(s->workaround_bugs&FF_BUG_AUTODETECT){ |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
291 if(s->padding_bug_score > -2 && !s->data_partitioning /*&& (s->divx_version>=0 || !s->resync_marker)*/) |
2350 | 292 s->workaround_bugs |= FF_BUG_NO_PADDING; |
293 else | |
294 s->workaround_bugs &= ~FF_BUG_NO_PADDING; | |
295 } | |
750 | 296 |
2764 | 297 // handle formats which don't have unique end markers |
1004 | 298 if(s->msmpeg4_version || (s->workaround_bugs&FF_BUG_NO_PADDING)){ //FIXME perhaps solve this more cleanly |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
10509
diff
changeset
|
299 int left= get_bits_left(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
300 int max_extra=7; |
2967 | 301 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
302 /* no markers in M$ crap */ |
6481 | 303 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
|
304 max_extra+= 17; |
2967 | 305 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
306 /* buggy padding but the frame should still end approximately at the bitstream end */ |
7831 | 307 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
|
308 max_extra+= 48; |
1004 | 309 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
|
310 max_extra+= 256*256*256*64; |
2967 | 311 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
312 if(left>max_extra){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
313 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
|
314 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
315 else if(left<0){ |
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, "overreading %d bits\n", -left); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
317 }else |
1144 | 318 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 | 319 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
320 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
321 } |
750 | 322 |
2967 | 323 av_log(s->avctx, AV_LOG_ERROR, "slice end not reached but screenspace end (%d left %06X, score= %d)\n", |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
10509
diff
changeset
|
324 get_bits_left(&s->gb), |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
325 show_bits(&s->gb, 24), s->padding_bug_score); |
2967 | 326 |
1144 | 327 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); |
328 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
329 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
330 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
331 |
2967 | 332 int ff_h263_decode_frame(AVCodecContext *avctx, |
0 | 333 void *data, int *data_size, |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9083
diff
changeset
|
334 AVPacket *avpkt) |
0 | 335 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9083
diff
changeset
|
336 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9083
diff
changeset
|
337 int buf_size = avpkt->size; |
0 | 338 MpegEncContext *s = avctx->priv_data; |
1453 | 339 int ret; |
2967 | 340 AVFrame *pict = data; |
341 | |
384 | 342 #ifdef PRINT_FRAME_TIME |
343 uint64_t time= rdtsc(); | |
344 #endif | |
485 | 345 s->flags= avctx->flags; |
1754
bdf3927bf8c5
closed gop support & flags2 as all bits in flags are used
michael
parents:
1747
diff
changeset
|
346 s->flags2= avctx->flags2; |
454 | 347 |
1372 | 348 /* no supplementary picture */ |
0 | 349 if (buf_size == 0) { |
1372 | 350 /* special case for last picture */ |
351 if (s->low_delay==0 && s->next_picture_ptr) { | |
352 *pict= *(AVFrame*)s->next_picture_ptr; | |
353 s->next_picture_ptr= NULL; | |
354 | |
355 *data_size = sizeof(AVFrame); | |
356 } | |
357 | |
0 | 358 return 0; |
359 } | |
1026 | 360 |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
361 if(s->flags&CODEC_FLAG_TRUNCATED){ |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
362 int next; |
2967 | 363 |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
364 if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4){ |
1988 | 365 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
|
366 }else if(CONFIG_H263_DECODER && s->codec_id==CODEC_ID_H263){ |
4938 | 367 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
|
368 }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
|
369 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
|
370 return -1; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
371 } |
2967 | 372 |
4931
0d1cc37d9430
make some parser parameters const to avoid casting const to non-const
aurel
parents:
4636
diff
changeset
|
373 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
|
374 return buf_size; |
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
831
diff
changeset
|
375 } |
0 | 376 |
2967 | 377 |
763 | 378 retry: |
2967 | 379 |
1747 | 380 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
|
381 init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size*8); |
353 | 382 }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
|
383 init_get_bits(&s->gb, buf, buf_size*8); |
465 | 384 s->bitstream_buffer_size=0; |
0 | 385 |
718 | 386 if (!s->context_initialized) { |
752
97077dd24bfa
fixing alt_scan for the first frame (variable was reset)
michaelni
parents:
750
diff
changeset
|
387 if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix |
718 | 388 return -1; |
389 } | |
2967 | 390 |
5127 | 391 /* We need to set current_picture_ptr before reading the header, |
392 * otherwise we cannot store anyting in there */ | |
1586 | 393 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){ |
394 int i= ff_find_unused_picture(s, 0); | |
395 s->current_picture_ptr= &s->picture[i]; | |
396 } | |
2967 | 397 |
0 | 398 /* let's go :-) */ |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
399 if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5) { |
936 | 400 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
|
401 } else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) { |
0 | 402 ret = msmpeg4_decode_picture_header(s); |
10792 | 403 } else if (CONFIG_MPEG4_DECODER && s->h263_pred) { |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
404 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
|
405 GetBitContext gb; |
2967 | 406 |
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
|
407 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
|
408 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
|
409 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
410 ret = ff_mpeg4_decode_picture_header(s, &s->gb); |
10792 | 411 } else if (CONFIG_H263I_DECODER && s->codec_id == CODEC_ID_H263I) { |
10791 | 412 ret = ff_intel_h263_decode_picture_header(s); |
10788 | 413 } else if (CONFIG_FLV_DECODER && s->h263_flv) { |
414 ret = ff_flv_decode_picture_header(s); | |
0 | 415 } else { |
416 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
|
417 } |
2967 | 418 |
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
|
419 if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_size); |
1393 | 420 |
421 /* skip if the header was thrashed */ | |
422 if (ret < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
423 av_log(s->avctx, AV_LOG_ERROR, "header damaged\n"); |
1393 | 424 return -1; |
425 } | |
2967 | 426 |
924 | 427 avctx->has_b_frames= !s->low_delay; |
2967 | 428 |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
429 if(s->xvid_build==-1 && s->divx_version==-1 && s->lavc_build==-1){ |
8612 | 430 if(s->stream_codec_tag == AV_RL32("XVID") || |
431 s->codec_tag == AV_RL32("XVID") || s->codec_tag == AV_RL32("XVIX") || | |
11773 | 432 s->codec_tag == AV_RL32("RMP4") || |
433 s->codec_tag == AV_RL32("SIPP") | |
434 ) | |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
435 s->xvid_build= 0; |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
436 #if 0 |
8612 | 437 if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==1 |
2967 | 438 && s->padding_bug_score > 0 && s->low_delay) // XVID with modified fourcc |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
439 s->xvid_build= 0; |
1458
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
440 #endif |
40b69d238beb
AVI stream header FCC / more reliable detection of old xvid files
michaelni
parents:
1457
diff
changeset
|
441 } |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
442 |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
443 if(s->xvid_build==-1 && s->divx_version==-1 && s->lavc_build==-1){ |
8612 | 444 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
|
445 s->divx_version= 400; //divx 4 |
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
446 } |
2967 | 447 |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
448 if(s->xvid_build>=0 && s->divx_version>=0){ |
2299 | 449 s->divx_version= |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
450 s->divx_build= -1; |
2299 | 451 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
452 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
453 if(s->workaround_bugs&FF_BUG_AUTODETECT){ |
8612 | 454 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
|
455 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
|
456 |
8612 | 457 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
|
458 s->workaround_bugs|= FF_BUG_UMP4; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
459 } |
760 | 460 |
5136 | 461 if(s->divx_version>=500 && s->divx_build<1814){ |
760 | 462 s->workaround_bugs|= FF_BUG_QPEL_CHROMA; |
463 } | |
761 | 464 |
5136 | 465 if(s->divx_version>502 && s->divx_build<1814){ |
1048 | 466 s->workaround_bugs|= FF_BUG_QPEL_CHROMA2; |
467 } | |
468 | |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
469 if(s->xvid_build<=3U) |
938
1e22655551b9
xvid build 3 still has the padding wrong in 1/8 of the cases :(((((
michaelni
parents:
936
diff
changeset
|
470 s->padding_bug_score= 256*256*256*64; |
2967 | 471 |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
472 if(s->xvid_build<=1U) |
761 | 473 s->workaround_bugs|= FF_BUG_QPEL_CHROMA; |
474 | |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
475 if(s->xvid_build<=12U) |
1420
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
476 s->workaround_bugs|= FF_BUG_EDGE; |
ff0220970711
xvid edge bug (if i understand the mpeg4 spec correctly) autodetection
michaelni
parents:
1393
diff
changeset
|
477 |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
478 if(s->xvid_build<=32U) |
2004 | 479 s->workaround_bugs|= FF_BUG_DC_CLIP; |
480 | |
984 | 481 #define SET_QPEL_FUNC(postfix1, postfix2) \ |
482 s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\ | |
483 s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\ | |
484 s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2; | |
485 | |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
486 if(s->lavc_build<4653U) |
984 | 487 s->workaround_bugs|= FF_BUG_STD_QPEL; |
2967 | 488 |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
489 if(s->lavc_build<4655U) |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
490 s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE; |
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
491 |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
492 if(s->lavc_build<4670U){ |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1353
diff
changeset
|
493 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
|
494 } |
2967 | 495 |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
496 if(s->lavc_build<=4712U) |
2004 | 497 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
|
498 |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
499 if(s->divx_version>=0) |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1048
diff
changeset
|
500 s->workaround_bugs|= FF_BUG_DIRECT_BLOCKSIZE; |
750 | 501 //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
|
502 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
|
503 s->padding_bug_score= 256*256*256*64; |
1137 | 504 |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
505 if(s->divx_version<500U){ |
1137 | 506 s->workaround_bugs|= FF_BUG_EDGE; |
507 } | |
2967 | 508 |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
509 if(s->divx_version>=0) |
1916 | 510 s->workaround_bugs|= FF_BUG_HPEL_CHROMA; |
750 | 511 #if 0 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
512 if(s->divx_version==500) |
1088
bb27c685fc72
fixing padding bug autodetection for some rare files, closes bug #647941
michaelni
parents:
1064
diff
changeset
|
513 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
|
514 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
515 /* 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
|
516 * 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
|
517 */ |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
518 if( s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==-1 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
519 && 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
|
520 s->workaround_bugs|= FF_BUG_NO_PADDING; |
2967 | 521 |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
522 if(s->lavc_build<4609U) //FIXME not sure about the version num but a 4609 file seems ok |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
523 s->workaround_bugs|= FF_BUG_NO_PADDING; |
750 | 524 #endif |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
525 } |
2967 | 526 |
984 | 527 if(s->workaround_bugs& FF_BUG_STD_QPEL){ |
528 SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c) | |
529 SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c) | |
530 SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c) | |
531 SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c) | |
532 SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c) | |
533 SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c) | |
534 | |
535 SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c) | |
536 SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c) | |
537 SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c) | |
538 SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c) | |
539 SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c) | |
540 SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c) | |
541 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
542 |
1457 | 543 if(avctx->debug & FF_DEBUG_BUGS) |
2967 | 544 av_log(s->avctx, AV_LOG_DEBUG, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n", |
1457 | 545 s->workaround_bugs, s->lavc_build, s->xvid_build, s->divx_version, s->divx_build, |
546 s->divx_packed ? "p" : ""); | |
2967 | 547 |
585
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
548 #if 0 // dump bits per frame / qp / complexity |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
549 { |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
550 static FILE *f=NULL; |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
551 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
|
552 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
|
553 } |
86ebb02c6693
dump bits per frame / qp / frame complexity support
michaelni
parents:
562
diff
changeset
|
554 #endif |
2096 | 555 |
8590 | 556 #if HAVE_MMX |
12475
9fef0a8ddd63
Move mm_support() from libavcodec to libavutil, make it a public
stefano
parents:
12456
diff
changeset
|
557 if (s->codec_id == CODEC_ID_MPEG4 && s->xvid_build>=0 && avctx->idct_algo == FF_IDCT_AUTO && (av_get_cpu_flags() & AV_CPU_FLAG_MMX)) { |
2869 | 558 avctx->idct_algo= FF_IDCT_XVIDMMX; |
2278 | 559 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
|
560 // 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
|
561 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
|
562 } |
2096 | 563 #endif |
564 | |
274
d0c186bcf075
use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents:
273
diff
changeset
|
565 /* After H263 & mpeg4 header decode we have the height, width,*/ |
160 | 566 /* and other parameters. So then we could init the picture */ |
567 /* FIXME: By the way H263 decoder is evolving it should have */ | |
568 /* an H263EncContext */ | |
2967 | 569 |
570 if ( s->width != avctx->coded_width | |
2270 | 571 || s->height != avctx->coded_height) { |
553 | 572 /* H.263 could change picture size any time */ |
1536 | 573 ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat |
574 s->parse_context.buffer=0; | |
553 | 575 MPV_common_end(s); |
1536 | 576 s->parse_context= pc; |
553 | 577 } |
274
d0c186bcf075
use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents:
273
diff
changeset
|
578 if (!s->context_initialized) { |
2270 | 579 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
|
580 |
763 | 581 goto retry; |
0 | 582 } |
758 | 583 |
8800
8ec0175bbcb5
Initialize s->gob_index for Intel variant of H.263 too
kostya
parents:
8718
diff
changeset
|
584 if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P || s->codec_id == CODEC_ID_H263I)) |
758 | 585 s->gob_index = ff_h263_get_gob_height(s); |
2967 | 586 |
903 | 587 // for hurry_up==5 |
588 s->current_picture.pict_type= s->pict_type; | |
6481 | 589 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
|
590 |
2764 | 591 /* skip B-frames if we don't have reference frames */ |
6481 | 592 if(s->last_picture_ptr==NULL && (s->pict_type==FF_B_TYPE || s->dropable)) return get_consumed_bytes(s, buf_size); |
345 | 593 /* skip b frames if we are in a hurry */ |
6481 | 594 if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return get_consumed_bytes(s, buf_size); |
595 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE) | |
596 || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE) | |
2967 | 597 || avctx->skip_frame >= AVDISCARD_ALL) |
2792 | 598 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
|
599 /* 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
|
600 if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size); |
2967 | 601 |
454 | 602 if(s->next_p_frame_damaged){ |
6481 | 603 if(s->pict_type==FF_B_TYPE) |
655 | 604 return get_consumed_bytes(s, buf_size); |
454 | 605 else |
606 s->next_p_frame_damaged=0; | |
607 } | |
608 | |
6481 | 609 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
|
610 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
|
611 s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab; |
6481 | 612 }else if((!s->no_rounding) || s->pict_type==FF_B_TYPE){ |
3926 | 613 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
|
614 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
|
615 }else{ |
3926 | 616 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
|
617 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
|
618 } |
6a40092eb9e6
approximate qpel functions: sacrifice some quality for some decoding speed. enabled on B-frames with -lavdopts fast.
lorenm
parents:
3551
diff
changeset
|
619 |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
763
diff
changeset
|
620 if(MPV_frame_start(s, avctx) < 0) |
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
763
diff
changeset
|
621 return -1; |
0 | 622 |
10509
cdf5b1ed3500
Add VDPAU hardware accelerated decoding for MPEG-4 ASP which can be used
cehoyos
parents:
10443
diff
changeset
|
623 if (CONFIG_MPEG4_VDPAU_DECODER && (s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)) { |
11332
c66e0bc700dd
Pass correct buffer-pointer and buffer-size to hardware accelerated
cehoyos
parents:
11327
diff
changeset
|
624 ff_vdpau_mpeg4_decode_picture(s, s->gb.buffer, s->gb.buffer_end - s->gb.buffer); |
10509
cdf5b1ed3500
Add VDPAU hardware accelerated decoding for MPEG-4 ASP which can be used
cehoyos
parents:
10443
diff
changeset
|
625 goto frame_end; |
cdf5b1ed3500
Add VDPAU hardware accelerated decoding for MPEG-4 ASP which can be used
cehoyos
parents:
10443
diff
changeset
|
626 } |
cdf5b1ed3500
Add VDPAU hardware accelerated decoding for MPEG-4 ASP which can be used
cehoyos
parents:
10443
diff
changeset
|
627 |
9064
ca19176df986
Add HW acceleration hooks for MPEG-4 / H.263 decoding.
benoit
parents:
9033
diff
changeset
|
628 if (avctx->hwaccel) { |
11332
c66e0bc700dd
Pass correct buffer-pointer and buffer-size to hardware accelerated
cehoyos
parents:
11327
diff
changeset
|
629 if (avctx->hwaccel->start_frame(avctx, s->gb.buffer, s->gb.buffer_end - s->gb.buffer) < 0) |
9064
ca19176df986
Add HW acceleration hooks for MPEG-4 / H.263 decoding.
benoit
parents:
9033
diff
changeset
|
630 return -1; |
ca19176df986
Add HW acceleration hooks for MPEG-4 / H.263 decoding.
benoit
parents:
9033
diff
changeset
|
631 } |
ca19176df986
Add HW acceleration hooks for MPEG-4 / H.263 decoding.
benoit
parents:
9033
diff
changeset
|
632 |
1144 | 633 ff_er_frame_start(s); |
2967 | 634 |
1183 | 635 //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type |
5127 | 636 //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
|
637 if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5){ |
5887 | 638 ret = ff_wmv2_decode_secondary_picture_header(s); |
639 if(ret<0) return ret; | |
640 if(ret==1) goto intrax8_decoded; | |
1183 | 641 } |
642 | |
0 | 643 /* decode each macroblock */ |
2967 | 644 s->mb_x=0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
645 s->mb_y=0; |
2967 | 646 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
647 decode_slice(s); |
1183 | 648 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
|
649 if(s->msmpeg4_version){ |
4386 | 650 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
|
651 break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
652 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
653 if(ff_h263_resync(s)<0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
654 break; |
454 | 655 } |
2967 | 656 |
983 | 657 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
|
658 ff_mpeg4_clean_buffers(s); |
454 | 659 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
660 decode_slice(s); |
0 | 661 } |
756 | 662 |
6481 | 663 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
|
664 if(!CONFIG_MSMPEG4_DECODER || msmpeg4_decode_ext_header(s, buf_size) < 0){ |
903 | 665 s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR; |
666 } | |
2967 | 667 |
10760
c199eb2ad4ec
It appears s->bitstream_buffer_size has to be 0 at the end so rather use assert.
michael
parents:
10535
diff
changeset
|
668 assert(s->bitstream_buffer_size==0); |
11327 | 669 frame_end: |
333 | 670 /* divx 5.01+ bistream reorder stuff */ |
10760
c199eb2ad4ec
It appears s->bitstream_buffer_size has to be 0 at the end so rather use assert.
michael
parents:
10535
diff
changeset
|
671 if(s->codec_id==CODEC_ID_MPEG4 && s->divx_packed){ |
454 | 672 int current_pos= get_bits_count(&s->gb)>>3; |
1747 | 673 int startcode_found=0; |
2967 | 674 |
2422 | 675 if(buf_size - current_pos > 5){ |
454 | 676 int i; |
655 | 677 for(i=current_pos; i<buf_size-3; i++){ |
454 | 678 if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){ |
679 startcode_found=1; | |
680 break; | |
681 } | |
682 } | |
1747 | 683 } |
11098
77b3f322dba8
Change xvid/divx/lavc build variables to be consistent to x264_build.
michael
parents:
10828
diff
changeset
|
684 if(s->gb.buffer == s->bitstream_buffer && buf_size>7 && s->xvid_build>=0){ //xvid style |
1747 | 685 startcode_found=1; |
686 current_pos=0; | |
687 } | |
688 | |
689 if(startcode_found){ | |
9415
141badec76fc
Add a av_fast_malloc function and replace several uses of av_fast_realloc,
reimar
parents:
9355
diff
changeset
|
690 av_fast_malloc( |
141badec76fc
Add a av_fast_malloc function and replace several uses of av_fast_realloc,
reimar
parents:
9355
diff
changeset
|
691 &s->bitstream_buffer, |
2967 | 692 &s->allocated_bitstream_buffer_size, |
2422 | 693 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
|
694 if (!s->bitstream_buffer) |
141badec76fc
Add a av_fast_malloc function and replace several uses of av_fast_realloc,
reimar
parents:
9355
diff
changeset
|
695 return AVERROR(ENOMEM); |
1747 | 696 memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos); |
697 s->bitstream_buffer_size= buf_size - current_pos; | |
454 | 698 } |
699 } | |
700 | |
5887 | 701 intrax8_decoded: |
1144 | 702 ff_er_frame_end(s); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
703 |
9029 | 704 if (avctx->hwaccel) { |
705 if (avctx->hwaccel->end_frame(avctx) < 0) | |
706 return -1; | |
707 } | |
708 | |
0 | 709 MPV_frame_end(s); |
984 | 710 |
1285 | 711 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type); |
712 assert(s->current_picture.pict_type == s->pict_type); | |
6481 | 713 if (s->pict_type == FF_B_TYPE || s->low_delay) { |
3185 | 714 *pict= *(AVFrame*)s->current_picture_ptr; |
715 } else if (s->last_picture_ptr != NULL) { | |
716 *pict= *(AVFrame*)s->last_picture_ptr; | |
717 } | |
718 | |
719 if(s->last_picture_ptr || s->low_delay){ | |
720 *data_size = sizeof(AVFrame); | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1687
diff
changeset
|
721 ff_print_debug_info(s, pict); |
262 | 722 } |
931 | 723 |
384 | 724 #ifdef PRINT_FRAME_TIME |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
3947
diff
changeset
|
725 av_log(avctx, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time); |
384 | 726 #endif |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1219
diff
changeset
|
727 |
655 | 728 return get_consumed_bytes(s, buf_size); |
0 | 729 } |
730 | |
731 AVCodec h263_decoder = { | |
732 "h263", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11332
diff
changeset
|
733 AVMEDIA_TYPE_VIDEO, |
0 | 734 CODEC_ID_H263, |
735 sizeof(MpegEncContext), | |
936 | 736 ff_h263_decode_init, |
0 | 737 NULL, |
936 | 738 ff_h263_decode_end, |
739 ff_h263_decode_frame, | |
2453 | 740 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
1368 | 741 .flush= ff_mpeg_flush, |
12108
c35d7bc64882
Add new decoder property max_lowres and do not init decoder if requested value is higher.
cehoyos
parents:
11773
diff
changeset
|
742 .max_lowres= 3, |
9083
bf274494b66e
Change a bunch of codec long_names to be more consistent and descriptive.
diego
parents:
9067
diff
changeset
|
743 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"), |
9067 | 744 .pix_fmts= ff_hwaccel_pixfmt_list_420, |
0 | 745 }; |