?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
error_resilience: decouple ER from MpegEncContext
[FFMpeg-mirror/mplayer-patches.git] / libavcodec / rv10.c
blob9a9da919d81ff2f4f794118ee05abf5b454053b3
1 /*
2 * RV10/RV20 decoder
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer
5 *
6 * This file is part of Libav.
7 *
8 * Libav is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * Libav is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with Libav; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 /**
24 * @file
25 * RV10/RV20 decoder
26 */
27
28 #include "libavutil/imgutils.h"
29 #include "avcodec.h"
30 #include "dsputil.h"
31 #include "mpegvideo.h"
32 #include "mpeg4video.h"
33 #include "h263.h"
34
35 //#define DEBUG
36
37 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
38 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
39 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
40
41 #define DC_VLC_BITS 14 //FIXME find a better solution
42
43 typedef struct RVDecContext {
44 MpegEncContext m;
45 int sub_id;
46 } RVDecContext;
47
48 static const uint16_t rv_lum_code[256] =
49 {
50 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
51 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
52 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
53 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
54 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
55 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
56 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
57 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
58 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
59 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
60 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
61 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
62 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
63 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
64 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
65 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
66 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
67 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
68 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
69 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
70 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
71 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
72 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
73 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
74 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
75 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
76 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
77 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
78 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
79 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
80 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
81 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
82 };
83
84 static const uint8_t rv_lum_bits[256] =
85 {
86 14, 12, 12, 12, 12, 12, 12, 12,
87 12, 12, 12, 12, 12, 12, 12, 12,
88 12, 12, 12, 12, 12, 12, 12, 12,
89 12, 12, 12, 12, 12, 12, 12, 12,
90 12, 12, 12, 12, 12, 12, 12, 12,
91 12, 12, 12, 12, 12, 12, 12, 12,
92 12, 12, 12, 12, 12, 12, 12, 12,
93 12, 12, 12, 12, 12, 12, 12, 12,
94 12, 10, 10, 10, 10, 10, 10, 10,
95 10, 10, 10, 10, 10, 10, 10, 10,
96 10, 10, 10, 10, 10, 10, 10, 10,
97 10, 10, 10, 10, 10, 10, 10, 10,
98 10, 8, 8, 8, 8, 8, 8, 8,
99 8, 8, 8, 8, 8, 8, 8, 8,
100 8, 7, 7, 7, 7, 7, 7, 7,
101 7, 6, 6, 6, 6, 5, 5, 4,
102 2, 4, 5, 5, 6, 6, 6, 6,
103 7, 7, 7, 7, 7, 7, 7, 7,
104 8, 8, 8, 8, 8, 8, 8, 8,
105 8, 8, 8, 8, 8, 8, 8, 8,
106 10, 10, 10, 10, 10, 10, 10, 10,
107 10, 10, 10, 10, 10, 10, 10, 10,
108 10, 10, 10, 10, 10, 10, 10, 10,
109 10, 10, 10, 10, 10, 10, 10, 10,
110 12, 12, 12, 12, 12, 12, 12, 12,
111 12, 12, 12, 12, 12, 12, 12, 12,
112 12, 12, 12, 12, 12, 12, 12, 12,
113 12, 12, 12, 12, 12, 12, 12, 12,
114 12, 12, 12, 12, 12, 12, 12, 12,
115 12, 12, 12, 12, 12, 12, 12, 12,
116 12, 12, 12, 12, 12, 12, 12, 12,
117 12, 12, 12, 12, 12, 12, 12, 12,
118 };
119
120 static const uint16_t rv_chrom_code[256] =
121 {
122 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
123 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
124 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
125 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
126 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
127 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
128 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
129 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
130 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
131 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
132 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
133 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
134 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
135 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
136 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
137 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
138 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
139 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
140 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
141 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
142 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
143 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
144 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
145 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
146 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
147 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
148 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
149 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
150 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
151 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
152 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
153 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
154 };
155
156 static const uint8_t rv_chrom_bits[256] =
157 {
158 16, 14, 14, 14, 14, 14, 14, 14,
159 14, 14, 14, 14, 14, 14, 14, 14,
160 14, 14, 14, 14, 14, 14, 14, 14,
161 14, 14, 14, 14, 14, 14, 14, 14,
162 14, 14, 14, 14, 14, 14, 14, 14,
163 14, 14, 14, 14, 14, 14, 14, 14,
164 14, 14, 14, 14, 14, 14, 14, 14,
165 14, 14, 14, 14, 14, 14, 14, 14,
166 14, 12, 12, 12, 12, 12, 12, 12,
167 12, 12, 12, 12, 12, 12, 12, 12,
168 12, 12, 12, 12, 12, 12, 12, 12,
169 12, 12, 12, 12, 12, 12, 12, 12,
170 12, 10, 10, 10, 10, 10, 10, 10,
171 10, 10, 10, 10, 10, 10, 10, 10,
172 10, 8, 8, 8, 8, 8, 8, 8,
173 8, 6, 6, 6, 6, 4, 4, 3,
174 2, 3, 4, 4, 6, 6, 6, 6,
175 8, 8, 8, 8, 8, 8, 8, 8,
176 10, 10, 10, 10, 10, 10, 10, 10,
177 10, 10, 10, 10, 10, 10, 10, 10,
178 12, 12, 12, 12, 12, 12, 12, 12,
179 12, 12, 12, 12, 12, 12, 12, 12,
180 12, 12, 12, 12, 12, 12, 12, 12,
181 12, 12, 12, 12, 12, 12, 12, 12,
182 14, 14, 14, 14, 14, 14, 14, 14,
183 14, 14, 14, 14, 14, 14, 14, 14,
184 14, 14, 14, 14, 14, 14, 14, 14,
185 14, 14, 14, 14, 14, 14, 14, 14,
186 14, 14, 14, 14, 14, 14, 14, 14,
187 14, 14, 14, 14, 14, 14, 14, 14,
188 14, 14, 14, 14, 14, 14, 14, 14,
189 14, 14, 14, 14, 14, 14, 14, 14,
190 };
191
192 static VLC rv_dc_lum, rv_dc_chrom;
193
194 int ff_rv_decode_dc(MpegEncContext *s, int n)
195 {
196 int code;
197
198 if (n < 4) {
199 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
200 if (code < 0) {
201 /* XXX: I don't understand why they use LONGER codes than
202 necessary. The following code would be completely useless
203 if they had thought about it !!! */
204 code = get_bits(&s->gb, 7);
205 if (code == 0x7c) {
206 code = (int8_t)(get_bits(&s->gb, 7) + 1);
207 } else if (code == 0x7d) {
208 code = -128 + get_bits(&s->gb, 7);
209 } else if (code == 0x7e) {
210 if (get_bits1(&s->gb) == 0)
211 code = (int8_t)(get_bits(&s->gb, 8) + 1);
212 else
213 code = (int8_t)(get_bits(&s->gb, 8));
214 } else if (code == 0x7f) {
215 skip_bits(&s->gb, 11);
216 code = 1;
217 }
218 } else {
219 code -= 128;
220 }
221 } else {
222 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
223 /* same remark */
224 if (code < 0) {
225 code = get_bits(&s->gb, 9);
226 if (code == 0x1fc) {
227 code = (int8_t)(get_bits(&s->gb, 7) + 1);
228 } else if (code == 0x1fd) {
229 code = -128 + get_bits(&s->gb, 7);
230 } else if (code == 0x1fe) {
231 skip_bits(&s->gb, 9);
232 code = 1;
233 } else {
234 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
235 return 0xffff;
236 }
237 } else {
238 code -= 128;
239 }
240 }
241 return -code;
242 }
243
244 /* read RV 1.0 compatible frame header */
245 static int rv10_decode_picture_header(MpegEncContext *s)
246 {
247 int mb_count, pb_frame, marker, mb_xy;
248
249 marker = get_bits1(&s->gb);
250
251 if (get_bits1(&s->gb))
252 s->pict_type = AV_PICTURE_TYPE_P;
253 else
254 s->pict_type = AV_PICTURE_TYPE_I;
255 if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
256 pb_frame = get_bits1(&s->gb);
257
258 av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
259
260 if (pb_frame){
261 av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
262 return -1;
263 }
264
265 s->qscale = get_bits(&s->gb, 5);
266 if(s->qscale==0){
267 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
268 return -1;
269 }
270
271 if (s->pict_type == AV_PICTURE_TYPE_I) {
272 if (s->rv10_version == 3) {
273 /* specific MPEG like DC coding not used */
274 s->last_dc[0] = get_bits(&s->gb, 8);
275 s->last_dc[1] = get_bits(&s->gb, 8);
276 s->last_dc[2] = get_bits(&s->gb, 8);
277 av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
278 s->last_dc[1], s->last_dc[2]);
279 }
280 }
281 /* if multiple packets per frame are sent, the position at which
282 to display the macroblocks is coded here */
283
284 mb_xy= s->mb_x + s->mb_y*s->mb_width;
285 if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
286 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
287 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
288 mb_count = get_bits(&s->gb, 12);
289 } else {
290 s->mb_x = 0;
291 s->mb_y = 0;
292 mb_count = s->mb_width * s->mb_height;
293 }
294 skip_bits(&s->gb, 3); /* ignored */
295 s->f_code = 1;
296 s->unrestricted_mv = 1;
297
298 return mb_count;
299 }
300
301 static int rv20_decode_picture_header(RVDecContext *rv)
302 {
303 MpegEncContext *s = &rv->m;
304 int seq, mb_pos, i;
305 int rpr_bits;
306
307 i= get_bits(&s->gb, 2);
308 switch(i){
309 case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
310 case 1: s->pict_type= AV_PICTURE_TYPE_I; break; //hmm ...
311 case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
312 case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
313 default:
314 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
315 return -1;
316 }
317
318 if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
319 av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
320 return -1;
321 }
322
323 if (get_bits1(&s->gb)){
324 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
325 return -1;
326 }
327
328 s->qscale = get_bits(&s->gb, 5);
329 if(s->qscale==0){
330 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
331 return -1;
332 }
333
334 if(RV_GET_MINOR_VER(rv->sub_id) >= 2)
335 s->loop_filter = get_bits1(&s->gb);
336
337 if(RV_GET_MINOR_VER(rv->sub_id) <= 1)
338 seq = get_bits(&s->gb, 8) << 7;
339 else
340 seq = get_bits(&s->gb, 13) << 2;
341
342 rpr_bits = s->avctx->extradata[1] & 7;
343 if(rpr_bits){
344 int f, new_w, new_h;
345 rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
346
347 f = get_bits(&s->gb, rpr_bits);
348
349 if(f){
350 new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
351 new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
352 }else{
353 new_w= s->orig_width ;
354 new_h= s->orig_height;
355 }
356 if(new_w != s->width || new_h != s->height){
357 av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
358 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
359 return -1;
360 ff_MPV_common_end(s);
361 avcodec_set_dimensions(s->avctx, new_w, new_h);
362 s->width = new_w;
363 s->height = new_h;
364 if (ff_MPV_common_init(s) < 0)
365 return -1;
366 }
367
368 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
369 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
370 }
371 } else if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
372 return AVERROR_INVALIDDATA;
373
374 mb_pos = ff_h263_decode_mba(s);
375
376 seq |= s->time &~0x7FFF;
377 if(seq - s->time > 0x4000) seq -= 0x8000;
378 if(seq - s->time < -0x4000) seq += 0x8000;
379 if(seq != s->time){
380 if(s->pict_type!=AV_PICTURE_TYPE_B){
381 s->time= seq;
382 s->pp_time= s->time - s->last_non_b_time;
383 s->last_non_b_time= s->time;
384 }else{
385 s->time= seq;
386 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
387 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
388 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
389 return FRAME_SKIPPED;
390 }
391 ff_mpeg4_init_direct_mv(s);
392 }
393 }
394
395 s->no_rounding= get_bits1(&s->gb);
396
397 if(RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
398 skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
399
400 s->f_code = 1;
401 s->unrestricted_mv = 1;
402 s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
403 // s->alt_inter_vlc=1;
404 // s->obmc=1;
405 // s->umvplus=1;
406 s->modified_quant=1;
407 s->loop_filter=1;
408
409 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
410 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
411 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
412 }
413
414 assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
415
416 return s->mb_width*s->mb_height - mb_pos;
417 }
418
419 static av_cold int rv10_decode_init(AVCodecContext *avctx)
420 {
421 RVDecContext *rv = avctx->priv_data;
422 MpegEncContext *s = &rv->m;
423 static int done=0;
424 int major_ver, minor_ver, micro_ver;
425
426 if (avctx->extradata_size < 8) {
427 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
428 return -1;
429 }
430
431 ff_MPV_decode_defaults(s);
432
433 s->avctx= avctx;
434 s->out_format = FMT_H263;
435 s->codec_id= avctx->codec_id;
436 avctx->flags |= CODEC_FLAG_EMU_EDGE;
437
438 s->orig_width = s->width = avctx->coded_width;
439 s->orig_height= s->height = avctx->coded_height;
440
441 s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
442 rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
443
444 major_ver = RV_GET_MAJOR_VER(rv->sub_id);
445 minor_ver = RV_GET_MINOR_VER(rv->sub_id);
446 micro_ver = RV_GET_MICRO_VER(rv->sub_id);
447
448 s->low_delay = 1;
449 switch (major_ver) {
450 case 1:
451 s->rv10_version = micro_ver ? 3 : 1;
452 s->obmc = micro_ver == 2;
453 break;
454 case 2:
455 if (minor_ver >= 2) {
456 s->low_delay = 0;
457 s->avctx->has_b_frames = 1;
458 }
459 break;
460 default:
461 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
462 av_log_missing_feature(avctx, "RV1/2 version", 1);
463 return AVERROR_PATCHWELCOME;
464 }
465
466 if(avctx->debug & FF_DEBUG_PICT_INFO){
467 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
468 }
469
470 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
471
472 if (ff_MPV_common_init(s) < 0)
473 return -1;
474
475 ff_h263_decode_init_vlc();
476
477 /* init rv vlc */
478 if (!done) {
479 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
480 rv_lum_bits, 1, 1,
481 rv_lum_code, 2, 2, 16384);
482 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
483 rv_chrom_bits, 1, 1,
484 rv_chrom_code, 2, 2, 16388);
485 done = 1;
486 }
487
488 return 0;
489 }
490
491 static av_cold int rv10_decode_end(AVCodecContext *avctx)
492 {
493 MpegEncContext *s = avctx->priv_data;
494
495 ff_MPV_common_end(s);
496 return 0;
497 }
498
499 static int rv10_decode_packet(AVCodecContext *avctx,
500 const uint8_t *buf, int buf_size, int buf_size2)
501 {
502 RVDecContext *rv = avctx->priv_data;
503 MpegEncContext *s = &rv->m;
504 int mb_count, mb_pos, left, start_mb_x, active_bits_size;
505
506 active_bits_size = buf_size * 8;
507 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
508 if(s->codec_id ==AV_CODEC_ID_RV10)
509 mb_count = rv10_decode_picture_header(s);
510 else
511 mb_count = rv20_decode_picture_header(rv);
512 if (mb_count < 0) {
513 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
514 return -1;
515 }
516
517 if (s->mb_x >= s->mb_width ||
518 s->mb_y >= s->mb_height) {
519 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
520 return -1;
521 }
522 mb_pos = s->mb_y * s->mb_width + s->mb_x;
523 left = s->mb_width * s->mb_height - mb_pos;
524 if (mb_count > left) {
525 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
526 return -1;
527 }
528
529 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
530 if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
531 ff_er_frame_end(&s->er);
532 ff_MPV_frame_end(s);
533 s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
534 }
535 if(ff_MPV_frame_start(s, avctx) < 0)
536 return -1;
537 ff_mpeg_er_frame_start(s);
538 } else {
539 if (s->current_picture_ptr->f.pict_type != s->pict_type) {
540 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
541 return -1;
542 }
543 }
544
545 av_dlog(avctx, "qscale=%d\n", s->qscale);
546
547 /* default quantization values */
548 if(s->codec_id== AV_CODEC_ID_RV10){
549 if(s->mb_y==0) s->first_slice_line=1;
550 }else{
551 s->first_slice_line=1;
552 s->resync_mb_x= s->mb_x;
553 }
554 start_mb_x= s->mb_x;
555 s->resync_mb_y= s->mb_y;
556 if(s->h263_aic){
557 s->y_dc_scale_table=
558 s->c_dc_scale_table= ff_aic_dc_scale_table;
559 }else{
560 s->y_dc_scale_table=
561 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
562 }
563
564 if(s->modified_quant)
565 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
566
567 ff_set_qscale(s, s->qscale);
568
569 s->rv10_first_dc_coded[0] = 0;
570 s->rv10_first_dc_coded[1] = 0;
571 s->rv10_first_dc_coded[2] = 0;
572 s->block_wrap[0]=
573 s->block_wrap[1]=
574 s->block_wrap[2]=
575 s->block_wrap[3]= s->b8_stride;
576 s->block_wrap[4]=
577 s->block_wrap[5]= s->mb_stride;
578 ff_init_block_index(s);
579 /* decode each macroblock */
580
581 for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
582 int ret;
583 ff_update_block_index(s);
584 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
585
586 s->mv_dir = MV_DIR_FORWARD;
587 s->mv_type = MV_TYPE_16X16;
588 ret=ff_h263_decode_mb(s, s->block);
589
590 // Repeat the slice end check from ff_h263_decode_mb with our active
591 // bitstream size
592 if (ret != SLICE_ERROR) {
593 int v = show_bits(&s->gb, 16);
594
595 if (get_bits_count(&s->gb) + 16 > active_bits_size)
596 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
597
598 if (!v)
599 ret = SLICE_END;
600 }
601 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
602 8 * buf_size2 >= get_bits_count(&s->gb)) {
603 active_bits_size = buf_size2 * 8;
604 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
605 8 * buf_size, active_bits_size);
606 ret= SLICE_OK;
607 }
608
609 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
610 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
611 return -1;
612 }
613 if(s->pict_type != AV_PICTURE_TYPE_B)
614 ff_h263_update_motion_val(s);
615 ff_MPV_decode_mb(s, s->block);
616 if(s->loop_filter)
617 ff_h263_loop_filter(s);
618
619 if (++s->mb_x == s->mb_width) {
620 s->mb_x = 0;
621 s->mb_y++;
622 ff_init_block_index(s);
623 }
624 if(s->mb_x == s->resync_mb_x)
625 s->first_slice_line=0;
626 if(ret == SLICE_END) break;
627 }
628
629 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
630
631 return active_bits_size;
632 }
633
634 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
635 {
636 if(avctx->slice_count) return avctx->slice_offset[n];
637 else return AV_RL32(buf + n*8);
638 }
639
640 static int rv10_decode_frame(AVCodecContext *avctx,
641 void *data, int *got_frame,
642 AVPacket *avpkt)
643 {
644 const uint8_t *buf = avpkt->data;
645 int buf_size = avpkt->size;
646 MpegEncContext *s = avctx->priv_data;
647 int i;
648 AVFrame *pict = data;
649 int slice_count;
650 const uint8_t *slices_hdr = NULL;
651
652 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
653
654 /* no supplementary picture */
655 if (buf_size == 0) {
656 return 0;
657 }
658
659 if(!avctx->slice_count){
660 slice_count = (*buf++) + 1;
661 buf_size--;
662
663 if (!slice_count || buf_size <= 8 * slice_count) {
664 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
665 return AVERROR_INVALIDDATA;
666 }
667
668 slices_hdr = buf + 4;
669 buf += 8 * slice_count;
670 buf_size -= 8 * slice_count;
671 }else
672 slice_count = avctx->slice_count;
673
674 for(i=0; i<slice_count; i++){
675 unsigned offset = get_slice_offset(avctx, slices_hdr, i);
676 int size, size2;
677
678 if (offset >= buf_size)
679 return AVERROR_INVALIDDATA;
680
681 if(i+1 == slice_count)
682 size= buf_size - offset;
683 else
684 size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
685
686 if(i+2 >= slice_count)
687 size2= buf_size - offset;
688 else
689 size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
690
691 if (size <= 0 || size2 <= 0 ||
692 offset + FFMAX(size, size2) > buf_size)
693 return AVERROR_INVALIDDATA;
694
695 if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
696 i++;
697 }
698
699 if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
700 ff_er_frame_end(&s->er);
701 ff_MPV_frame_end(s);
702
703 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
704 *pict = s->current_picture_ptr->f;
705 } else if (s->last_picture_ptr != NULL) {
706 *pict = s->last_picture_ptr->f;
707 }
708
709 if(s->last_picture_ptr || s->low_delay){
710 *got_frame = 1;
711 ff_print_debug_info(s, pict);
712 }
713 s->current_picture_ptr= NULL; // so we can detect if frame_end was not called (find some nicer solution...)
714 }
715
716 return avpkt->size;
717 }
718
719 AVCodec ff_rv10_decoder = {
720 .name = "rv10",
721 .type = AVMEDIA_TYPE_VIDEO,
722 .id = AV_CODEC_ID_RV10,
723 .priv_data_size = sizeof(RVDecContext),
724 .init = rv10_decode_init,
725 .close = rv10_decode_end,
726 .decode = rv10_decode_frame,
727 .capabilities = CODEC_CAP_DR1,
728 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
729 .pix_fmts = ff_pixfmt_list_420,
730 };
731
732 AVCodec ff_rv20_decoder = {
733 .name = "rv20",
734 .type = AVMEDIA_TYPE_VIDEO,
735 .id = AV_CODEC_ID_RV20,
736 .priv_data_size = sizeof(RVDecContext),
737 .init = rv10_decode_init,
738 .close = rv10_decode_end,
739 .decode = rv10_decode_frame,
740 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
741 .flush = ff_mpeg_flush,
742 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
743 .pix_fmts = ff_pixfmt_list_420,
744 };
A couple of patches to make building with MPlayer easier