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