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