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
30 #include "libavutil/imgutils.h"
33 #include "error_resilience.h"
36 #include "mpegvideo.h"
37 #include "mpeg4video.h"
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)
43 #define DC_VLC_BITS 14 // FIXME find a better solution
45 typedef struct RVDecContext {
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,
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,
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,
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,
190 static VLC rv_dc_lum, rv_dc_chrom;
192 int ff_rv_decode_dc(MpegEncContext *s, int n)
197 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
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);
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);
211 code = (int8_t) (get_bits(&s->gb, 8));
212 } else if (code == 0x7f) {
213 skip_bits(&s->gb, 11);
220 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
223 code = get_bits(&s->gb, 9);
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);
232 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
242 /* read RV 1.0 compatible frame header */
243 static int rv10_decode_picture_header(MpegEncContext *s)
245 int mb_count, pb_frame, marker, mb_xy;
247 marker = get_bits1(&s->gb);
249 if (get_bits1(&s->gb))
250 s->pict_type = AV_PICTURE_TYPE_P;
252 s->pict_type = AV_PICTURE_TYPE_I;
255 av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
257 pb_frame = get_bits1(&s->gb);
259 av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
262 avpriv_request_sample(s->avctx, "pb frame");
263 return AVERROR_PATCHWELCOME;
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;
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]);
282 /* if multiple packets per frame are sent, the position at which
283 * to display the macroblocks is coded here */
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);
293 mb_count = s->mb_width * s->mb_height;
295 skip_bits(&s->gb, 3); /* ignored */
297 s->unrestricted_mv = 1;
302 static int rv20_decode_picture_header(RVDecContext *rv)
304 MpegEncContext *s = &rv->m;
305 int seq, mb_pos, i, ret;
308 i = get_bits(&s->gb, 2);
311 s->pict_type = AV_PICTURE_TYPE_I;
314 s->pict_type = AV_PICTURE_TYPE_I;
317 s->pict_type = AV_PICTURE_TYPE_P;
320 s->pict_type = AV_PICTURE_TYPE_B;
323 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
324 return AVERROR_INVALIDDATA;
327 if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
328 av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
331 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
332 av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
333 return AVERROR_INVALIDDATA;
336 if (get_bits1(&s->gb)) {
337 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
338 return AVERROR_INVALIDDATA;
341 s->qscale = get_bits(&s->gb, 5);
342 if (s->qscale == 0) {
343 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
344 return AVERROR_INVALIDDATA;
347 if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
348 s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
350 if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
351 seq = get_bits(&s->gb, 8) << 7;
353 seq = get_bits(&s->gb, 13) << 2;
355 rpr_max = s->avctx->extradata[1] & 7;
358 int rpr_bits = av_log2(rpr_max) + 1;
360 f = get_bits(&s->gb, rpr_bits);
363 if (s->avctx->extradata_size < 8 + 2 * f) {
364 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
365 return AVERROR_INVALIDDATA;
368 new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];
369 new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];
371 new_w = s->orig_width;
372 new_h = s->orig_height;
374 if (new_w != s->width || new_h != s->height) {
375 AVRational old_aspect = s->avctx->sample_aspect_ratio;
376 av_log(s->avctx, AV_LOG_DEBUG,
377 "attempting to change resolution to %dx%d\n", new_w, new_h);
378 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
379 return AVERROR_INVALIDDATA;
380 ff_MPV_common_end(s);
382 // attempt to keep aspect during typical resolution switches
384 old_aspect = (AVRational){1, 1};
385 if (2 * new_w * s->height == new_h * s->width)
386 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
387 if (new_w * s->height == 2 * new_h * s->width)
388 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
390 ret = ff_set_dimensions(s->avctx, new_w, new_h);
396 if ((ret = ff_MPV_common_init(s)) < 0)
400 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
401 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max);
404 if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
405 return AVERROR_INVALIDDATA;
407 mb_pos = ff_h263_decode_mba(s);
409 seq |= s->time & ~0x7FFF;
410 if (seq - s->time > 0x4000)
412 if (seq - s->time < -0x4000)
415 if (seq != s->time) {
416 if (s->pict_type != AV_PICTURE_TYPE_B) {
418 s->pp_time = s->time - s->last_non_b_time;
419 s->last_non_b_time = s->time;
422 s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
425 if (s->pict_type == AV_PICTURE_TYPE_B) {
426 if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
427 av_log(s->avctx, AV_LOG_DEBUG,
428 "messed up order, possible from seeking? skipping current b frame\n");
429 #define ERROR_SKIP_FRAME -123
430 return ERROR_SKIP_FRAME;
432 ff_mpeg4_init_direct_mv(s);
435 s->no_rounding = get_bits1(&s->gb);
437 if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
438 // binary decoder reads 3+2 bits here but they don't seem to be used
439 skip_bits(&s->gb, 5);
442 s->unrestricted_mv = 1;
443 s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;
444 s->modified_quant = 1;
445 if (!s->avctx->lowres)
448 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
449 av_log(s->avctx, AV_LOG_INFO,
450 "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
451 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,
455 av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
457 return s->mb_width * s->mb_height - mb_pos;
460 static av_cold int rv10_decode_init(AVCodecContext *avctx)
462 RVDecContext *rv = avctx->priv_data;
463 MpegEncContext *s = &rv->m;
465 int major_ver, minor_ver, micro_ver, ret;
467 if (avctx->extradata_size < 8) {
468 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
469 return AVERROR_INVALIDDATA;
471 if ((ret = av_image_check_size(avctx->coded_width,
472 avctx->coded_height, 0, avctx)) < 0)
475 ff_MPV_decode_defaults(s);
478 s->out_format = FMT_H263;
479 s->codec_id = avctx->codec_id;
482 s->width = avctx->coded_width;
484 s->height = avctx->coded_height;
486 s->h263_long_vectors = ((uint8_t *) avctx->extradata)[3] & 1;
487 rv->sub_id = AV_RB32((uint8_t *) avctx->extradata + 4);
489 major_ver = RV_GET_MAJOR_VER(rv->sub_id);
490 minor_ver = RV_GET_MINOR_VER(rv->sub_id);
491 micro_ver = RV_GET_MICRO_VER(rv->sub_id);
496 s->rv10_version = micro_ver ? 3 : 1;
497 s->obmc = micro_ver == 2;
500 if (minor_ver >= 2) {
502 s->avctx->has_b_frames = 1;
506 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
507 avpriv_request_sample(avctx, "RV1/2 version");
508 return AVERROR_PATCHWELCOME;
511 if (avctx->debug & FF_DEBUG_PICT_INFO) {
512 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%"PRIX32"\n", rv->sub_id,
513 ((uint32_t *) avctx->extradata)[0]);
516 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
518 if ((ret = ff_MPV_common_init(s)) < 0)
521 ff_h263dsp_init(&s->h263dsp);
522 ff_h263_decode_init_vlc();
526 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
528 rv_lum_code, 2, 2, 16384);
529 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
531 rv_chrom_code, 2, 2, 16388);
538 static av_cold int rv10_decode_end(AVCodecContext *avctx)
540 MpegEncContext *s = avctx->priv_data;
542 ff_MPV_common_end(s);
546 static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
547 int buf_size, int buf_size2)
549 RVDecContext *rv = avctx->priv_data;
550 MpegEncContext *s = &rv->m;
551 int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
553 active_bits_size = buf_size * 8;
554 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
555 if (s->codec_id == AV_CODEC_ID_RV10)
556 mb_count = rv10_decode_picture_header(s);
558 mb_count = rv20_decode_picture_header(rv);
560 if (mb_count != ERROR_SKIP_FRAME)
561 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
562 return AVERROR_INVALIDDATA;
565 if (s->mb_x >= s->mb_width ||
566 s->mb_y >= s->mb_height) {
567 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
568 return AVERROR_INVALIDDATA;
570 mb_pos = s->mb_y * s->mb_width + s->mb_x;
571 left = s->mb_width * s->mb_height - mb_pos;
572 if (mb_count > left) {
573 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
574 return AVERROR_INVALIDDATA;
577 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
578 // FIXME write parser so we always have complete frames?
579 if (s->current_picture_ptr) {
580 ff_er_frame_end(&s->er);
582 s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
584 if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
586 ff_mpeg_er_frame_start(s);
588 if (s->current_picture_ptr->f->pict_type != s->pict_type) {
589 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
590 return AVERROR_INVALIDDATA;
595 av_dlog(avctx, "qscale=%d\n", s->qscale);
597 /* default quantization values */
598 if (s->codec_id == AV_CODEC_ID_RV10) {
600 s->first_slice_line = 1;
602 s->first_slice_line = 1;
603 s->resync_mb_x = s->mb_x;
605 start_mb_x = s->mb_x;
606 s->resync_mb_y = s->mb_y;
608 s->y_dc_scale_table =
609 s->c_dc_scale_table = ff_aic_dc_scale_table;
611 s->y_dc_scale_table =
612 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
615 if (s->modified_quant)
616 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
618 ff_set_qscale(s, s->qscale);
620 s->rv10_first_dc_coded[0] = 0;
621 s->rv10_first_dc_coded[1] = 0;
622 s->rv10_first_dc_coded[2] = 0;
626 s->block_wrap[3] = s->b8_stride;
628 s->block_wrap[5] = s->mb_stride;
629 ff_init_block_index(s);
631 /* decode each macroblock */
632 for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
634 ff_update_block_index(s);
635 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
637 s->mv_dir = MV_DIR_FORWARD;
638 s->mv_type = MV_TYPE_16X16;
639 ret = ff_h263_decode_mb(s, s->block);
641 // Repeat the slice end check from ff_h263_decode_mb with our active
643 if (ret != SLICE_ERROR) {
644 int v = show_bits(&s->gb, 16);
646 if (get_bits_count(&s->gb) + 16 > active_bits_size)
647 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
652 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
653 8 * buf_size2 >= get_bits_count(&s->gb)) {
654 active_bits_size = buf_size2 * 8;
655 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
656 8 * buf_size, active_bits_size);
660 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
661 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
663 return AVERROR_INVALIDDATA;
665 if (s->pict_type != AV_PICTURE_TYPE_B)
666 ff_h263_update_motion_val(s);
667 ff_MPV_decode_mb(s, s->block);
669 ff_h263_loop_filter(s);
671 if (++s->mb_x == s->mb_width) {
674 ff_init_block_index(s);
676 if (s->mb_x == s->resync_mb_x)
677 s->first_slice_line = 0;
678 if (ret == SLICE_END)
682 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
685 return active_bits_size;
688 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
690 if (avctx->slice_count)
691 return avctx->slice_offset[n];
693 return AV_RL32(buf + n * 8);
696 static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
699 const uint8_t *buf = avpkt->data;
700 int buf_size = avpkt->size;
701 MpegEncContext *s = avctx->priv_data;
702 AVFrame *pict = data;
705 const uint8_t *slices_hdr = NULL;
707 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
708 s->flags = avctx->flags;
709 s->flags2 = avctx->flags2;
711 /* no supplementary picture */
716 if (!avctx->slice_count) {
717 slice_count = (*buf++) + 1;
720 if (!slice_count || buf_size <= 8 * slice_count) {
721 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",
723 return AVERROR_INVALIDDATA;
726 slices_hdr = buf + 4;
727 buf += 8 * slice_count;
728 buf_size -= 8 * slice_count;
730 slice_count = avctx->slice_count;
732 for (i = 0; i < slice_count; i++) {
733 unsigned offset = get_slice_offset(avctx, slices_hdr, i);
736 if (offset >= buf_size)
737 return AVERROR_INVALIDDATA;
739 if (i + 1 == slice_count)
740 size = buf_size - offset;
742 size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
744 if (i + 2 >= slice_count)
745 size2 = buf_size - offset;
747 size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
749 if (size <= 0 || size2 <= 0 ||
750 offset + FFMAX(size, size2) > buf_size)
751 return AVERROR_INVALIDDATA;
753 if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2)) < 0)
760 if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
761 ff_er_frame_end(&s->er);
764 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
765 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
767 ff_print_debug_info(s, s->current_picture_ptr, pict);
768 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
769 } else if (s->last_picture_ptr != NULL) {
770 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
772 ff_print_debug_info(s, s->last_picture_ptr, pict);
773 ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
776 if (s->last_picture_ptr || s->low_delay) {
780 // so we can detect if frame_end was not called (find some nicer solution...)
781 s->current_picture_ptr = NULL;
787 AVCodec ff_rv10_decoder = {
789 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
790 .type = AVMEDIA_TYPE_VIDEO,
791 .id = AV_CODEC_ID_RV10,
792 .priv_data_size = sizeof(RVDecContext),
793 .init = rv10_decode_init,
794 .close = rv10_decode_end,
795 .decode = rv10_decode_frame,
796 .capabilities = CODEC_CAP_DR1,
798 .pix_fmts = (const enum AVPixelFormat[]) {
804 AVCodec ff_rv20_decoder = {
806 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
807 .type = AVMEDIA_TYPE_VIDEO,
808 .id = AV_CODEC_ID_RV20,
809 .priv_data_size = sizeof(RVDecContext),
810 .init = rv10_decode_init,
811 .close = rv10_decode_end,
812 .decode = rv10_decode_frame,
813 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
814 .flush = ff_mpeg_flush,
816 .pix_fmts = (const enum AVPixelFormat[]) {