3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer
6 * This file is part of FFmpeg.
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.
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.
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
28 #include "libavutil/imgutils.h"
30 #include "error_resilience.h"
32 #include "mpegvideo.h"
33 #include "mpeg4video.h"
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)
40 #define DC_VLC_BITS 14 //FIXME find a better solution
42 typedef struct RVDecContext {
47 static const uint16_t rv_lum_code[256] = {
48 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
49 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
50 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
51 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
52 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
53 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
54 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
55 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
56 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
57 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
58 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
59 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
60 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
61 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
62 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
63 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
64 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
65 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
66 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
67 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
68 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
69 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
70 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
71 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
72 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
73 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
74 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
75 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
76 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
77 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
78 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
79 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
82 static const uint8_t rv_lum_bits[256] = {
83 14, 12, 12, 12, 12, 12, 12, 12,
84 12, 12, 12, 12, 12, 12, 12, 12,
85 12, 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, 10, 10, 10, 10, 10, 10, 10,
92 10, 10, 10, 10, 10, 10, 10, 10,
93 10, 10, 10, 10, 10, 10, 10, 10,
94 10, 10, 10, 10, 10, 10, 10, 10,
95 10, 8, 8, 8, 8, 8, 8, 8,
96 8, 8, 8, 8, 8, 8, 8, 8,
97 8, 7, 7, 7, 7, 7, 7, 7,
98 7, 6, 6, 6, 6, 5, 5, 4,
99 2, 4, 5, 5, 6, 6, 6, 6,
100 7, 7, 7, 7, 7, 7, 7, 7,
101 8, 8, 8, 8, 8, 8, 8, 8,
102 8, 8, 8, 8, 8, 8, 8, 8,
103 10, 10, 10, 10, 10, 10, 10, 10,
104 10, 10, 10, 10, 10, 10, 10, 10,
105 10, 10, 10, 10, 10, 10, 10, 10,
106 10, 10, 10, 10, 10, 10, 10, 10,
107 12, 12, 12, 12, 12, 12, 12, 12,
108 12, 12, 12, 12, 12, 12, 12, 12,
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,
117 static const uint16_t rv_chrom_code[256] = {
118 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
119 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
120 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
121 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
122 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
123 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
124 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
125 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
126 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
127 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
128 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
129 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
130 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
131 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
132 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
133 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
134 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
135 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
136 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
137 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
138 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
139 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
140 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
141 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
142 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
143 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
144 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
145 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
146 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
147 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
148 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
149 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
152 static const uint8_t rv_chrom_bits[256] = {
153 16, 14, 14, 14, 14, 14, 14, 14,
154 14, 14, 14, 14, 14, 14, 14, 14,
155 14, 14, 14, 14, 14, 14, 14, 14,
156 14, 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, 12, 12, 12, 12, 12, 12, 12,
162 12, 12, 12, 12, 12, 12, 12, 12,
163 12, 12, 12, 12, 12, 12, 12, 12,
164 12, 12, 12, 12, 12, 12, 12, 12,
165 12, 10, 10, 10, 10, 10, 10, 10,
166 10, 10, 10, 10, 10, 10, 10, 10,
167 10, 8, 8, 8, 8, 8, 8, 8,
168 8, 6, 6, 6, 6, 4, 4, 3,
169 2, 3, 4, 4, 6, 6, 6, 6,
170 8, 8, 8, 8, 8, 8, 8, 8,
171 10, 10, 10, 10, 10, 10, 10, 10,
172 10, 10, 10, 10, 10, 10, 10, 10,
173 12, 12, 12, 12, 12, 12, 12, 12,
174 12, 12, 12, 12, 12, 12, 12, 12,
175 12, 12, 12, 12, 12, 12, 12, 12,
176 12, 12, 12, 12, 12, 12, 12, 12,
177 14, 14, 14, 14, 14, 14, 14, 14,
178 14, 14, 14, 14, 14, 14, 14, 14,
179 14, 14, 14, 14, 14, 14, 14, 14,
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,
187 static VLC rv_dc_lum, rv_dc_chrom;
189 int ff_rv_decode_dc(MpegEncContext *s, int n)
194 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
196 /* XXX: I don't understand why they use LONGER codes than
197 necessary. The following code would be completely useless
198 if they had thought about it !!! */
199 code = get_bits(&s->gb, 7);
201 code = (int8_t)(get_bits(&s->gb, 7) + 1);
202 } else if (code == 0x7d) {
203 code = -128 + get_bits(&s->gb, 7);
204 } else if (code == 0x7e) {
205 if (get_bits1(&s->gb) == 0)
206 code = (int8_t)(get_bits(&s->gb, 8) + 1);
208 code = (int8_t)(get_bits(&s->gb, 8));
209 } else if (code == 0x7f) {
210 skip_bits(&s->gb, 11);
217 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
220 code = get_bits(&s->gb, 9);
222 code = (int8_t)(get_bits(&s->gb, 7) + 1);
223 } else if (code == 0x1fd) {
224 code = -128 + get_bits(&s->gb, 7);
225 } else if (code == 0x1fe) {
226 skip_bits(&s->gb, 9);
229 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
239 /* read RV 1.0 compatible frame header */
240 static int rv10_decode_picture_header(MpegEncContext *s)
242 int mb_count, pb_frame, marker, mb_xy;
244 marker = get_bits1(&s->gb);
246 if (get_bits1(&s->gb))
247 s->pict_type = AV_PICTURE_TYPE_P;
249 s->pict_type = AV_PICTURE_TYPE_I;
252 av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
254 pb_frame = get_bits1(&s->gb);
256 av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
259 avpriv_request_sample(s->avctx, "pb frame");
260 return AVERROR_PATCHWELCOME;
263 s->qscale = get_bits(&s->gb, 5);
264 if (s->qscale == 0) {
265 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
266 return AVERROR_INVALIDDATA;
269 if (s->pict_type == AV_PICTURE_TYPE_I) {
270 if (s->rv10_version == 3) {
271 /* specific MPEG like DC coding not used */
272 s->last_dc[0] = get_bits(&s->gb, 8);
273 s->last_dc[1] = get_bits(&s->gb, 8);
274 s->last_dc[2] = get_bits(&s->gb, 8);
275 av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
276 s->last_dc[1], s->last_dc[2]);
279 /* if multiple packets per frame are sent, the position at which
280 to display the macroblocks is coded here */
282 mb_xy = s->mb_x + s->mb_y * s->mb_width;
283 if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
284 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
285 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
286 mb_count = get_bits(&s->gb, 12);
290 mb_count = s->mb_width * s->mb_height;
292 skip_bits(&s->gb, 3); /* ignored */
294 s->unrestricted_mv = 1;
299 static int rv20_decode_picture_header(RVDecContext *rv)
301 MpegEncContext *s = &rv->m;
302 int seq, mb_pos, i, ret;
305 i = get_bits(&s->gb, 2);
307 case 0: s->pict_type = AV_PICTURE_TYPE_I; break;
308 case 1: s->pict_type = AV_PICTURE_TYPE_I; break; //hmm ...
309 case 2: s->pict_type = AV_PICTURE_TYPE_P; break;
310 case 3: s->pict_type = AV_PICTURE_TYPE_B; break;
312 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
313 return AVERROR_INVALIDDATA;
316 if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
317 av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
320 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
321 av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
322 return AVERROR_INVALIDDATA;
325 if (get_bits1(&s->gb)) {
326 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
327 return AVERROR_INVALIDDATA;
330 s->qscale = get_bits(&s->gb, 5);
331 if (s->qscale == 0) {
332 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
333 return AVERROR_INVALIDDATA;
336 if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
337 s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
339 if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
340 seq = get_bits(&s->gb, 8) << 7;
342 seq = get_bits(&s->gb, 13) << 2;
344 rpr_bits = s->avctx->extradata[1] & 7;
347 rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
349 f = get_bits(&s->gb, rpr_bits);
352 if (s->avctx->extradata_size < 8 + 2 * f) {
353 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
354 return AVERROR_INVALIDDATA;
357 new_w = 4 * ((uint8_t*)s->avctx->extradata)[6 + 2 * f];
358 new_h = 4 * ((uint8_t*)s->avctx->extradata)[7 + 2 * f];
360 new_w = s->orig_width ;
361 new_h = s->orig_height;
363 if (new_w != s->width || new_h != s->height) {
364 AVRational old_aspect = s->avctx->sample_aspect_ratio;
365 av_log(s->avctx, AV_LOG_DEBUG,
366 "attempting to change resolution to %dx%d\n", new_w, new_h);
367 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
368 return AVERROR_INVALIDDATA;
369 ff_MPV_common_end(s);
371 // attempt to keep aspect during typical resolution switches
373 old_aspect = (AVRational){1, 1};
374 if (2 * new_w * s->height == new_h * s->width)
375 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
376 if (new_w * s->height == 2 * new_h * s->width)
377 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
379 ret = ff_set_dimensions(s->avctx, new_w, new_h);
385 if ((ret = ff_MPV_common_init(s)) < 0)
389 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
390 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
393 if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
394 return AVERROR_INVALIDDATA;
396 mb_pos = ff_h263_decode_mba(s);
398 seq |= s->time & ~0x7FFF;
399 if (seq - s->time > 0x4000)
401 if (seq - s->time < -0x4000)
404 if (seq != s->time) {
405 if (s->pict_type != AV_PICTURE_TYPE_B) {
407 s->pp_time = s->time - s->last_non_b_time;
408 s->last_non_b_time = s->time;
411 s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
414 if (s->pict_type == AV_PICTURE_TYPE_B) {
415 if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
416 av_log(s->avctx, AV_LOG_DEBUG,
417 "messed up order, possible from seeking? skipping current b frame\n");
418 #define ERROR_SKIP_FRAME -123
419 return ERROR_SKIP_FRAME;
421 ff_mpeg4_init_direct_mv(s);
424 s->no_rounding = get_bits1(&s->gb);
426 if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
427 skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
430 s->unrestricted_mv = 1;
431 s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;
432 s->modified_quant = 1;
433 if (!s->avctx->lowres)
436 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
437 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
438 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
441 av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
443 return s->mb_width*s->mb_height - mb_pos;
446 static av_cold int rv10_decode_init(AVCodecContext *avctx)
448 RVDecContext *rv = avctx->priv_data;
449 MpegEncContext *s = &rv->m;
451 int major_ver, minor_ver, micro_ver, ret;
453 if (avctx->extradata_size < 8) {
454 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
455 return AVERROR_INVALIDDATA;
457 if ((ret = av_image_check_size(avctx->coded_width,
458 avctx->coded_height, 0, avctx)) < 0)
461 ff_MPV_decode_defaults(s);
464 s->out_format = FMT_H263;
465 s->codec_id = avctx->codec_id;
467 s->orig_width = s->width = avctx->coded_width;
468 s->orig_height = s->height = avctx->coded_height;
470 s->h263_long_vectors = ((uint8_t*)avctx->extradata)[3] & 1;
471 rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
473 major_ver = RV_GET_MAJOR_VER(rv->sub_id);
474 minor_ver = RV_GET_MINOR_VER(rv->sub_id);
475 micro_ver = RV_GET_MICRO_VER(rv->sub_id);
480 s->rv10_version = micro_ver ? 3 : 1;
481 s->obmc = micro_ver == 2;
484 if (minor_ver >= 2) {
486 s->avctx->has_b_frames = 1;
490 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
491 avpriv_request_sample(avctx, "RV1/2 version");
492 return AVERROR_PATCHWELCOME;
495 if (avctx->debug & FF_DEBUG_PICT_INFO) {
496 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
497 ((uint32_t*)avctx->extradata)[0]);
500 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
502 if ((ret = ff_MPV_common_init(s)) < 0)
505 ff_h263dsp_init(&s->h263dsp);
506 ff_h263_decode_init_vlc();
510 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
512 rv_lum_code, 2, 2, 16384);
513 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
515 rv_chrom_code, 2, 2, 16388);
522 static av_cold int rv10_decode_end(AVCodecContext *avctx)
524 MpegEncContext *s = avctx->priv_data;
526 ff_MPV_common_end(s);
530 static int rv10_decode_packet(AVCodecContext *avctx,
531 const uint8_t *buf, int buf_size, int buf_size2)
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;
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);
542 mb_count = rv20_decode_picture_header(rv);
544 if (mb_count != ERROR_SKIP_FRAME)
545 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
546 return AVERROR_INVALIDDATA;
549 if (s->mb_x >= s->mb_width ||
550 s->mb_y >= s->mb_height) {
551 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
552 return AVERROR_INVALIDDATA;
554 mb_pos = s->mb_y * s->mb_width + s->mb_x;
555 left = s->mb_width * s->mb_height - mb_pos;
556 if (mb_count > left) {
557 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
558 return AVERROR_INVALIDDATA;
561 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
562 if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?
563 ff_er_frame_end(&s->er);
565 s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
567 if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
569 ff_mpeg_er_frame_start(s);
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;
578 av_dlog(avctx, "qscale=%d\n", s->qscale);
580 /* default quantization values */
581 if (s->codec_id == AV_CODEC_ID_RV10) {
583 s->first_slice_line = 1;
585 s->first_slice_line = 1;
586 s->resync_mb_x = s->mb_x;
588 start_mb_x = s->mb_x;
589 s->resync_mb_y = s->mb_y;
591 s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;
593 s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
596 if (s->modified_quant)
597 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
599 ff_set_qscale(s, s->qscale);
601 s->rv10_first_dc_coded[0] = 0;
602 s->rv10_first_dc_coded[1] = 0;
603 s->rv10_first_dc_coded[2] = 0;
607 s->block_wrap[3] = s->b8_stride;
609 s->block_wrap[5] = s->mb_stride;
610 ff_init_block_index(s);
612 /* decode each macroblock */
613 for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
615 ff_update_block_index(s);
616 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
618 s->mv_dir = MV_DIR_FORWARD;
619 s->mv_type = MV_TYPE_16X16;
620 ret = ff_h263_decode_mb(s, s->block);
622 // Repeat the slice end check from ff_h263_decode_mb with our active
624 if (ret != SLICE_ERROR) {
625 int v = show_bits(&s->gb, 16);
627 if (get_bits_count(&s->gb) + 16 > active_bits_size)
628 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
633 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
634 8 * buf_size2 >= get_bits_count(&s->gb)) {
635 active_bits_size = buf_size2 * 8;
636 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
637 8 * buf_size, active_bits_size);
641 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
642 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
643 return AVERROR_INVALIDDATA;
645 if (s->pict_type != AV_PICTURE_TYPE_B)
646 ff_h263_update_motion_val(s);
647 ff_MPV_decode_mb(s, s->block);
649 ff_h263_loop_filter(s);
651 if (++s->mb_x == s->mb_width) {
654 ff_init_block_index(s);
656 if (s->mb_x == s->resync_mb_x)
657 s->first_slice_line = 0;
658 if (ret == SLICE_END)
662 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,
665 return active_bits_size;
668 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
670 if (avctx->slice_count)
671 return avctx->slice_offset[n];
673 return AV_RL32(buf + n * 8);
676 static int rv10_decode_frame(AVCodecContext *avctx,
677 void *data, int *got_frame,
680 const uint8_t *buf = avpkt->data;
681 int buf_size = avpkt->size;
682 MpegEncContext *s = avctx->priv_data;
683 AVFrame *pict = data;
686 const uint8_t *slices_hdr = NULL;
688 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
689 s->flags = avctx->flags;
690 s->flags2 = avctx->flags2;
692 /* no supplementary picture */
697 if (!avctx->slice_count) {
698 slice_count = (*buf++) + 1;
701 if (!slice_count || buf_size <= 8 * slice_count) {
702 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
703 return AVERROR_INVALIDDATA;
706 slices_hdr = buf + 4;
707 buf += 8 * slice_count;
708 buf_size -= 8 * slice_count;
710 slice_count = avctx->slice_count;
712 for (i = 0; i < slice_count; i++) {
713 unsigned offset = get_slice_offset(avctx, slices_hdr, i);
716 if (offset >= buf_size)
717 return AVERROR_INVALIDDATA;
719 if (i + 1 == slice_count)
720 size = buf_size - offset;
722 size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
724 if (i + 2 >= slice_count)
725 size2 = buf_size - offset;
727 size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
729 if (size <= 0 || size2 <= 0 ||
730 offset + FFMAX(size, size2) > buf_size)
731 return AVERROR_INVALIDDATA;
733 if (rv10_decode_packet(avctx, buf + offset, size, size2) > 8 * size)
737 if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
738 ff_er_frame_end(&s->er);
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)
744 ff_print_debug_info(s, s->current_picture_ptr, pict);
745 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
746 } else if (s->last_picture_ptr != NULL) {
747 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
749 ff_print_debug_info(s, s->last_picture_ptr, pict);
750 ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
753 if (s->last_picture_ptr || s->low_delay) {
757 // so we can detect if frame_end was not called (find some nicer solution...)
758 s->current_picture_ptr = NULL;
764 AVCodec ff_rv10_decoder = {
766 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
767 .type = AVMEDIA_TYPE_VIDEO,
768 .id = AV_CODEC_ID_RV10,
769 .priv_data_size = sizeof(RVDecContext),
770 .init = rv10_decode_init,
771 .close = rv10_decode_end,
772 .decode = rv10_decode_frame,
773 .capabilities = CODEC_CAP_DR1,
775 .pix_fmts = ff_pixfmt_list_420,
778 AVCodec ff_rv20_decoder = {
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,
790 .pix_fmts = ff_pixfmt_list_420,