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"
37 #include "mpegvideo.h"
38 #include "mpeg4video.h"
40 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
41 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
42 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
44 #define DC_VLC_BITS 14 // FIXME find a better solution
46 typedef struct RVDecContext {
51 static const uint16_t rv_lum_code[256] = {
52 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
53 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
54 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
55 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
56 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
57 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
58 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
59 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
60 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
61 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
62 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
63 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
64 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
65 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
66 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
67 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
68 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
69 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
70 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
71 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
72 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
73 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
74 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
75 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
76 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
77 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
78 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
79 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
80 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
81 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
82 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
83 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
86 static const uint8_t rv_lum_bits[256] = {
87 14, 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, 12, 12, 12, 12, 12, 12, 12,
95 12, 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, 10, 10, 10, 10, 10, 10, 10,
99 10, 8, 8, 8, 8, 8, 8, 8,
100 8, 8, 8, 8, 8, 8, 8, 8,
101 8, 7, 7, 7, 7, 7, 7, 7,
102 7, 6, 6, 6, 6, 5, 5, 4,
103 2, 4, 5, 5, 6, 6, 6, 6,
104 7, 7, 7, 7, 7, 7, 7, 7,
105 8, 8, 8, 8, 8, 8, 8, 8,
106 8, 8, 8, 8, 8, 8, 8, 8,
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 10, 10, 10, 10, 10, 10, 10, 10,
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 12, 12, 12, 12, 12, 12, 12, 12,
121 static const uint16_t rv_chrom_code[256] = {
122 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
123 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
124 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
125 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
126 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
127 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
128 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
129 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
130 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
131 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
132 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
133 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
134 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
135 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
136 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
137 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
138 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
139 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
140 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
141 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
142 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
143 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
144 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
145 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
146 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
147 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
148 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
149 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
150 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
151 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
152 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
153 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
156 static const uint8_t rv_chrom_bits[256] = {
157 16, 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, 14, 14, 14, 14, 14, 14, 14,
165 14, 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, 12, 12, 12, 12, 12, 12, 12,
169 12, 10, 10, 10, 10, 10, 10, 10,
170 10, 10, 10, 10, 10, 10, 10, 10,
171 10, 8, 8, 8, 8, 8, 8, 8,
172 8, 6, 6, 6, 6, 4, 4, 3,
173 2, 3, 4, 4, 6, 6, 6, 6,
174 8, 8, 8, 8, 8, 8, 8, 8,
175 10, 10, 10, 10, 10, 10, 10, 10,
176 10, 10, 10, 10, 10, 10, 10, 10,
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 12, 12, 12, 12, 12, 12, 12, 12,
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 14, 14, 14, 14, 14, 14, 14, 14,
191 static VLC rv_dc_lum, rv_dc_chrom;
193 int ff_rv_decode_dc(MpegEncContext *s, int n)
198 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
200 /* XXX: I don't understand why they use LONGER codes than
201 * necessary. The following code would be completely useless
202 * if they had thought about it !!! */
203 code = get_bits(&s->gb, 7);
205 code = (int8_t) (get_bits(&s->gb, 7) + 1);
206 } else if (code == 0x7d) {
207 code = -128 + get_bits(&s->gb, 7);
208 } else if (code == 0x7e) {
209 if (get_bits1(&s->gb) == 0)
210 code = (int8_t) (get_bits(&s->gb, 8) + 1);
212 code = (int8_t) (get_bits(&s->gb, 8));
213 } else if (code == 0x7f) {
214 skip_bits(&s->gb, 11);
221 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
224 code = get_bits(&s->gb, 9);
226 code = (int8_t) (get_bits(&s->gb, 7) + 1);
227 } else if (code == 0x1fd) {
228 code = -128 + get_bits(&s->gb, 7);
229 } else if (code == 0x1fe) {
230 skip_bits(&s->gb, 9);
233 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
243 /* read RV 1.0 compatible frame header */
244 static int rv10_decode_picture_header(MpegEncContext *s)
246 int mb_count, pb_frame, marker, mb_xy;
248 marker = get_bits1(&s->gb);
250 if (get_bits1(&s->gb))
251 s->pict_type = AV_PICTURE_TYPE_P;
253 s->pict_type = AV_PICTURE_TYPE_I;
256 av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
258 pb_frame = get_bits1(&s->gb);
260 av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
263 avpriv_request_sample(s->avctx, "pb frame");
264 return AVERROR_PATCHWELCOME;
267 s->qscale = get_bits(&s->gb, 5);
268 if (s->qscale == 0) {
269 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
270 return AVERROR_INVALIDDATA;
273 if (s->pict_type == AV_PICTURE_TYPE_I) {
274 if (s->rv10_version == 3) {
275 /* specific MPEG like DC coding not used */
276 s->last_dc[0] = get_bits(&s->gb, 8);
277 s->last_dc[1] = get_bits(&s->gb, 8);
278 s->last_dc[2] = get_bits(&s->gb, 8);
279 av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
280 s->last_dc[1], s->last_dc[2]);
283 /* if multiple packets per frame are sent, the position at which
284 * to display the macroblocks is coded here */
286 mb_xy = s->mb_x + s->mb_y * s->mb_width;
287 if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
288 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
289 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
290 mb_count = get_bits(&s->gb, 12);
294 mb_count = s->mb_width * s->mb_height;
296 skip_bits(&s->gb, 3); /* ignored */
298 s->unrestricted_mv = 1;
303 static int rv20_decode_picture_header(RVDecContext *rv)
305 MpegEncContext *s = &rv->m;
306 int seq, mb_pos, i, ret;
309 i = get_bits(&s->gb, 2);
312 s->pict_type = AV_PICTURE_TYPE_I;
315 s->pict_type = AV_PICTURE_TYPE_I;
318 s->pict_type = AV_PICTURE_TYPE_P;
321 s->pict_type = AV_PICTURE_TYPE_B;
324 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
325 return AVERROR_INVALIDDATA;
328 if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
329 av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
332 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
333 av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
334 return AVERROR_INVALIDDATA;
337 if (get_bits1(&s->gb)) {
338 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
339 return AVERROR_INVALIDDATA;
342 s->qscale = get_bits(&s->gb, 5);
343 if (s->qscale == 0) {
344 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
345 return AVERROR_INVALIDDATA;
348 if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
349 s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
351 if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
352 seq = get_bits(&s->gb, 8) << 7;
354 seq = get_bits(&s->gb, 13) << 2;
356 rpr_max = s->avctx->extradata[1] & 7;
359 int rpr_bits = av_log2(rpr_max) + 1;
361 f = get_bits(&s->gb, rpr_bits);
364 if (s->avctx->extradata_size < 8 + 2 * f) {
365 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
366 return AVERROR_INVALIDDATA;
369 new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];
370 new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];
372 new_w = s->orig_width;
373 new_h = s->orig_height;
375 if (new_w != s->width || new_h != s->height) {
376 AVRational old_aspect = s->avctx->sample_aspect_ratio;
377 av_log(s->avctx, AV_LOG_DEBUG,
378 "attempting to change resolution to %dx%d\n", new_w, new_h);
379 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
380 return AVERROR_INVALIDDATA;
381 ff_MPV_common_end(s);
383 // attempt to keep aspect during typical resolution switches
385 old_aspect = (AVRational){1, 1};
386 if (2 * new_w * s->height == new_h * s->width)
387 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
388 if (new_w * s->height == 2 * new_h * s->width)
389 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
391 ret = ff_set_dimensions(s->avctx, new_w, new_h);
397 if ((ret = ff_MPV_common_init(s)) < 0)
401 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
402 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max);
405 if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
406 return AVERROR_INVALIDDATA;
408 mb_pos = ff_h263_decode_mba(s);
410 seq |= s->time & ~0x7FFF;
411 if (seq - s->time > 0x4000)
413 if (seq - s->time < -0x4000)
416 if (seq != s->time) {
417 if (s->pict_type != AV_PICTURE_TYPE_B) {
419 s->pp_time = s->time - s->last_non_b_time;
420 s->last_non_b_time = s->time;
423 s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
426 if (s->pict_type == AV_PICTURE_TYPE_B) {
427 if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
428 av_log(s->avctx, AV_LOG_DEBUG,
429 "messed up order, possible from seeking? skipping current b frame\n");
430 #define ERROR_SKIP_FRAME -123
431 return ERROR_SKIP_FRAME;
433 ff_mpeg4_init_direct_mv(s);
436 s->no_rounding = get_bits1(&s->gb);
438 if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
439 // binary decoder reads 3+2 bits here but they don't seem to be used
440 skip_bits(&s->gb, 5);
443 s->unrestricted_mv = 1;
444 s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;
445 s->modified_quant = 1;
446 if (!s->avctx->lowres)
449 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
450 av_log(s->avctx, AV_LOG_INFO,
451 "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
452 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,
456 av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
458 return s->mb_width * s->mb_height - mb_pos;
461 static av_cold int rv10_decode_init(AVCodecContext *avctx)
463 RVDecContext *rv = avctx->priv_data;
464 MpegEncContext *s = &rv->m;
466 int major_ver, minor_ver, micro_ver, ret;
468 if (avctx->extradata_size < 8) {
469 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
470 return AVERROR_INVALIDDATA;
472 if ((ret = av_image_check_size(avctx->coded_width,
473 avctx->coded_height, 0, avctx)) < 0)
476 ff_MPV_decode_defaults(s);
479 s->out_format = FMT_H263;
480 s->codec_id = avctx->codec_id;
483 s->width = avctx->coded_width;
485 s->height = avctx->coded_height;
487 s->h263_long_vectors = ((uint8_t *) avctx->extradata)[3] & 1;
488 rv->sub_id = AV_RB32((uint8_t *) avctx->extradata + 4);
490 major_ver = RV_GET_MAJOR_VER(rv->sub_id);
491 minor_ver = RV_GET_MINOR_VER(rv->sub_id);
492 micro_ver = RV_GET_MICRO_VER(rv->sub_id);
497 s->rv10_version = micro_ver ? 3 : 1;
498 s->obmc = micro_ver == 2;
501 if (minor_ver >= 2) {
503 s->avctx->has_b_frames = 1;
507 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
508 avpriv_request_sample(avctx, "RV1/2 version");
509 return AVERROR_PATCHWELCOME;
512 if (avctx->debug & FF_DEBUG_PICT_INFO) {
513 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%"PRIX32"\n", rv->sub_id,
514 ((uint32_t *) avctx->extradata)[0]);
517 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
519 if ((ret = ff_MPV_common_init(s)) < 0)
522 ff_h263dsp_init(&s->h263dsp);
523 ff_h263_decode_init_vlc();
527 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
529 rv_lum_code, 2, 2, 16384);
530 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
532 rv_chrom_code, 2, 2, 16388);
539 static av_cold int rv10_decode_end(AVCodecContext *avctx)
541 MpegEncContext *s = avctx->priv_data;
543 ff_MPV_common_end(s);
547 static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
548 int buf_size, int buf_size2)
550 RVDecContext *rv = avctx->priv_data;
551 MpegEncContext *s = &rv->m;
552 int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
554 active_bits_size = buf_size * 8;
555 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
556 if (s->codec_id == AV_CODEC_ID_RV10)
557 mb_count = rv10_decode_picture_header(s);
559 mb_count = rv20_decode_picture_header(rv);
561 if (mb_count != ERROR_SKIP_FRAME)
562 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
563 return AVERROR_INVALIDDATA;
566 if (s->mb_x >= s->mb_width ||
567 s->mb_y >= s->mb_height) {
568 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
569 return AVERROR_INVALIDDATA;
571 mb_pos = s->mb_y * s->mb_width + s->mb_x;
572 left = s->mb_width * s->mb_height - mb_pos;
573 if (mb_count > left) {
574 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
575 return AVERROR_INVALIDDATA;
578 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
579 // FIXME write parser so we always have complete frames?
580 if (s->current_picture_ptr) {
581 ff_er_frame_end(&s->er);
583 s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
585 if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
587 ff_mpeg_er_frame_start(s);
589 if (s->current_picture_ptr->f->pict_type != s->pict_type) {
590 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
591 return AVERROR_INVALIDDATA;
596 av_dlog(avctx, "qscale=%d\n", s->qscale);
598 /* default quantization values */
599 if (s->codec_id == AV_CODEC_ID_RV10) {
601 s->first_slice_line = 1;
603 s->first_slice_line = 1;
604 s->resync_mb_x = s->mb_x;
606 start_mb_x = s->mb_x;
607 s->resync_mb_y = s->mb_y;
609 s->y_dc_scale_table =
610 s->c_dc_scale_table = ff_aic_dc_scale_table;
612 s->y_dc_scale_table =
613 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
616 if (s->modified_quant)
617 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
619 ff_set_qscale(s, s->qscale);
621 s->rv10_first_dc_coded[0] = 0;
622 s->rv10_first_dc_coded[1] = 0;
623 s->rv10_first_dc_coded[2] = 0;
627 s->block_wrap[3] = s->b8_stride;
629 s->block_wrap[5] = s->mb_stride;
630 ff_init_block_index(s);
632 /* decode each macroblock */
633 for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
635 ff_update_block_index(s);
636 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
638 s->mv_dir = MV_DIR_FORWARD;
639 s->mv_type = MV_TYPE_16X16;
640 ret = ff_h263_decode_mb(s, s->block);
642 // Repeat the slice end check from ff_h263_decode_mb with our active
644 if (ret != SLICE_ERROR) {
645 int v = show_bits(&s->gb, 16);
647 if (get_bits_count(&s->gb) + 16 > active_bits_size)
648 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
653 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
654 8 * buf_size2 >= get_bits_count(&s->gb)) {
655 active_bits_size = buf_size2 * 8;
656 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
657 8 * buf_size, active_bits_size);
661 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
662 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
664 return AVERROR_INVALIDDATA;
666 if (s->pict_type != AV_PICTURE_TYPE_B)
667 ff_h263_update_motion_val(s);
668 ff_MPV_decode_mb(s, s->block);
670 ff_h263_loop_filter(s);
672 if (++s->mb_x == s->mb_width) {
675 ff_init_block_index(s);
677 if (s->mb_x == s->resync_mb_x)
678 s->first_slice_line = 0;
679 if (ret == SLICE_END)
683 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
686 return active_bits_size;
689 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
691 if (avctx->slice_count)
692 return avctx->slice_offset[n];
694 return AV_RL32(buf + n * 8);
697 static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
700 const uint8_t *buf = avpkt->data;
701 int buf_size = avpkt->size;
702 MpegEncContext *s = avctx->priv_data;
703 AVFrame *pict = data;
706 const uint8_t *slices_hdr = NULL;
708 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
709 s->flags = avctx->flags;
710 s->flags2 = avctx->flags2;
712 /* no supplementary picture */
717 if (!avctx->slice_count) {
718 slice_count = (*buf++) + 1;
721 if (!slice_count || buf_size <= 8 * slice_count) {
722 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",
724 return AVERROR_INVALIDDATA;
727 slices_hdr = buf + 4;
728 buf += 8 * slice_count;
729 buf_size -= 8 * slice_count;
731 slice_count = avctx->slice_count;
733 for (i = 0; i < slice_count; i++) {
734 unsigned offset = get_slice_offset(avctx, slices_hdr, i);
737 if (offset >= buf_size)
738 return AVERROR_INVALIDDATA;
740 if (i + 1 == slice_count)
741 size = buf_size - offset;
743 size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
745 if (i + 2 >= slice_count)
746 size2 = buf_size - offset;
748 size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
750 if (size <= 0 || size2 <= 0 ||
751 offset + FFMAX(size, size2) > buf_size)
752 return AVERROR_INVALIDDATA;
754 if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2)) < 0)
761 if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
762 ff_er_frame_end(&s->er);
765 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
766 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
768 ff_print_debug_info(s, s->current_picture_ptr, pict);
769 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
770 } else if (s->last_picture_ptr != NULL) {
771 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
773 ff_print_debug_info(s, s->last_picture_ptr, pict);
774 ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
777 if (s->last_picture_ptr || s->low_delay) {
781 // so we can detect if frame_end was not called (find some nicer solution...)
782 s->current_picture_ptr = NULL;
788 AVCodec ff_rv10_decoder = {
790 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
791 .type = AVMEDIA_TYPE_VIDEO,
792 .id = AV_CODEC_ID_RV10,
793 .priv_data_size = sizeof(RVDecContext),
794 .init = rv10_decode_init,
795 .close = rv10_decode_end,
796 .decode = rv10_decode_frame,
797 .capabilities = CODEC_CAP_DR1,
799 .pix_fmts = (const enum AVPixelFormat[]) {
805 AVCodec ff_rv20_decoder = {
807 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
808 .type = AVMEDIA_TYPE_VIDEO,
809 .id = AV_CODEC_ID_RV20,
810 .priv_data_size = sizeof(RVDecContext),
811 .init = rv10_decode_init,
812 .close = rv10_decode_end,
813 .decode = rv10_decode_frame,
814 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
815 .flush = ff_mpeg_flush,
817 .pix_fmts = (const enum AVPixelFormat[]) {