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