lavc: drop ff_pixfmt_list_420
[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 "mpegvideo.h"
37 #include "mpeg4video.h"
38
39 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
40 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
41 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
42
43 #define DC_VLC_BITS 14 // FIXME find a better solution
44
45 typedef struct RVDecContext {
46 MpegEncContext m;
47 int sub_id;
48 } RVDecContext;
49
50 static const uint16_t rv_lum_code[256] = {
51 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
52 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
53 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
54 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
55 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
56 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
57 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
58 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
59 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
60 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
61 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
62 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
63 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
64 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
65 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
66 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
67 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
68 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
69 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
70 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
71 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
72 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
73 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
74 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
75 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
76 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
77 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
78 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
79 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
80 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
81 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
82 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
83 };
84
85 static const uint8_t rv_lum_bits[256] = {
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 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 16, 14, 14, 14, 14, 14, 14, 14,
157 14, 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, 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 12, 10, 10, 10, 10, 10, 10, 10,
169 10, 10, 10, 10, 10, 10, 10, 10,
170 10, 8, 8, 8, 8, 8, 8, 8,
171 8, 6, 6, 6, 6, 4, 4, 3,
172 2, 3, 4, 4, 6, 6, 6, 6,
173 8, 8, 8, 8, 8, 8, 8, 8,
174 10, 10, 10, 10, 10, 10, 10, 10,
175 10, 10, 10, 10, 10, 10, 10, 10,
176 12, 12, 12, 12, 12, 12, 12, 12,
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 14, 14, 14, 14, 14, 14, 14, 14,
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 };
189
190 static VLC rv_dc_lum, rv_dc_chrom;
191
192 int ff_rv_decode_dc(MpegEncContext *s, int n)
193 {
194 int code;
195
196 if (n < 4) {
197 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
198 if (code < 0) {
199 /* XXX: I don't understand why they use LONGER codes than
200 * necessary. The following code would be completely useless
201 * if they had thought about it !!! */
202 code = get_bits(&s->gb, 7);
203 if (code == 0x7c) {
204 code = (int8_t) (get_bits(&s->gb, 7) + 1);
205 } else if (code == 0x7d) {
206 code = -128 + get_bits(&s->gb, 7);
207 } else if (code == 0x7e) {
208 if (get_bits1(&s->gb) == 0)
209 code = (int8_t) (get_bits(&s->gb, 8) + 1);
210 else
211 code = (int8_t) (get_bits(&s->gb, 8));
212 } else if (code == 0x7f) {
213 skip_bits(&s->gb, 11);
214 code = 1;
215 }
216 } else {
217 code -= 128;
218 }
219 } else {
220 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
221 /* same remark */
222 if (code < 0) {
223 code = get_bits(&s->gb, 9);
224 if (code == 0x1fc) {
225 code = (int8_t) (get_bits(&s->gb, 7) + 1);
226 } else if (code == 0x1fd) {
227 code = -128 + get_bits(&s->gb, 7);
228 } else if (code == 0x1fe) {
229 skip_bits(&s->gb, 9);
230 code = 1;
231 } else {
232 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
233 return 0xffff;
234 }
235 } else {
236 code -= 128;
237 }
238 }
239 return -code;
240 }
241
242 /* read RV 1.0 compatible frame header */
243 static int rv10_decode_picture_header(MpegEncContext *s)
244 {
245 int mb_count, pb_frame, marker, mb_xy;
246
247 marker = get_bits1(&s->gb);
248
249 if (get_bits1(&s->gb))
250 s->pict_type = AV_PICTURE_TYPE_P;
251 else
252 s->pict_type = AV_PICTURE_TYPE_I;
253
254 if (!marker)
255 av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
256
257 pb_frame = get_bits1(&s->gb);
258
259 av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
260
261 if (pb_frame) {
262 avpriv_request_sample(s->avctx, "pb frame");
263 return AVERROR_PATCHWELCOME;
264 }
265
266 s->qscale = get_bits(&s->gb, 5);
267 if (s->qscale == 0) {
268 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
269 return AVERROR_INVALIDDATA;
270 }
271
272 if (s->pict_type == AV_PICTURE_TYPE_I) {
273 if (s->rv10_version == 3) {
274 /* specific MPEG like DC coding not used */
275 s->last_dc[0] = get_bits(&s->gb, 8);
276 s->last_dc[1] = get_bits(&s->gb, 8);
277 s->last_dc[2] = get_bits(&s->gb, 8);
278 av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
279 s->last_dc[1], s->last_dc[2]);
280 }
281 }
282 /* if multiple packets per frame are sent, the position at which
283 * to display the macroblocks is coded here */
284
285 mb_xy = s->mb_x + s->mb_y * s->mb_width;
286 if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
287 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
288 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
289 mb_count = get_bits(&s->gb, 12);
290 } else {
291 s->mb_x = 0;
292 s->mb_y = 0;
293 mb_count = s->mb_width * s->mb_height;
294 }
295 skip_bits(&s->gb, 3); /* ignored */
296 s->f_code = 1;
297 s->unrestricted_mv = 1;
298
299 return mb_count;
300 }
301
302 static int rv20_decode_picture_header(RVDecContext *rv)
303 {
304 MpegEncContext *s = &rv->m;
305 int seq, mb_pos, i, ret;
306 int rpr_bits;
307
308 i = get_bits(&s->gb, 2);
309 switch (i) {
310 case 0:
311 s->pict_type = AV_PICTURE_TYPE_I;
312 break;
313 case 1:
314 s->pict_type = AV_PICTURE_TYPE_I;
315 break; // hmm ...
316 case 2:
317 s->pict_type = AV_PICTURE_TYPE_P;
318 break;
319 case 3:
320 s->pict_type = AV_PICTURE_TYPE_B;
321 break;
322 default:
323 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
324 return AVERROR_INVALIDDATA;
325 }
326
327 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
328 av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
329 return AVERROR_INVALIDDATA;
330 }
331
332 if (get_bits1(&s->gb)) {
333 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
334 return AVERROR_INVALIDDATA;
335 }
336
337 s->qscale = get_bits(&s->gb, 5);
338 if (s->qscale == 0) {
339 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
340 return AVERROR_INVALIDDATA;
341 }
342
343 if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
344 s->loop_filter = get_bits1(&s->gb);
345
346 if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
347 seq = get_bits(&s->gb, 8) << 7;
348 else
349 seq = get_bits(&s->gb, 13) << 2;
350
351 rpr_bits = s->avctx->extradata[1] & 7;
352 if (rpr_bits) {
353 int f, new_w, new_h;
354 rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
355
356 f = get_bits(&s->gb, rpr_bits);
357
358 if (f) {
359 if (s->avctx->extradata_size < 8 + 2 * f) {
360 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
361 return AVERROR_INVALIDDATA;
362 }
363
364 new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];
365 new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];
366 } else {
367 new_w = s->orig_width;
368 new_h = s->orig_height;
369 }
370 if (new_w != s->width || new_h != s->height) {
371 av_log(s->avctx, AV_LOG_DEBUG,
372 "attempting to change resolution to %dx%d\n", new_w, new_h);
373 ff_MPV_common_end(s);
374
375 ret = ff_set_dimensions(s->avctx, new_w, new_h);
376 if (ret < 0)
377 return ret;
378
379 s->width = new_w;
380 s->height = new_h;
381 if ((ret = ff_MPV_common_init(s)) < 0)
382 return ret;
383 }
384
385 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
386 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
387 }
388 } else if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
389 return AVERROR_INVALIDDATA;
390
391 mb_pos = ff_h263_decode_mba(s);
392
393 seq |= s->time & ~0x7FFF;
394 if (seq - s->time > 0x4000)
395 seq -= 0x8000;
396 if (seq - s->time < -0x4000)
397 seq += 0x8000;
398
399 if (seq != s->time) {
400 if (s->pict_type != AV_PICTURE_TYPE_B) {
401 s->time = seq;
402 s->pp_time = s->time - s->last_non_b_time;
403 s->last_non_b_time = s->time;
404 } else {
405 s->time = seq;
406 s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
407 if (s->pp_time <= s->pb_time ||
408 s->pp_time <= s->pp_time - s->pb_time || s->pp_time <= 0) {
409 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible "
410 "from seeking? skipping current b frame\n");
411 return FRAME_SKIPPED;
412 }
413 ff_mpeg4_init_direct_mv(s);
414 }
415 }
416
417 s->no_rounding = get_bits1(&s->gb);
418
419 if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
420 // binary decoder reads 3+2 bits here but they don't seem to be used
421 skip_bits(&s->gb, 5);
422
423 s->f_code = 1;
424 s->unrestricted_mv = 1;
425 s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;
426 s->modified_quant = 1;
427 s->loop_filter = 1;
428
429 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
430 av_log(s->avctx, AV_LOG_INFO,
431 "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
432 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,
433 s->no_rounding);
434 }
435
436 assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
437
438 return s->mb_width * s->mb_height - mb_pos;
439 }
440
441 static av_cold int rv10_decode_init(AVCodecContext *avctx)
442 {
443 RVDecContext *rv = avctx->priv_data;
444 MpegEncContext *s = &rv->m;
445 static int done = 0;
446 int major_ver, minor_ver, micro_ver, ret;
447
448 if (avctx->extradata_size < 8) {
449 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
450 return AVERROR_INVALIDDATA;
451 }
452 if ((ret = av_image_check_size(avctx->coded_width,
453 avctx->coded_height, 0, avctx)) < 0)
454 return ret;
455
456 ff_MPV_decode_defaults(s);
457
458 s->avctx = avctx;
459 s->out_format = FMT_H263;
460 s->codec_id = avctx->codec_id;
461
462 s->orig_width =
463 s->width = avctx->coded_width;
464 s->orig_height =
465 s->height = avctx->coded_height;
466
467 s->h263_long_vectors = ((uint8_t *) avctx->extradata)[3] & 1;
468 rv->sub_id = AV_RB32((uint8_t *) avctx->extradata + 4);
469
470 major_ver = RV_GET_MAJOR_VER(rv->sub_id);
471 minor_ver = RV_GET_MINOR_VER(rv->sub_id);
472 micro_ver = RV_GET_MICRO_VER(rv->sub_id);
473
474 s->low_delay = 1;
475 switch (major_ver) {
476 case 1:
477 s->rv10_version = micro_ver ? 3 : 1;
478 s->obmc = micro_ver == 2;
479 break;
480 case 2:
481 if (minor_ver >= 2) {
482 s->low_delay = 0;
483 s->avctx->has_b_frames = 1;
484 }
485 break;
486 default:
487 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
488 avpriv_request_sample(avctx, "RV1/2 version");
489 return AVERROR_PATCHWELCOME;
490 }
491
492 if (avctx->debug & FF_DEBUG_PICT_INFO) {
493 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
494 avctx->extradata_size >= 4 ? ((int *) avctx->extradata)[0] : -1);
495 }
496
497 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
498
499 if ((ret = ff_MPV_common_init(s)) < 0)
500 return ret;
501
502 ff_h263dsp_init(&s->h263dsp);
503 ff_h263_decode_init_vlc();
504
505 /* init rv vlc */
506 if (!done) {
507 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
508 rv_lum_bits, 1, 1,
509 rv_lum_code, 2, 2, 16384);
510 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
511 rv_chrom_bits, 1, 1,
512 rv_chrom_code, 2, 2, 16388);
513 done = 1;
514 }
515
516 return 0;
517 }
518
519 static av_cold int rv10_decode_end(AVCodecContext *avctx)
520 {
521 MpegEncContext *s = avctx->priv_data;
522
523 ff_MPV_common_end(s);
524 return 0;
525 }
526
527 static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
528 int buf_size, int buf_size2)
529 {
530 RVDecContext *rv = avctx->priv_data;
531 MpegEncContext *s = &rv->m;
532 int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
533
534 active_bits_size = buf_size * 8;
535 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
536 if (s->codec_id == AV_CODEC_ID_RV10)
537 mb_count = rv10_decode_picture_header(s);
538 else
539 mb_count = rv20_decode_picture_header(rv);
540 if (mb_count < 0) {
541 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
542 return AVERROR_INVALIDDATA;
543 }
544
545 if (s->mb_x >= s->mb_width ||
546 s->mb_y >= s->mb_height) {
547 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
548 return AVERROR_INVALIDDATA;
549 }
550 mb_pos = s->mb_y * s->mb_width + s->mb_x;
551 left = s->mb_width * s->mb_height - mb_pos;
552 if (mb_count > left) {
553 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
554 return AVERROR_INVALIDDATA;
555 }
556
557 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
558 // FIXME write parser so we always have complete frames?
559 if (s->current_picture_ptr) {
560 ff_er_frame_end(&s->er);
561 ff_MPV_frame_end(s);
562 s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
563 }
564 if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
565 return ret;
566 ff_mpeg_er_frame_start(s);
567 } else {
568 if (s->current_picture_ptr->f.pict_type != s->pict_type) {
569 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
570 return AVERROR_INVALIDDATA;
571 }
572 }
573
574 av_dlog(avctx, "qscale=%d\n", s->qscale);
575
576 /* default quantization values */
577 if (s->codec_id == AV_CODEC_ID_RV10) {
578 if (s->mb_y == 0)
579 s->first_slice_line = 1;
580 } else {
581 s->first_slice_line = 1;
582 s->resync_mb_x = s->mb_x;
583 }
584 start_mb_x = s->mb_x;
585 s->resync_mb_y = s->mb_y;
586 if (s->h263_aic) {
587 s->y_dc_scale_table =
588 s->c_dc_scale_table = ff_aic_dc_scale_table;
589 } else {
590 s->y_dc_scale_table =
591 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
592 }
593
594 if (s->modified_quant)
595 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
596
597 ff_set_qscale(s, s->qscale);
598
599 s->rv10_first_dc_coded[0] = 0;
600 s->rv10_first_dc_coded[1] = 0;
601 s->rv10_first_dc_coded[2] = 0;
602 s->block_wrap[0] =
603 s->block_wrap[1] =
604 s->block_wrap[2] =
605 s->block_wrap[3] = s->b8_stride;
606 s->block_wrap[4] =
607 s->block_wrap[5] = s->mb_stride;
608 ff_init_block_index(s);
609
610 /* decode each macroblock */
611 for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
612 int ret;
613 ff_update_block_index(s);
614 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
615
616 s->mv_dir = MV_DIR_FORWARD;
617 s->mv_type = MV_TYPE_16X16;
618 ret = ff_h263_decode_mb(s, s->block);
619
620 // Repeat the slice end check from ff_h263_decode_mb with our active
621 // bitstream size
622 if (ret != SLICE_ERROR) {
623 int v = show_bits(&s->gb, 16);
624
625 if (get_bits_count(&s->gb) + 16 > active_bits_size)
626 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
627
628 if (!v)
629 ret = SLICE_END;
630 }
631 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
632 8 * buf_size2 >= get_bits_count(&s->gb)) {
633 active_bits_size = buf_size2 * 8;
634 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
635 8 * buf_size, active_bits_size);
636 ret = SLICE_OK;
637 }
638
639 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
640 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
641 s->mb_y);
642 return AVERROR_INVALIDDATA;
643 }
644 if (s->pict_type != AV_PICTURE_TYPE_B)
645 ff_h263_update_motion_val(s);
646 ff_MPV_decode_mb(s, s->block);
647 if (s->loop_filter)
648 ff_h263_loop_filter(s);
649
650 if (++s->mb_x == s->mb_width) {
651 s->mb_x = 0;
652 s->mb_y++;
653 ff_init_block_index(s);
654 }
655 if (s->mb_x == s->resync_mb_x)
656 s->first_slice_line = 0;
657 if (ret == SLICE_END)
658 break;
659 }
660
661 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
662 ER_MB_END);
663
664 return active_bits_size;
665 }
666
667 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
668 {
669 if (avctx->slice_count)
670 return avctx->slice_offset[n];
671 else
672 return AV_RL32(buf + n * 8);
673 }
674
675 static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
676 AVPacket *avpkt)
677 {
678 const uint8_t *buf = avpkt->data;
679 int buf_size = avpkt->size;
680 MpegEncContext *s = avctx->priv_data;
681 AVFrame *pict = data;
682 int i, ret;
683 int slice_count;
684 const uint8_t *slices_hdr = NULL;
685
686 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
687
688 /* no supplementary picture */
689 if (buf_size == 0) {
690 return 0;
691 }
692
693 if (!avctx->slice_count) {
694 slice_count = (*buf++) + 1;
695 buf_size--;
696
697 if (!slice_count || buf_size <= 8 * slice_count) {
698 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",
699 slice_count);
700 return AVERROR_INVALIDDATA;
701 }
702
703 slices_hdr = buf + 4;
704 buf += 8 * slice_count;
705 buf_size -= 8 * slice_count;
706 } else
707 slice_count = avctx->slice_count;
708
709 for (i = 0; i < slice_count; i++) {
710 unsigned offset = get_slice_offset(avctx, slices_hdr, i);
711 int size, size2;
712
713 if (offset >= buf_size)
714 return AVERROR_INVALIDDATA;
715
716 if (i + 1 == slice_count)
717 size = buf_size - offset;
718 else
719 size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
720
721 if (i + 2 >= slice_count)
722 size2 = buf_size - offset;
723 else
724 size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
725
726 if (size <= 0 || size2 <= 0 ||
727 offset + FFMAX(size, size2) > buf_size)
728 return AVERROR_INVALIDDATA;
729
730 if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2)) < 0)
731 return ret;
732
733 if (ret > 8 * size)
734 i++;
735 }
736
737 if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
738 ff_er_frame_end(&s->er);
739 ff_MPV_frame_end(s);
740
741 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
742 if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
743 return ret;
744 ff_print_debug_info(s, s->current_picture_ptr);
745 } else if (s->last_picture_ptr != NULL) {
746 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
747 return ret;
748 ff_print_debug_info(s, s->last_picture_ptr);
749 }
750
751 if (s->last_picture_ptr || s->low_delay) {
752 *got_frame = 1;
753 }
754
755 // so we can detect if frame_end was not called (find some nicer solution...)
756 s->current_picture_ptr = NULL;
757 }
758
759 return avpkt->size;
760 }
761
762 AVCodec ff_rv10_decoder = {
763 .name = "rv10",
764 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
765 .type = AVMEDIA_TYPE_VIDEO,
766 .id = AV_CODEC_ID_RV10,
767 .priv_data_size = sizeof(RVDecContext),
768 .init = rv10_decode_init,
769 .close = rv10_decode_end,
770 .decode = rv10_decode_frame,
771 .capabilities = CODEC_CAP_DR1,
772 .pix_fmts = (const enum AVPixelFormat[]) {
773 AV_PIX_FMT_YUV420P,
774 AV_PIX_FMT_NONE
775 },
776 };
777
778 AVCodec ff_rv20_decoder = {
779 .name = "rv20",
780 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
781 .type = AVMEDIA_TYPE_VIDEO,
782 .id = AV_CODEC_ID_RV20,
783 .priv_data_size = sizeof(RVDecContext),
784 .init = rv10_decode_init,
785 .close = rv10_decode_end,
786 .decode = rv10_decode_frame,
787 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
788 .flush = ff_mpeg_flush,
789 .pix_fmts = (const enum AVPixelFormat[]) {
790 AV_PIX_FMT_YUV420P,
791 AV_PIX_FMT_NONE
792 },
793 };