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"
39 #include "mpegvideodata.h"
41 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
42 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
43 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
45 #define DC_VLC_BITS 14 // FIXME find a better solution
47 typedef struct RVDecContext {
50 int orig_width, orig_height;
53 static const uint16_t rv_lum_code[256] = {
54 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
55 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
56 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
57 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
58 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
59 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
60 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
61 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
62 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
63 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
64 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
65 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
66 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
67 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
68 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
69 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
70 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
71 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
72 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
73 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
74 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
75 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
76 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
77 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
78 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
79 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
80 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
81 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
82 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
83 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
84 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
85 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
88 static const uint8_t rv_lum_bits[256] = {
89 14, 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, 12, 12, 12, 12, 12, 12, 12,
96 12, 12, 12, 12, 12, 12, 12, 12,
97 12, 10, 10, 10, 10, 10, 10, 10,
98 10, 10, 10, 10, 10, 10, 10, 10,
99 10, 10, 10, 10, 10, 10, 10, 10,
100 10, 10, 10, 10, 10, 10, 10, 10,
101 10, 8, 8, 8, 8, 8, 8, 8,
102 8, 8, 8, 8, 8, 8, 8, 8,
103 8, 7, 7, 7, 7, 7, 7, 7,
104 7, 6, 6, 6, 6, 5, 5, 4,
105 2, 4, 5, 5, 6, 6, 6, 6,
106 7, 7, 7, 7, 7, 7, 7, 7,
107 8, 8, 8, 8, 8, 8, 8, 8,
108 8, 8, 8, 8, 8, 8, 8, 8,
109 10, 10, 10, 10, 10, 10, 10, 10,
110 10, 10, 10, 10, 10, 10, 10, 10,
111 10, 10, 10, 10, 10, 10, 10, 10,
112 10, 10, 10, 10, 10, 10, 10, 10,
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,
119 12, 12, 12, 12, 12, 12, 12, 12,
120 12, 12, 12, 12, 12, 12, 12, 12,
123 static const uint16_t rv_chrom_code[256] = {
124 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
125 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
126 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
127 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
128 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
129 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
130 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
131 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
132 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
133 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
134 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
135 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
136 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
137 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
138 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
139 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
140 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
141 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
142 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
143 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
144 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
145 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
146 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
147 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
148 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
149 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
150 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
151 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
152 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
153 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
154 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
155 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
158 static const uint8_t rv_chrom_bits[256] = {
159 16, 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, 14, 14, 14, 14, 14, 14, 14,
166 14, 14, 14, 14, 14, 14, 14, 14,
167 14, 12, 12, 12, 12, 12, 12, 12,
168 12, 12, 12, 12, 12, 12, 12, 12,
169 12, 12, 12, 12, 12, 12, 12, 12,
170 12, 12, 12, 12, 12, 12, 12, 12,
171 12, 10, 10, 10, 10, 10, 10, 10,
172 10, 10, 10, 10, 10, 10, 10, 10,
173 10, 8, 8, 8, 8, 8, 8, 8,
174 8, 6, 6, 6, 6, 4, 4, 3,
175 2, 3, 4, 4, 6, 6, 6, 6,
176 8, 8, 8, 8, 8, 8, 8, 8,
177 10, 10, 10, 10, 10, 10, 10, 10,
178 10, 10, 10, 10, 10, 10, 10, 10,
179 12, 12, 12, 12, 12, 12, 12, 12,
180 12, 12, 12, 12, 12, 12, 12, 12,
181 12, 12, 12, 12, 12, 12, 12, 12,
182 12, 12, 12, 12, 12, 12, 12, 12,
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,
189 14, 14, 14, 14, 14, 14, 14, 14,
190 14, 14, 14, 14, 14, 14, 14, 14,
193 static VLC rv_dc_lum, rv_dc_chrom;
195 int ff_rv_decode_dc(MpegEncContext *s, int n)
200 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
202 /* XXX: I don't understand why they use LONGER codes than
203 * necessary. The following code would be completely useless
204 * if they had thought about it !!! */
205 code = get_bits(&s->gb, 7);
207 code = (int8_t) (get_bits(&s->gb, 7) + 1);
208 } else if (code == 0x7d) {
209 code = -128 + get_bits(&s->gb, 7);
210 } else if (code == 0x7e) {
211 if (get_bits1(&s->gb) == 0)
212 code = (int8_t) (get_bits(&s->gb, 8) + 1);
214 code = (int8_t) (get_bits(&s->gb, 8));
215 } else if (code == 0x7f) {
216 skip_bits(&s->gb, 11);
223 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
226 code = get_bits(&s->gb, 9);
228 code = (int8_t) (get_bits(&s->gb, 7) + 1);
229 } else if (code == 0x1fd) {
230 code = -128 + get_bits(&s->gb, 7);
231 } else if (code == 0x1fe) {
232 skip_bits(&s->gb, 9);
235 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
245 /* read RV 1.0 compatible frame header */
246 static int rv10_decode_picture_header(MpegEncContext *s)
248 int mb_count, pb_frame, marker, mb_xy;
250 marker = get_bits1(&s->gb);
252 if (get_bits1(&s->gb))
253 s->pict_type = AV_PICTURE_TYPE_P;
255 s->pict_type = AV_PICTURE_TYPE_I;
258 av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
260 pb_frame = get_bits1(&s->gb);
262 ff_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
265 avpriv_request_sample(s->avctx, "pb frame");
266 return AVERROR_PATCHWELCOME;
269 s->qscale = get_bits(&s->gb, 5);
270 if (s->qscale == 0) {
271 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
272 return AVERROR_INVALIDDATA;
275 if (s->pict_type == AV_PICTURE_TYPE_I) {
276 if (s->rv10_version == 3) {
277 /* specific MPEG like DC coding not used */
278 s->last_dc[0] = get_bits(&s->gb, 8);
279 s->last_dc[1] = get_bits(&s->gb, 8);
280 s->last_dc[2] = get_bits(&s->gb, 8);
281 ff_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
282 s->last_dc[1], s->last_dc[2]);
285 /* if multiple packets per frame are sent, the position at which
286 * to display the macroblocks is coded here */
288 mb_xy = s->mb_x + s->mb_y * s->mb_width;
289 if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
290 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
291 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
292 mb_count = get_bits(&s->gb, 12);
296 mb_count = s->mb_width * s->mb_height;
298 skip_bits(&s->gb, 3); /* ignored */
300 s->unrestricted_mv = 1;
305 static int rv20_decode_picture_header(RVDecContext *rv)
307 MpegEncContext *s = &rv->m;
308 int seq, mb_pos, i, ret;
311 i = get_bits(&s->gb, 2);
314 s->pict_type = AV_PICTURE_TYPE_I;
317 s->pict_type = AV_PICTURE_TYPE_I;
320 s->pict_type = AV_PICTURE_TYPE_P;
323 s->pict_type = AV_PICTURE_TYPE_B;
326 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
327 return AVERROR_INVALIDDATA;
330 if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
331 av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
334 if (!s->last_picture_ptr && s->pict_type == AV_PICTURE_TYPE_B) {
335 av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
336 return AVERROR_INVALIDDATA;
339 if (get_bits1(&s->gb)) {
340 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
341 return AVERROR_INVALIDDATA;
344 s->qscale = get_bits(&s->gb, 5);
345 if (s->qscale == 0) {
346 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
347 return AVERROR_INVALIDDATA;
350 if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
351 s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
353 if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
354 seq = get_bits(&s->gb, 8) << 7;
356 seq = get_bits(&s->gb, 13) << 2;
358 rpr_max = s->avctx->extradata[1] & 7;
361 int rpr_bits = av_log2(rpr_max) + 1;
363 f = get_bits(&s->gb, rpr_bits);
366 if (s->avctx->extradata_size < 8 + 2 * f) {
367 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
368 return AVERROR_INVALIDDATA;
371 new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];
372 new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];
374 new_w = rv->orig_width;
375 new_h = rv->orig_height;
377 if (new_w != s->width || new_h != s->height) {
378 AVRational old_aspect = s->avctx->sample_aspect_ratio;
379 av_log(s->avctx, AV_LOG_DEBUG,
380 "attempting to change resolution to %dx%d\n", new_w, new_h);
381 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
382 return AVERROR_INVALIDDATA;
383 ff_mpv_common_end(s);
385 // attempt to keep aspect during typical resolution switches
387 old_aspect = (AVRational){1, 1};
388 if (2 * new_w * s->height == new_h * s->width)
389 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
390 if (new_w * s->height == 2 * new_h * s->width)
391 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
393 ret = ff_set_dimensions(s->avctx, new_w, new_h);
399 if ((ret = ff_mpv_common_init(s)) < 0)
403 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
404 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max);
407 if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
408 return AVERROR_INVALIDDATA;
410 mb_pos = ff_h263_decode_mba(s);
412 seq |= s->time & ~0x7FFF;
413 if (seq - s->time > 0x4000)
415 if (seq - s->time < -0x4000)
418 if (seq != s->time) {
419 if (s->pict_type != AV_PICTURE_TYPE_B) {
421 s->pp_time = s->time - s->last_non_b_time;
422 s->last_non_b_time = s->time;
425 s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
428 if (s->pict_type == AV_PICTURE_TYPE_B) {
429 if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
430 av_log(s->avctx, AV_LOG_DEBUG,
431 "messed up order, possible from seeking? skipping current b frame\n");
432 #define ERROR_SKIP_FRAME -123
433 return ERROR_SKIP_FRAME;
435 ff_mpeg4_init_direct_mv(s);
438 s->no_rounding = get_bits1(&s->gb);
440 if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
441 // binary decoder reads 3+2 bits here but they don't seem to be used
442 skip_bits(&s->gb, 5);
445 s->unrestricted_mv = 1;
446 s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;
447 s->modified_quant = 1;
448 if (!s->avctx->lowres)
451 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
452 av_log(s->avctx, AV_LOG_INFO,
453 "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
454 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,
458 av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
460 return s->mb_width * s->mb_height - mb_pos;
463 static av_cold int rv10_decode_init(AVCodecContext *avctx)
465 RVDecContext *rv = avctx->priv_data;
466 MpegEncContext *s = &rv->m;
468 int major_ver, minor_ver, micro_ver, ret;
470 if (avctx->extradata_size < 8) {
471 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
472 return AVERROR_INVALIDDATA;
474 if ((ret = av_image_check_size(avctx->coded_width,
475 avctx->coded_height, 0, avctx)) < 0)
478 ff_mpv_decode_defaults(s);
479 ff_mpv_decode_init(s, avctx);
481 s->out_format = FMT_H263;
484 s->width = avctx->coded_width;
486 s->height = avctx->coded_height;
488 s->h263_long_vectors = ((uint8_t *) avctx->extradata)[3] & 1;
489 rv->sub_id = AV_RB32((uint8_t *) avctx->extradata + 4);
491 major_ver = RV_GET_MAJOR_VER(rv->sub_id);
492 minor_ver = RV_GET_MINOR_VER(rv->sub_id);
493 micro_ver = RV_GET_MICRO_VER(rv->sub_id);
498 s->rv10_version = micro_ver ? 3 : 1;
499 s->obmc = micro_ver == 2;
502 if (minor_ver >= 2) {
504 s->avctx->has_b_frames = 1;
508 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
509 avpriv_request_sample(avctx, "RV1/2 version");
510 return AVERROR_PATCHWELCOME;
513 if (avctx->debug & FF_DEBUG_PICT_INFO) {
514 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%"PRIX32"\n", rv->sub_id,
515 ((uint32_t *) avctx->extradata)[0]);
518 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
521 if ((ret = ff_mpv_common_init(s)) < 0)
524 ff_h263dsp_init(&s->h263dsp);
525 ff_h263_decode_init_vlc();
529 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
531 rv_lum_code, 2, 2, 16384);
532 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
534 rv_chrom_code, 2, 2, 16388);
541 static av_cold int rv10_decode_end(AVCodecContext *avctx)
543 MpegEncContext *s = avctx->priv_data;
545 ff_mpv_common_end(s);
549 static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
550 int buf_size, int buf_size2)
552 RVDecContext *rv = avctx->priv_data;
553 MpegEncContext *s = &rv->m;
554 int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
556 active_bits_size = buf_size * 8;
557 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
558 if (s->codec_id == AV_CODEC_ID_RV10)
559 mb_count = rv10_decode_picture_header(s);
561 mb_count = rv20_decode_picture_header(rv);
563 if (mb_count != ERROR_SKIP_FRAME)
564 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
565 return AVERROR_INVALIDDATA;
568 if (s->mb_x >= s->mb_width ||
569 s->mb_y >= s->mb_height) {
570 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
571 return AVERROR_INVALIDDATA;
573 mb_pos = s->mb_y * s->mb_width + s->mb_x;
574 left = s->mb_width * s->mb_height - mb_pos;
575 if (mb_count > left) {
576 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
577 return AVERROR_INVALIDDATA;
580 if ((s->mb_x == 0 && s->mb_y == 0) || !s->current_picture_ptr) {
581 // FIXME write parser so we always have complete frames?
582 if (s->current_picture_ptr) {
583 ff_er_frame_end(&s->er);
585 s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
587 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
589 ff_mpeg_er_frame_start(s);
591 if (s->current_picture_ptr->f->pict_type != s->pict_type) {
592 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
593 return AVERROR_INVALIDDATA;
598 ff_dlog(avctx, "qscale=%d\n", s->qscale);
600 /* default quantization values */
601 if (s->codec_id == AV_CODEC_ID_RV10) {
603 s->first_slice_line = 1;
605 s->first_slice_line = 1;
606 s->resync_mb_x = s->mb_x;
608 start_mb_x = s->mb_x;
609 s->resync_mb_y = s->mb_y;
611 s->y_dc_scale_table =
612 s->c_dc_scale_table = ff_aic_dc_scale_table;
614 s->y_dc_scale_table =
615 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
618 if (s->modified_quant)
619 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
621 ff_set_qscale(s, s->qscale);
623 s->rv10_first_dc_coded[0] = 0;
624 s->rv10_first_dc_coded[1] = 0;
625 s->rv10_first_dc_coded[2] = 0;
629 s->block_wrap[3] = s->b8_stride;
631 s->block_wrap[5] = s->mb_stride;
632 ff_init_block_index(s);
634 /* decode each macroblock */
635 for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
637 ff_update_block_index(s);
638 ff_tlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
640 s->mv_dir = MV_DIR_FORWARD;
641 s->mv_type = MV_TYPE_16X16;
642 ret = ff_h263_decode_mb(s, s->block);
644 // Repeat the slice end check from ff_h263_decode_mb with our active
646 if (ret != SLICE_ERROR) {
647 int v = show_bits(&s->gb, 16);
649 if (get_bits_count(&s->gb) + 16 > active_bits_size)
650 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
655 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
656 8 * buf_size2 >= get_bits_count(&s->gb)) {
657 active_bits_size = buf_size2 * 8;
658 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
659 8 * buf_size, active_bits_size);
663 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
664 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
666 return AVERROR_INVALIDDATA;
668 if (s->pict_type != AV_PICTURE_TYPE_B)
669 ff_h263_update_motion_val(s);
670 ff_mpv_decode_mb(s, s->block);
672 ff_h263_loop_filter(s);
674 if (++s->mb_x == s->mb_width) {
677 ff_init_block_index(s);
679 if (s->mb_x == s->resync_mb_x)
680 s->first_slice_line = 0;
681 if (ret == SLICE_END)
685 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
688 return active_bits_size;
691 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
693 if (avctx->slice_count)
694 return avctx->slice_offset[n];
696 return AV_RL32(buf + n * 8);
699 static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
702 const uint8_t *buf = avpkt->data;
703 int buf_size = avpkt->size;
704 MpegEncContext *s = avctx->priv_data;
705 AVFrame *pict = data;
708 const uint8_t *slices_hdr = NULL;
710 ff_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
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 && 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) {
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[]) {