Mercurial > libavcodec.hg
annotate rv10.c @ 2497:69adfbbdcdeb libavcodec
- samples from mplayer ftp in the "adv" profile seem to have profile=2,
which isn't the advanced one; and indeed, using adv. profile parser fails.
Using normal parser works, and that's what is done
- attempt at taking care of stride for NORM2 bitplane decoding
- duplication of much code from msmpeg4.c; this code isn't yet used, but
goes down as far as the block layer (mainly Transform Type stuff, the
remains are wild editing without checking). Unusable yet, and lacks the AC
decoding (but a step further in bitstream parsing)
patch by anonymous
author | michael |
---|---|
date | Fri, 04 Feb 2005 02:20:38 +0000 |
parents | f67b63ed036d |
children | e25782262d7d |
rev | line source |
---|---|
0 | 1 /* |
2 * RV10 codec | |
429 | 3 * Copyright (c) 2000,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 |
0 | 5 * |
429 | 6 * This library is free software; you can redistribute it and/or |
7 * modify it under the terms of the GNU Lesser General Public | |
8 * License as published by the Free Software Foundation; either | |
9 * version 2 of the License, or (at your option) any later version. | |
0 | 10 * |
429 | 11 * This library is distributed in the hope that it will be useful, |
0 | 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 * Lesser General Public License for more details. | |
0 | 15 * |
429 | 16 * You should have received a copy of the GNU Lesser General Public |
17 * License along with this library; if not, write to the Free Software | |
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
0 | 19 */ |
1106 | 20 |
21 /** | |
22 * @file rv10.c | |
23 * RV10 codec. | |
24 */ | |
25 | |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
350
diff
changeset
|
26 #include "avcodec.h" |
0 | 27 #include "dsputil.h" |
28 #include "mpegvideo.h" | |
29 | |
30 //#define DEBUG | |
31 | |
622
a1e54c24f221
working around undefined behavior of get-vlc if the vlc s invalid
michaelni
parents:
621
diff
changeset
|
32 #define DC_VLC_BITS 14 //FIXME find a better solution |
547 | 33 |
1064 | 34 static const uint16_t rv_lum_code[256] = |
0 | 35 { |
36 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06, | |
37 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e, | |
38 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16, | |
39 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e, | |
40 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26, | |
41 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e, | |
42 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36, | |
43 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e, | |
44 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386, | |
45 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e, | |
46 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, | |
47 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, | |
48 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, | |
49 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, | |
50 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, | |
51 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004, | |
52 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027, | |
53 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, | |
54 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, | |
55 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, | |
56 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7, | |
57 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af, | |
58 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7, | |
59 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf, | |
60 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47, | |
61 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f, | |
62 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57, | |
63 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f, | |
64 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67, | |
65 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f, | |
66 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77, | |
67 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f, | |
68 }; | |
69 | |
1064 | 70 static const uint8_t rv_lum_bits[256] = |
0 | 71 { |
72 14, 12, 12, 12, 12, 12, 12, 12, | |
73 12, 12, 12, 12, 12, 12, 12, 12, | |
74 12, 12, 12, 12, 12, 12, 12, 12, | |
75 12, 12, 12, 12, 12, 12, 12, 12, | |
76 12, 12, 12, 12, 12, 12, 12, 12, | |
77 12, 12, 12, 12, 12, 12, 12, 12, | |
78 12, 12, 12, 12, 12, 12, 12, 12, | |
79 12, 12, 12, 12, 12, 12, 12, 12, | |
80 12, 10, 10, 10, 10, 10, 10, 10, | |
81 10, 10, 10, 10, 10, 10, 10, 10, | |
82 10, 10, 10, 10, 10, 10, 10, 10, | |
83 10, 10, 10, 10, 10, 10, 10, 10, | |
84 10, 8, 8, 8, 8, 8, 8, 8, | |
85 8, 8, 8, 8, 8, 8, 8, 8, | |
86 8, 7, 7, 7, 7, 7, 7, 7, | |
87 7, 6, 6, 6, 6, 5, 5, 4, | |
88 2, 4, 5, 5, 6, 6, 6, 6, | |
89 7, 7, 7, 7, 7, 7, 7, 7, | |
90 8, 8, 8, 8, 8, 8, 8, 8, | |
91 8, 8, 8, 8, 8, 8, 8, 8, | |
92 10, 10, 10, 10, 10, 10, 10, 10, | |
93 10, 10, 10, 10, 10, 10, 10, 10, | |
94 10, 10, 10, 10, 10, 10, 10, 10, | |
95 10, 10, 10, 10, 10, 10, 10, 10, | |
96 12, 12, 12, 12, 12, 12, 12, 12, | |
97 12, 12, 12, 12, 12, 12, 12, 12, | |
98 12, 12, 12, 12, 12, 12, 12, 12, | |
99 12, 12, 12, 12, 12, 12, 12, 12, | |
100 12, 12, 12, 12, 12, 12, 12, 12, | |
101 12, 12, 12, 12, 12, 12, 12, 12, | |
102 12, 12, 12, 12, 12, 12, 12, 12, | |
103 12, 12, 12, 12, 12, 12, 12, 12, | |
104 }; | |
105 | |
1064 | 106 static const uint16_t rv_chrom_code[256] = |
0 | 107 { |
108 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06, | |
109 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e, | |
110 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16, | |
111 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e, | |
112 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26, | |
113 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e, | |
114 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36, | |
115 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e, | |
116 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86, | |
117 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e, | |
118 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96, | |
119 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e, | |
120 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, | |
121 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce, | |
122 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, | |
123 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002, | |
124 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037, | |
125 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, | |
126 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7, | |
127 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df, | |
128 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7, | |
129 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf, | |
130 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7, | |
131 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf, | |
132 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47, | |
133 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f, | |
134 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57, | |
135 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f, | |
136 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67, | |
137 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f, | |
138 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77, | |
139 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f, | |
140 }; | |
141 | |
1064 | 142 static const uint8_t rv_chrom_bits[256] = |
0 | 143 { |
144 16, 14, 14, 14, 14, 14, 14, 14, | |
145 14, 14, 14, 14, 14, 14, 14, 14, | |
146 14, 14, 14, 14, 14, 14, 14, 14, | |
147 14, 14, 14, 14, 14, 14, 14, 14, | |
148 14, 14, 14, 14, 14, 14, 14, 14, | |
149 14, 14, 14, 14, 14, 14, 14, 14, | |
150 14, 14, 14, 14, 14, 14, 14, 14, | |
151 14, 14, 14, 14, 14, 14, 14, 14, | |
152 14, 12, 12, 12, 12, 12, 12, 12, | |
153 12, 12, 12, 12, 12, 12, 12, 12, | |
154 12, 12, 12, 12, 12, 12, 12, 12, | |
155 12, 12, 12, 12, 12, 12, 12, 12, | |
156 12, 10, 10, 10, 10, 10, 10, 10, | |
157 10, 10, 10, 10, 10, 10, 10, 10, | |
158 10, 8, 8, 8, 8, 8, 8, 8, | |
159 8, 6, 6, 6, 6, 4, 4, 3, | |
160 2, 3, 4, 4, 6, 6, 6, 6, | |
161 8, 8, 8, 8, 8, 8, 8, 8, | |
162 10, 10, 10, 10, 10, 10, 10, 10, | |
163 10, 10, 10, 10, 10, 10, 10, 10, | |
164 12, 12, 12, 12, 12, 12, 12, 12, | |
165 12, 12, 12, 12, 12, 12, 12, 12, | |
166 12, 12, 12, 12, 12, 12, 12, 12, | |
167 12, 12, 12, 12, 12, 12, 12, 12, | |
168 14, 14, 14, 14, 14, 14, 14, 14, | |
169 14, 14, 14, 14, 14, 14, 14, 14, | |
170 14, 14, 14, 14, 14, 14, 14, 14, | |
171 14, 14, 14, 14, 14, 14, 14, 14, | |
172 14, 14, 14, 14, 14, 14, 14, 14, | |
173 14, 14, 14, 14, 14, 14, 14, 14, | |
174 14, 14, 14, 14, 14, 14, 14, 14, | |
175 14, 14, 14, 14, 14, 14, 14, 14, | |
176 }; | |
177 | |
178 static VLC rv_dc_lum, rv_dc_chrom; | |
179 | |
180 int rv_decode_dc(MpegEncContext *s, int n) | |
181 { | |
182 int code; | |
183 | |
184 if (n < 4) { | |
547 | 185 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2); |
0 | 186 if (code < 0) { |
187 /* XXX: I don't understand why they use LONGER codes than | |
188 necessary. The following code would be completely useless | |
189 if they had thought about it !!! */ | |
190 code = get_bits(&s->gb, 7); | |
191 if (code == 0x7c) { | |
1064 | 192 code = (int8_t)(get_bits(&s->gb, 7) + 1); |
0 | 193 } else if (code == 0x7d) { |
194 code = -128 + get_bits(&s->gb, 7); | |
195 } else if (code == 0x7e) { | |
196 if (get_bits(&s->gb, 1) == 0) | |
1064 | 197 code = (int8_t)(get_bits(&s->gb, 8) + 1); |
0 | 198 else |
1064 | 199 code = (int8_t)(get_bits(&s->gb, 8)); |
0 | 200 } else if (code == 0x7f) { |
201 get_bits(&s->gb, 11); | |
202 code = 1; | |
203 } | |
204 } else { | |
205 code -= 128; | |
206 } | |
207 } else { | |
547 | 208 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2); |
0 | 209 /* same remark */ |
210 if (code < 0) { | |
211 code = get_bits(&s->gb, 9); | |
212 if (code == 0x1fc) { | |
1064 | 213 code = (int8_t)(get_bits(&s->gb, 7) + 1); |
0 | 214 } else if (code == 0x1fd) { |
215 code = -128 + get_bits(&s->gb, 7); | |
216 } else if (code == 0x1fe) { | |
217 get_bits(&s->gb, 9); | |
218 code = 1; | |
219 } else { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1389
diff
changeset
|
220 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n"); |
0 | 221 return 0xffff; |
222 } | |
223 } else { | |
224 code -= 128; | |
225 } | |
226 } | |
227 return -code; | |
228 } | |
229 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
230 #ifdef CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
231 |
0 | 232 /* write RV 1.0 compatible frame header */ |
233 void rv10_encode_picture_header(MpegEncContext *s, int picture_number) | |
234 { | |
712
e55b91623e09
fixing rv10, this isnt the cleanest solution (parsing the packet header in the codec & creating it in the muxer) but it was that way before things broke, and its the simplest solution
michaelni
parents:
646
diff
changeset
|
235 int full_frame= 0; |
646
f87dc45d921d
fixing rv10 encoding (ffmpeg can at least decode its own rv10 files now)
michaelni
parents:
643
diff
changeset
|
236 |
0 | 237 align_put_bits(&s->pb); |
646
f87dc45d921d
fixing rv10 encoding (ffmpeg can at least decode its own rv10 files now)
michaelni
parents:
643
diff
changeset
|
238 |
0 | 239 put_bits(&s->pb, 1, 1); /* marker */ |
240 | |
241 put_bits(&s->pb, 1, (s->pict_type == P_TYPE)); | |
242 | |
243 put_bits(&s->pb, 1, 0); /* not PB frame */ | |
244 | |
245 put_bits(&s->pb, 5, s->qscale); | |
246 | |
247 if (s->pict_type == I_TYPE) { | |
248 /* specific MPEG like DC coding not used */ | |
249 } | |
250 /* if multiple packets per frame are sent, the position at which | |
251 to display the macro blocks is coded here */ | |
646
f87dc45d921d
fixing rv10 encoding (ffmpeg can at least decode its own rv10 files now)
michaelni
parents:
643
diff
changeset
|
252 if(!full_frame){ |
f87dc45d921d
fixing rv10 encoding (ffmpeg can at least decode its own rv10 files now)
michaelni
parents:
643
diff
changeset
|
253 put_bits(&s->pb, 6, 0); /* mb_x */ |
f87dc45d921d
fixing rv10 encoding (ffmpeg can at least decode its own rv10 files now)
michaelni
parents:
643
diff
changeset
|
254 put_bits(&s->pb, 6, 0); /* mb_y */ |
f87dc45d921d
fixing rv10 encoding (ffmpeg can at least decode its own rv10 files now)
michaelni
parents:
643
diff
changeset
|
255 put_bits(&s->pb, 12, s->mb_width * s->mb_height); |
f87dc45d921d
fixing rv10 encoding (ffmpeg can at least decode its own rv10 files now)
michaelni
parents:
643
diff
changeset
|
256 } |
0 | 257 |
258 put_bits(&s->pb, 3, 0); /* ignored */ | |
259 } | |
260 | |
2380 | 261 void rv20_encode_picture_header(MpegEncContext *s, int picture_number){ |
262 put_bits(&s->pb, 2, s->pict_type); //I 0 vs. 1 ? | |
263 put_bits(&s->pb, 1, 0); /* unknown bit */ | |
264 put_bits(&s->pb, 5, s->qscale); | |
265 | |
266 put_bits(&s->pb, 8, picture_number&0xFF); //FIXME wrong, but correct is not known | |
267 s->mb_x= s->mb_y= 0; | |
268 ff_h263_encode_mba(s); | |
269 | |
270 put_bits(&s->pb, 1, s->no_rounding); | |
271 | |
272 assert(s->f_code == 1); | |
273 assert(s->unrestricted_mv == 1); | |
274 // assert(s->h263_aic== (s->pict_type == I_TYPE)); | |
275 assert(s->alt_inter_vlc == 0); | |
276 assert(s->umvplus == 0); | |
277 assert(s->modified_quant==1); | |
278 assert(s->loop_filter==1); | |
279 | |
280 s->h263_aic= s->pict_type == I_TYPE; | |
281 if(s->h263_aic){ | |
282 s->y_dc_scale_table= | |
283 s->c_dc_scale_table= ff_aic_dc_scale_table; | |
284 }else{ | |
285 s->y_dc_scale_table= | |
286 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
287 } | |
288 } | |
289 | |
0 | 290 static int get_num(GetBitContext *gb) |
291 { | |
292 int n, n1; | |
293 | |
294 n = get_bits(gb, 16); | |
295 if (n >= 0x4000) { | |
296 return n - 0x4000; | |
297 } else { | |
298 n1 = get_bits(gb, 16); | |
299 return (n << 16) | n1; | |
300 } | |
301 } | |
302 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
303 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
304 |
0 | 305 /* read RV 1.0 compatible frame header */ |
306 static int rv10_decode_picture_header(MpegEncContext *s) | |
307 { | |
2378 | 308 int mb_count, pb_frame, marker, unk, mb_xy; |
0 | 309 |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
310 //printf("ff:%d\n", full_frame); |
0 | 311 marker = get_bits(&s->gb, 1); |
312 | |
313 if (get_bits(&s->gb, 1)) | |
314 s->pict_type = P_TYPE; | |
315 else | |
316 s->pict_type = I_TYPE; | |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
317 //printf("h:%X ver:%d\n",h,s->rv10_version); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1389
diff
changeset
|
318 if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n"); |
0 | 319 pb_frame = get_bits(&s->gb, 1); |
320 | |
321 #ifdef DEBUG | |
322 printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame); | |
323 #endif | |
324 | |
622
a1e54c24f221
working around undefined behavior of get-vlc if the vlc s invalid
michaelni
parents:
621
diff
changeset
|
325 if (pb_frame){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1389
diff
changeset
|
326 av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n"); |
0 | 327 return -1; |
622
a1e54c24f221
working around undefined behavior of get-vlc if the vlc s invalid
michaelni
parents:
621
diff
changeset
|
328 } |
0 | 329 |
330 s->qscale = get_bits(&s->gb, 5); | |
621 | 331 if(s->qscale==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1389
diff
changeset
|
332 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n"); |
621 | 333 return -1; |
334 } | |
0 | 335 |
336 if (s->pict_type == I_TYPE) { | |
337 if (s->rv10_version == 3) { | |
338 /* specific MPEG like DC coding not used */ | |
339 s->last_dc[0] = get_bits(&s->gb, 8); | |
340 s->last_dc[1] = get_bits(&s->gb, 8); | |
341 s->last_dc[2] = get_bits(&s->gb, 8); | |
342 #ifdef DEBUG | |
343 printf("DC:%d %d %d\n", | |
344 s->last_dc[0], | |
345 s->last_dc[1], | |
346 s->last_dc[2]); | |
347 #endif | |
348 } | |
349 } | |
350 /* if multiple packets per frame are sent, the position at which | |
351 to display the macro blocks is coded here */ | |
2378 | 352 |
353 mb_xy= s->mb_x + s->mb_y*s->mb_width; | |
354 if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){ | |
0 | 355 s->mb_x = get_bits(&s->gb, 6); /* mb_x */ |
356 s->mb_y = get_bits(&s->gb, 6); /* mb_y */ | |
357 mb_count = get_bits(&s->gb, 12); | |
358 } else { | |
359 s->mb_x = 0; | |
360 s->mb_y = 0; | |
361 mb_count = s->mb_width * s->mb_height; | |
362 } | |
622
a1e54c24f221
working around undefined behavior of get-vlc if the vlc s invalid
michaelni
parents:
621
diff
changeset
|
363 unk= get_bits(&s->gb, 3); /* ignored */ |
a1e54c24f221
working around undefined behavior of get-vlc if the vlc s invalid
michaelni
parents:
621
diff
changeset
|
364 //printf("%d\n", unk); |
0 | 365 s->f_code = 1; |
366 s->unrestricted_mv = 1; | |
624
35353e4520d8
use extradata for h263_long_vector mode detection
michaelni
parents:
622
diff
changeset
|
367 |
0 | 368 return mb_count; |
369 } | |
370 | |
1639 | 371 static int rv20_decode_picture_header(MpegEncContext *s) |
372 { | |
1642 | 373 int seq, mb_pos, i; |
1655 | 374 |
2358 | 375 #if 0 |
376 GetBitContext gb= s->gb; | |
377 for(i=0; i<64; i++){ | |
378 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb)); | |
379 if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " "); | |
380 } | |
381 av_log(s->avctx, AV_LOG_DEBUG, "\n"); | |
382 #endif | |
2376 | 383 #if 0 |
384 for(i=0; i<s->avctx->extradata_size; i++){ | |
385 av_log(s->avctx, AV_LOG_DEBUG, "%2X ", ((uint8_t*)s->avctx->extradata)[i]); | |
386 if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " "); | |
387 } | |
388 av_log(s->avctx, AV_LOG_DEBUG, "\n"); | |
389 #endif | |
2358 | 390 |
1655 | 391 if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){ |
392 if (get_bits(&s->gb, 3)){ | |
393 av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n"); | |
394 return -1; | |
395 } | |
396 } | |
1639 | 397 |
1642 | 398 i= get_bits(&s->gb, 2); |
399 switch(i){ | |
400 case 0: s->pict_type= I_TYPE; break; | |
1643 | 401 case 1: s->pict_type= I_TYPE; break; //hmm ... |
1642 | 402 case 2: s->pict_type= P_TYPE; break; |
403 case 3: s->pict_type= B_TYPE; break; | |
404 default: | |
405 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n"); | |
406 return -1; | |
407 } | |
408 | |
1844 | 409 if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){ |
410 av_log(s->avctx, AV_LOG_ERROR, "early B pix\n"); | |
411 return -1; | |
412 } | |
413 | |
1642 | 414 if (get_bits(&s->gb, 1)){ |
415 av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n"); | |
1639 | 416 return -1; |
417 } | |
418 | |
419 s->qscale = get_bits(&s->gb, 5); | |
420 if(s->qscale==0){ | |
421 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n"); | |
422 return -1; | |
423 } | |
1655 | 424 if(s->avctx->sub_id == 0x30203002){ |
425 if (get_bits(&s->gb, 1)){ | |
426 av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n"); | |
427 return -1; | |
428 } | |
429 } | |
430 | |
1657
aaaa1767acc2
set has_b_frames correctly, fixes rv20 dr1 with mplayer
michael
parents:
1655
diff
changeset
|
431 if(s->avctx->has_b_frames){ |
2387 | 432 int f=9; |
433 int v= s->avctx->extradata_size >= 4 ? ((uint8_t*)s->avctx->extradata)[1] : 0; | |
2379 | 434 |
1655 | 435 if (get_bits(&s->gb, 1)){ |
2379 | 436 av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n"); |
1700 | 437 // return -1; |
1655 | 438 } |
2376 | 439 seq= get_bits(&s->gb, 14)<<1; |
2387 | 440 |
2412
436a5f740f29
fixing decoding of http://mplayerhq.hu/~atmos4/ffrv20-crashing-atmos.rm
michael
parents:
2387
diff
changeset
|
441 if(v>1 || (s->avctx->sub_id < 0x20201002 && v>0)){ |
2387 | 442 f= get_bits(&s->gb, av_log2(v-1)+1); |
2379 | 443 } |
444 | |
445 if(s->avctx->debug & FF_DEBUG_PICT_INFO){ | |
2412
436a5f740f29
fixing decoding of http://mplayerhq.hu/~atmos4/ffrv20-crashing-atmos.rm
michael
parents:
2387
diff
changeset
|
446 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v); |
2359 | 447 } |
2376 | 448 |
449 mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1); | |
450 s->mb_x= mb_pos % s->mb_width; | |
451 s->mb_y= mb_pos / s->mb_width; | |
1701 | 452 }else{ |
1655 | 453 seq= get_bits(&s->gb, 8)*128; |
1701 | 454 mb_pos= ff_h263_decode_mba(s); |
455 } | |
1917 | 456 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq); |
1655 | 457 seq |= s->time &~0x7FFF; |
458 if(seq - s->time > 0x4000) seq -= 0x8000; | |
459 if(seq - s->time < -0x4000) seq += 0x8000; | |
460 if(seq != s->time){ | |
461 if(s->pict_type!=B_TYPE){ | |
462 s->time= seq; | |
463 s->pp_time= s->time - s->last_non_b_time; | |
464 s->last_non_b_time= s->time; | |
465 }else{ | |
466 s->time= seq; | |
467 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); | |
468 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){ | |
1823
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1796
diff
changeset
|
469 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, seeking?, skiping current b frame\n"); |
1655 | 470 return FRAME_SKIPED; |
471 } | |
472 } | |
473 } | |
474 // printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time); | |
1917 | 475 /*for(i=0; i<32; i++){ |
476 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); | |
477 } | |
478 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/ | |
1639 | 479 s->no_rounding= get_bits1(&s->gb); |
480 | |
481 s->f_code = 1; | |
482 s->unrestricted_mv = 1; | |
483 s->h263_aic= s->pict_type == I_TYPE; | |
484 // s->alt_inter_vlc=1; | |
485 // s->obmc=1; | |
486 // s->umvplus=1; | |
1644 | 487 s->modified_quant=1; |
488 s->loop_filter=1; | |
1639 | 489 |
490 if(s->avctx->debug & FF_DEBUG_PICT_INFO){ | |
1642 | 491 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n", |
1639 | 492 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding); |
493 } | |
494 | |
1655 | 495 assert(s->pict_type != B_TYPE || !s->low_delay); |
1642 | 496 |
1639 | 497 return s->mb_width*s->mb_height - mb_pos; |
498 } | |
499 | |
0 | 500 static int rv10_decode_init(AVCodecContext *avctx) |
501 { | |
502 MpegEncContext *s = avctx->priv_data; | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
503 static int done=0; |
0 | 504 |
1892 | 505 MPV_decode_defaults(s); |
506 | |
643 | 507 s->avctx= avctx; |
0 | 508 s->out_format = FMT_H263; |
1640 | 509 s->codec_id= avctx->codec_id; |
0 | 510 |
511 s->width = avctx->width; | |
512 s->height = avctx->height; | |
513 | |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
514 switch(avctx->sub_id){ |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
515 case 0x10000000: |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
516 s->rv10_version= 0; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
517 s->h263_long_vectors=0; |
1655 | 518 s->low_delay=1; |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
519 break; |
1796 | 520 case 0x10002000: |
521 s->rv10_version= 3; | |
522 s->h263_long_vectors=1; | |
523 s->low_delay=1; | |
524 s->obmc=1; | |
525 break; | |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
526 case 0x10003000: |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
527 s->rv10_version= 3; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
528 s->h263_long_vectors=1; |
1655 | 529 s->low_delay=1; |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
530 break; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
531 case 0x10003001: |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
532 s->rv10_version= 3; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
533 s->h263_long_vectors=0; |
1655 | 534 s->low_delay=1; |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
535 break; |
1639 | 536 case 0x20001000: |
1657
aaaa1767acc2
set has_b_frames correctly, fixes rv20 dr1 with mplayer
michael
parents:
1655
diff
changeset
|
537 case 0x20100001: |
aaaa1767acc2
set has_b_frames correctly, fixes rv20 dr1 with mplayer
michael
parents:
1655
diff
changeset
|
538 case 0x20101001: |
2358 | 539 case 0x20103001: |
1657
aaaa1767acc2
set has_b_frames correctly, fixes rv20 dr1 with mplayer
michael
parents:
1655
diff
changeset
|
540 s->low_delay=1; |
aaaa1767acc2
set has_b_frames correctly, fixes rv20 dr1 with mplayer
michael
parents:
1655
diff
changeset
|
541 break; |
1639 | 542 case 0x20200002: |
1917 | 543 case 0x20201002: |
1657
aaaa1767acc2
set has_b_frames correctly, fixes rv20 dr1 with mplayer
michael
parents:
1655
diff
changeset
|
544 case 0x30202002: |
aaaa1767acc2
set has_b_frames correctly, fixes rv20 dr1 with mplayer
michael
parents:
1655
diff
changeset
|
545 case 0x30203002: |
aaaa1767acc2
set has_b_frames correctly, fixes rv20 dr1 with mplayer
michael
parents:
1655
diff
changeset
|
546 s->low_delay=0; |
aaaa1767acc2
set has_b_frames correctly, fixes rv20 dr1 with mplayer
michael
parents:
1655
diff
changeset
|
547 s->avctx->has_b_frames=1; |
aaaa1767acc2
set has_b_frames correctly, fixes rv20 dr1 with mplayer
michael
parents:
1655
diff
changeset
|
548 break; |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
549 default: |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1389
diff
changeset
|
550 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id); |
624
35353e4520d8
use extradata for h263_long_vector mode detection
michaelni
parents:
622
diff
changeset
|
551 } |
2376 | 552 |
553 if(avctx->debug & FF_DEBUG_PICT_INFO){ | |
554 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1); | |
555 } | |
556 | |
0 | 557 if (MPV_common_init(s) < 0) |
558 return -1; | |
559 | |
560 h263_decode_init_vlc(s); | |
561 | |
562 /* init rv vlc */ | |
563 if (!done) { | |
547 | 564 init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, |
0 | 565 rv_lum_bits, 1, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2359
diff
changeset
|
566 rv_lum_code, 2, 2, 1); |
547 | 567 init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, |
0 | 568 rv_chrom_bits, 1, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2359
diff
changeset
|
569 rv_chrom_code, 2, 2, 1); |
0 | 570 done = 1; |
571 } | |
1284
119c814aa9de
set pix_fmt in rv10 patch by (James Stembridge <jstembridge at users dot sourceforge dot net>)
michaelni
parents:
1106
diff
changeset
|
572 |
119c814aa9de
set pix_fmt in rv10 patch by (James Stembridge <jstembridge at users dot sourceforge dot net>)
michaelni
parents:
1106
diff
changeset
|
573 avctx->pix_fmt = PIX_FMT_YUV420P; |
0 | 574 |
575 return 0; | |
576 } | |
577 | |
578 static int rv10_decode_end(AVCodecContext *avctx) | |
579 { | |
580 MpegEncContext *s = avctx->priv_data; | |
581 | |
582 MPV_common_end(s); | |
583 return 0; | |
584 } | |
585 | |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
586 static int rv10_decode_packet(AVCodecContext *avctx, |
1064 | 587 uint8_t *buf, int buf_size) |
0 | 588 { |
589 MpegEncContext *s = avctx->priv_data; | |
2031
4225c131a2eb
warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
2028
diff
changeset
|
590 int mb_count, mb_pos, left; |
0 | 591 |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
925
diff
changeset
|
592 init_get_bits(&s->gb, buf, buf_size*8); |
1639 | 593 if(s->codec_id ==CODEC_ID_RV10) |
594 mb_count = rv10_decode_picture_header(s); | |
595 else | |
596 mb_count = rv20_decode_picture_header(s); | |
0 | 597 if (mb_count < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1389
diff
changeset
|
598 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n"); |
0 | 599 return -1; |
600 } | |
601 | |
602 if (s->mb_x >= s->mb_width || | |
603 s->mb_y >= s->mb_height) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1389
diff
changeset
|
604 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y); |
0 | 605 return -1; |
606 } | |
607 mb_pos = s->mb_y * s->mb_width + s->mb_x; | |
608 left = s->mb_width * s->mb_height - mb_pos; | |
609 if (mb_count > left) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1389
diff
changeset
|
610 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n"); |
0 | 611 return -1; |
612 } | |
1639 | 613 //if(s->pict_type == P_TYPE) return 0; |
0 | 614 |
1700 | 615 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) { |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
745
diff
changeset
|
616 if(MPV_frame_start(s, avctx) < 0) |
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
745
diff
changeset
|
617 return -1; |
0 | 618 } |
619 | |
620 #ifdef DEBUG | |
621 printf("qscale=%d\n", s->qscale); | |
622 #endif | |
623 | |
624 /* default quantization values */ | |
1639 | 625 if(s->codec_id== CODEC_ID_RV10){ |
626 if(s->mb_y==0) s->first_slice_line=1; | |
627 }else{ | |
628 s->first_slice_line=1; | |
629 s->resync_mb_x= s->mb_x; | |
630 s->resync_mb_y= s->mb_y; | |
631 } | |
632 if(s->h263_aic){ | |
633 s->y_dc_scale_table= | |
634 s->c_dc_scale_table= ff_aic_dc_scale_table; | |
635 }else{ | |
636 s->y_dc_scale_table= | |
637 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
638 } | |
1644 | 639 |
640 if(s->modified_quant) | |
641 s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
642 | |
1652 | 643 ff_set_qscale(s, s->qscale); |
1644 | 644 |
0 | 645 s->rv10_first_dc_coded[0] = 0; |
646 s->rv10_first_dc_coded[1] = 0; | |
647 s->rv10_first_dc_coded[2] = 0; | |
1748 | 648 //printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]); |
450 | 649 s->block_wrap[0]= |
650 s->block_wrap[1]= | |
651 s->block_wrap[2]= | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1917
diff
changeset
|
652 s->block_wrap[3]= s->b8_stride; |
450 | 653 s->block_wrap[4]= |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1917
diff
changeset
|
654 s->block_wrap[5]= s->mb_stride; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
713
diff
changeset
|
655 ff_init_block_index(s); |
0 | 656 /* decode each macroblock */ |
1796 | 657 |
658 for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) { | |
1639 | 659 int ret; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
713
diff
changeset
|
660 ff_update_block_index(s); |
0 | 661 #ifdef DEBUG |
662 printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); | |
663 #endif | |
1796 | 664 |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
771
diff
changeset
|
665 s->dsp.clear_blocks(s->block[0]); |
0 | 666 s->mv_dir = MV_DIR_FORWARD; |
667 s->mv_type = MV_TYPE_16X16; | |
1639 | 668 ret=ff_h263_decode_mb(s, s->block); |
669 | |
670 if (ret == SLICE_ERROR) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1389
diff
changeset
|
671 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y); |
0 | 672 return -1; |
673 } | |
1748 | 674 if(s->pict_type != B_TYPE) |
675 ff_h263_update_motion_val(s); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
713
diff
changeset
|
676 MPV_decode_mb(s, s->block); |
1644 | 677 if(s->loop_filter) |
678 ff_h263_loop_filter(s); | |
679 | |
0 | 680 if (++s->mb_x == s->mb_width) { |
681 s->mb_x = 0; | |
682 s->mb_y++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
713
diff
changeset
|
683 ff_init_block_index(s); |
1639 | 684 } |
685 if(s->mb_x == s->resync_mb_x) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
713
diff
changeset
|
686 s->first_slice_line=0; |
1639 | 687 if(ret == SLICE_END) break; |
0 | 688 } |
689 | |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
690 return buf_size; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
691 } |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
692 |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
693 static int rv10_decode_frame(AVCodecContext *avctx, |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
694 void *data, int *data_size, |
1064 | 695 uint8_t *buf, int buf_size) |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
696 { |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
697 MpegEncContext *s = avctx->priv_data; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
698 int i; |
925 | 699 AVFrame *pict = data; |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
700 |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
701 #ifdef DEBUG |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
702 printf("*****frame %d size=%d\n", avctx->frame_number, buf_size); |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
703 #endif |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
704 |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
705 /* no supplementary picture */ |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
706 if (buf_size == 0) { |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
707 return 0; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
708 } |
1748 | 709 |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
710 if(avctx->slice_count){ |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
711 for(i=0; i<avctx->slice_count; i++){ |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
712 int offset= avctx->slice_offset[i]; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
713 int size; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
714 |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
715 if(i+1 == avctx->slice_count) |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
716 size= buf_size - offset; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
717 else |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
718 size= avctx->slice_offset[i+1] - offset; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
719 |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
720 if( rv10_decode_packet(avctx, buf+offset, size) < 0 ) |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
721 return -1; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
722 } |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
723 }else{ |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
724 if( rv10_decode_packet(avctx, buf, buf_size) < 0 ) |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
725 return -1; |
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
726 } |
1701 | 727 |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
728 if(s->mb_y>=s->mb_height){ |
0 | 729 MPV_frame_end(s); |
1655 | 730 |
731 if(s->pict_type==B_TYPE || s->low_delay){ | |
732 *pict= *(AVFrame*)&s->current_picture; | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1701
diff
changeset
|
733 ff_print_debug_info(s, pict); |
1655 | 734 } else { |
735 *pict= *(AVFrame*)&s->last_picture; | |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1701
diff
changeset
|
736 ff_print_debug_info(s, pict); |
1655 | 737 } |
2359 | 738 if(s->last_picture_ptr || s->low_delay) |
739 *data_size = sizeof(AVFrame); | |
0 | 740 } |
713
e74a563eb643
rv10 cleanup (de)muxer still needs to be cleaned up (still searching volunteer for that ;) )
michaelni
parents:
712
diff
changeset
|
741 |
0 | 742 return buf_size; |
743 } | |
744 | |
745 AVCodec rv10_decoder = { | |
746 "rv10", | |
747 CODEC_TYPE_VIDEO, | |
748 CODEC_ID_RV10, | |
749 sizeof(MpegEncContext), | |
750 rv10_decode_init, | |
751 NULL, | |
752 rv10_decode_end, | |
753 rv10_decode_frame, | |
559 | 754 CODEC_CAP_DR1 |
0 | 755 }; |
1639 | 756 |
757 AVCodec rv20_decoder = { | |
758 "rv20", | |
759 CODEC_TYPE_VIDEO, | |
760 CODEC_ID_RV20, | |
761 sizeof(MpegEncContext), | |
762 rv10_decode_init, | |
763 NULL, | |
764 rv10_decode_end, | |
765 rv10_decode_frame, | |
2453 | 766 CODEC_CAP_DR1 | CODEC_CAP_DELAY, |
2379 | 767 .flush= ff_mpeg_flush, |
1639 | 768 }; |
1655 | 769 |