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"
31 #include "mpegvideo.h"
32 #include "mpeg4video.h"
37 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
38 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
39 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
41 #define DC_VLC_BITS 14 //FIXME find a better solution
43 typedef struct RVDecContext {
48 static const uint16_t rv_lum_code[256] = {
49 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
50 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
51 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
52 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
53 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
54 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
55 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
56 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
57 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
58 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
59 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
60 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
61 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
62 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
63 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
64 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
65 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
66 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
67 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
68 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
69 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
70 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
71 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
72 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
73 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
74 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
75 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
76 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
77 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
78 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
79 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
80 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
83 static const uint8_t rv_lum_bits[256] = {
84 14, 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, 12, 12, 12, 12, 12, 12, 12,
92 12, 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, 10, 10, 10, 10, 10, 10, 10,
96 10, 8, 8, 8, 8, 8, 8, 8,
97 8, 8, 8, 8, 8, 8, 8, 8,
98 8, 7, 7, 7, 7, 7, 7, 7,
99 7, 6, 6, 6, 6, 5, 5, 4,
100 2, 4, 5, 5, 6, 6, 6, 6,
101 7, 7, 7, 7, 7, 7, 7, 7,
102 8, 8, 8, 8, 8, 8, 8, 8,
103 8, 8, 8, 8, 8, 8, 8, 8,
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 10, 10, 10, 10, 10, 10, 10, 10,
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,
115 12, 12, 12, 12, 12, 12, 12, 12,
118 static const uint16_t rv_chrom_code[256] = {
119 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
120 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
121 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
122 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
123 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
124 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
125 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
126 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
127 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
128 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
129 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
130 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
131 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
132 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
133 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
134 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
135 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
136 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
137 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
138 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
139 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
140 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
141 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
142 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
143 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
144 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
145 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
146 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
147 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
148 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
149 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
150 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
153 static const uint8_t rv_chrom_bits[256] = {
154 16, 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, 14, 14, 14, 14, 14, 14, 14,
162 14, 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, 12, 12, 12, 12, 12, 12, 12,
166 12, 10, 10, 10, 10, 10, 10, 10,
167 10, 10, 10, 10, 10, 10, 10, 10,
168 10, 8, 8, 8, 8, 8, 8, 8,
169 8, 6, 6, 6, 6, 4, 4, 3,
170 2, 3, 4, 4, 6, 6, 6, 6,
171 8, 8, 8, 8, 8, 8, 8, 8,
172 10, 10, 10, 10, 10, 10, 10, 10,
173 10, 10, 10, 10, 10, 10, 10, 10,
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 12, 12, 12, 12, 12, 12, 12, 12,
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,
185 14, 14, 14, 14, 14, 14, 14, 14,
188 static VLC rv_dc_lum, rv_dc_chrom;
190 int ff_rv_decode_dc(MpegEncContext *s, int n)
195 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
197 /* XXX: I don't understand why they use LONGER codes than
198 necessary. The following code would be completely useless
199 if they had thought about it !!! */
200 code = get_bits(&s->gb, 7);
202 code = (int8_t)(get_bits(&s->gb, 7) + 1);
203 } else if (code == 0x7d) {
204 code = -128 + get_bits(&s->gb, 7);
205 } else if (code == 0x7e) {
206 if (get_bits1(&s->gb) == 0)
207 code = (int8_t)(get_bits(&s->gb, 8) + 1);
209 code = (int8_t)(get_bits(&s->gb, 8));
210 } else if (code == 0x7f) {
211 skip_bits(&s->gb, 11);
218 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
221 code = get_bits(&s->gb, 9);
223 code = (int8_t)(get_bits(&s->gb, 7) + 1);
224 } else if (code == 0x1fd) {
225 code = -128 + get_bits(&s->gb, 7);
226 } else if (code == 0x1fe) {
227 skip_bits(&s->gb, 9);
230 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
240 /* read RV 1.0 compatible frame header */
241 static int rv10_decode_picture_header(MpegEncContext *s)
243 int mb_count, pb_frame, marker, mb_xy;
245 marker = get_bits1(&s->gb);
247 if (get_bits1(&s->gb))
248 s->pict_type = AV_PICTURE_TYPE_P;
250 s->pict_type = AV_PICTURE_TYPE_I;
253 av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
255 pb_frame = get_bits1(&s->gb);
257 av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
260 avpriv_request_sample(s->avctx, "pb frame");
261 return AVERROR_PATCHWELCOME;
264 s->qscale = get_bits(&s->gb, 5);
265 if (s->qscale == 0) {
266 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
267 return AVERROR_INVALIDDATA;
270 if (s->pict_type == AV_PICTURE_TYPE_I) {
271 if (s->rv10_version == 3) {
272 /* specific MPEG like DC coding not used */
273 s->last_dc[0] = get_bits(&s->gb, 8);
274 s->last_dc[1] = get_bits(&s->gb, 8);
275 s->last_dc[2] = get_bits(&s->gb, 8);
276 av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
277 s->last_dc[1], s->last_dc[2]);
280 /* if multiple packets per frame are sent, the position at which
281 to display the macroblocks is coded here */
283 mb_xy = s->mb_x + s->mb_y * s->mb_width;
284 if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
285 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
286 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
287 mb_count = get_bits(&s->gb, 12);
291 mb_count = s->mb_width * s->mb_height;
293 skip_bits(&s->gb, 3); /* ignored */
295 s->unrestricted_mv = 1;
300 static int rv20_decode_picture_header(RVDecContext *rv)
302 MpegEncContext *s = &rv->m;
303 int seq, mb_pos, i, ret;
306 i = get_bits(&s->gb, 2);
308 case 0: s->pict_type = AV_PICTURE_TYPE_I; break;
309 case 1: s->pict_type = AV_PICTURE_TYPE_I; break; //hmm ...
310 case 2: s->pict_type = AV_PICTURE_TYPE_P; break;
311 case 3: s->pict_type = AV_PICTURE_TYPE_B; break;
313 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
314 return AVERROR_INVALIDDATA;
317 if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
318 av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
321 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
322 av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
323 return AVERROR_INVALIDDATA;
326 if (get_bits1(&s->gb)) {
327 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
328 return AVERROR_INVALIDDATA;
331 s->qscale = get_bits(&s->gb, 5);
332 if (s->qscale == 0) {
333 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
334 return AVERROR_INVALIDDATA;
337 if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
338 s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
340 if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
341 seq = get_bits(&s->gb, 8) << 7;
343 seq = get_bits(&s->gb, 13) << 2;
345 rpr_bits = s->avctx->extradata[1] & 7;
348 rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
350 f = get_bits(&s->gb, rpr_bits);
353 if (s->avctx->extradata_size < 8 + 2 * f) {
354 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
355 return AVERROR_INVALIDDATA;
358 new_w = 4 * ((uint8_t*)s->avctx->extradata)[6 + 2 * f];
359 new_h = 4 * ((uint8_t*)s->avctx->extradata)[7 + 2 * f];
361 new_w = s->orig_width ;
362 new_h = s->orig_height;
364 if (new_w != s->width || new_h != s->height) {
365 AVRational old_aspect = s->avctx->sample_aspect_ratio;
366 av_log(s->avctx, AV_LOG_DEBUG,
367 "attempting to change resolution to %dx%d\n", new_w, new_h);
368 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
369 return AVERROR_INVALIDDATA;
370 ff_MPV_common_end(s);
372 // attempt to keep aspect during typical resolution switches
374 old_aspect = (AVRational){1, 1};
375 if (2 * new_w * s->height == new_h * s->width)
376 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
377 if (new_w * s->height == 2 * new_h * s->width)
378 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
379 avcodec_set_dimensions(s->avctx, new_w, new_h);
382 if ((ret = ff_MPV_common_init(s)) < 0)
386 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
387 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
390 if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
391 return AVERROR_INVALIDDATA;
393 mb_pos = ff_h263_decode_mba(s);
395 seq |= s->time & ~0x7FFF;
396 if (seq - s->time > 0x4000)
398 if (seq - s->time < -0x4000)
401 if (seq != s->time) {
402 if (s->pict_type != AV_PICTURE_TYPE_B) {
404 s->pp_time = s->time - s->last_non_b_time;
405 s->last_non_b_time = s->time;
408 s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
411 if (s->pict_type == AV_PICTURE_TYPE_B) {
412 if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
413 av_log(s->avctx, AV_LOG_DEBUG,
414 "messed up order, possible from seeking? skipping current b frame\n");
415 #define ERROR_SKIP_FRAME -123
416 return ERROR_SKIP_FRAME;
418 ff_mpeg4_init_direct_mv(s);
421 s->no_rounding = get_bits1(&s->gb);
423 if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
424 skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
427 s->unrestricted_mv = 1;
428 s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;
429 s->modified_quant = 1;
430 if (!s->avctx->lowres)
433 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
434 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
435 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
438 av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
440 return s->mb_width*s->mb_height - mb_pos;
443 static av_cold int rv10_decode_init(AVCodecContext *avctx)
445 RVDecContext *rv = avctx->priv_data;
446 MpegEncContext *s = &rv->m;
448 int major_ver, minor_ver, micro_ver, ret;
450 if (avctx->extradata_size < 8) {
451 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
452 return AVERROR_INVALIDDATA;
455 ff_MPV_decode_defaults(s);
458 s->out_format = FMT_H263;
459 s->codec_id = avctx->codec_id;
461 s->orig_width = s->width = avctx->coded_width;
462 s->orig_height = s->height = avctx->coded_height;
464 s->h263_long_vectors = ((uint8_t*)avctx->extradata)[3] & 1;
465 rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
467 major_ver = RV_GET_MAJOR_VER(rv->sub_id);
468 minor_ver = RV_GET_MINOR_VER(rv->sub_id);
469 micro_ver = RV_GET_MICRO_VER(rv->sub_id);
474 s->rv10_version = micro_ver ? 3 : 1;
475 s->obmc = micro_ver == 2;
478 if (minor_ver >= 2) {
480 s->avctx->has_b_frames = 1;
484 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
485 avpriv_request_sample(avctx, "RV1/2 version");
486 return AVERROR_PATCHWELCOME;
489 if (avctx->debug & FF_DEBUG_PICT_INFO) {
490 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
491 ((uint32_t*)avctx->extradata)[0]);
494 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
496 if ((ret = ff_MPV_common_init(s)) < 0)
499 ff_h263_decode_init_vlc();
503 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
505 rv_lum_code, 2, 2, 16384);
506 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
508 rv_chrom_code, 2, 2, 16388);
515 static av_cold int rv10_decode_end(AVCodecContext *avctx)
517 MpegEncContext *s = avctx->priv_data;
519 ff_MPV_common_end(s);
523 static int rv10_decode_packet(AVCodecContext *avctx,
524 const uint8_t *buf, int buf_size, int buf_size2)
526 RVDecContext *rv = avctx->priv_data;
527 MpegEncContext *s = &rv->m;
528 int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
530 active_bits_size = buf_size * 8;
531 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
532 if (s->codec_id == AV_CODEC_ID_RV10)
533 mb_count = rv10_decode_picture_header(s);
535 mb_count = rv20_decode_picture_header(rv);
537 if (mb_count != ERROR_SKIP_FRAME)
538 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
539 return AVERROR_INVALIDDATA;
542 if (s->mb_x >= s->mb_width ||
543 s->mb_y >= s->mb_height) {
544 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
545 return AVERROR_INVALIDDATA;
547 mb_pos = s->mb_y * s->mb_width + s->mb_x;
548 left = s->mb_width * s->mb_height - mb_pos;
549 if (mb_count > left) {
550 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
551 return AVERROR_INVALIDDATA;
554 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
555 if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?
556 ff_er_frame_end(&s->er);
558 s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
560 if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
562 ff_mpeg_er_frame_start(s);
564 if (s->current_picture_ptr->f.pict_type != s->pict_type) {
565 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
566 return AVERROR_INVALIDDATA;
571 av_dlog(avctx, "qscale=%d\n", s->qscale);
573 /* default quantization values */
574 if (s->codec_id == AV_CODEC_ID_RV10) {
576 s->first_slice_line = 1;
578 s->first_slice_line = 1;
579 s->resync_mb_x = s->mb_x;
581 start_mb_x = s->mb_x;
582 s->resync_mb_y = s->mb_y;
584 s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;
586 s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
589 if (s->modified_quant)
590 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
592 ff_set_qscale(s, s->qscale);
594 s->rv10_first_dc_coded[0] = 0;
595 s->rv10_first_dc_coded[1] = 0;
596 s->rv10_first_dc_coded[2] = 0;
600 s->block_wrap[3] = s->b8_stride;
602 s->block_wrap[5] = s->mb_stride;
603 ff_init_block_index(s);
605 /* decode each macroblock */
606 for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
608 ff_update_block_index(s);
609 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
611 s->mv_dir = MV_DIR_FORWARD;
612 s->mv_type = MV_TYPE_16X16;
613 ret = ff_h263_decode_mb(s, s->block);
615 // Repeat the slice end check from ff_h263_decode_mb with our active
617 if (ret != SLICE_ERROR) {
618 int v = show_bits(&s->gb, 16);
620 if (get_bits_count(&s->gb) + 16 > active_bits_size)
621 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
626 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
627 8 * buf_size2 >= get_bits_count(&s->gb)) {
628 active_bits_size = buf_size2 * 8;
629 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
630 8 * buf_size, active_bits_size);
634 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
635 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
636 return AVERROR_INVALIDDATA;
638 if (s->pict_type != AV_PICTURE_TYPE_B)
639 ff_h263_update_motion_val(s);
640 ff_MPV_decode_mb(s, s->block);
642 ff_h263_loop_filter(s);
644 if (++s->mb_x == s->mb_width) {
647 ff_init_block_index(s);
649 if (s->mb_x == s->resync_mb_x)
650 s->first_slice_line = 0;
651 if (ret == SLICE_END)
655 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,
658 return active_bits_size;
661 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
663 if (avctx->slice_count)
664 return avctx->slice_offset[n];
666 return AV_RL32(buf + n * 8);
669 static int rv10_decode_frame(AVCodecContext *avctx,
670 void *data, int *got_frame,
673 const uint8_t *buf = avpkt->data;
674 int buf_size = avpkt->size;
675 MpegEncContext *s = avctx->priv_data;
676 AVFrame *pict = data;
679 const uint8_t *slices_hdr = NULL;
681 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
682 s->flags = avctx->flags;
683 s->flags2 = avctx->flags2;
685 /* no supplementary picture */
690 if (!avctx->slice_count) {
691 slice_count = (*buf++) + 1;
694 if (!slice_count || buf_size <= 8 * slice_count) {
695 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
696 return AVERROR_INVALIDDATA;
699 slices_hdr = buf + 4;
700 buf += 8 * slice_count;
701 buf_size -= 8 * slice_count;
703 slice_count = avctx->slice_count;
705 for (i = 0; i < slice_count; i++) {
706 unsigned offset = get_slice_offset(avctx, slices_hdr, i);
709 if (offset >= buf_size)
710 return AVERROR_INVALIDDATA;
712 if (i + 1 == slice_count)
713 size = buf_size - offset;
715 size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
717 if (i + 2 >= slice_count)
718 size2 = buf_size - offset;
720 size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
722 if (size <= 0 || size2 <= 0 ||
723 offset + FFMAX(size, size2) > buf_size)
724 return AVERROR_INVALIDDATA;
726 if (rv10_decode_packet(avctx, buf + offset, size, size2) > 8 * size)
730 if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
731 ff_er_frame_end(&s->er);
734 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
735 if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
737 ff_print_debug_info(s, s->current_picture_ptr, pict);
738 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
739 } else if (s->last_picture_ptr != NULL) {
740 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
742 ff_print_debug_info(s, s->last_picture_ptr, pict);
743 ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
746 if (s->last_picture_ptr || s->low_delay) {
750 // so we can detect if frame_end was not called (find some nicer solution...)
751 s->current_picture_ptr = NULL;
757 AVCodec ff_rv10_decoder = {
759 .type = AVMEDIA_TYPE_VIDEO,
760 .id = AV_CODEC_ID_RV10,
761 .priv_data_size = sizeof(RVDecContext),
762 .init = rv10_decode_init,
763 .close = rv10_decode_end,
764 .decode = rv10_decode_frame,
765 .capabilities = CODEC_CAP_DR1,
767 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
768 .pix_fmts = ff_pixfmt_list_420,
771 AVCodec ff_rv20_decoder = {
773 .type = AVMEDIA_TYPE_VIDEO,
774 .id = AV_CODEC_ID_RV20,
775 .priv_data_size = sizeof(RVDecContext),
776 .init = rv10_decode_init,
777 .close = rv10_decode_end,
778 .decode = rv10_decode_frame,
779 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
780 .flush = ff_mpeg_flush,
782 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
783 .pix_fmts = ff_pixfmt_list_420,