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"
35 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
36 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
37 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
39 #define DC_VLC_BITS 14 //FIXME find a better solution
41 typedef struct RVDecContext {
46 static const uint16_t rv_lum_code[256] = {
47 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
48 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
49 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
50 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
51 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
52 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
53 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
54 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
55 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
56 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
57 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
58 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
59 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
60 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
61 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
62 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
63 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
64 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
65 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
66 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
67 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
68 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
69 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
70 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
71 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
72 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
73 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
74 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
75 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
76 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
77 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
78 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
81 static const uint8_t rv_lum_bits[256] = {
82 14, 12, 12, 12, 12, 12, 12, 12,
83 12, 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, 10, 10, 10, 10, 10, 10, 10,
91 10, 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, 8, 8, 8, 8, 8, 8, 8,
95 8, 8, 8, 8, 8, 8, 8, 8,
96 8, 7, 7, 7, 7, 7, 7, 7,
97 7, 6, 6, 6, 6, 5, 5, 4,
98 2, 4, 5, 5, 6, 6, 6, 6,
99 7, 7, 7, 7, 7, 7, 7, 7,
100 8, 8, 8, 8, 8, 8, 8, 8,
101 8, 8, 8, 8, 8, 8, 8, 8,
102 10, 10, 10, 10, 10, 10, 10, 10,
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 12, 12, 12, 12, 12, 12, 12, 12,
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,
116 static const uint16_t rv_chrom_code[256] = {
117 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
118 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
119 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
120 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
121 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
122 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
123 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
124 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
125 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
126 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
127 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
128 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
129 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
130 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
131 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
132 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
133 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
134 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
135 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
136 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
137 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
138 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
139 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
140 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
141 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
142 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
143 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
144 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
145 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
146 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
147 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
148 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
151 static const uint8_t rv_chrom_bits[256] = {
152 16, 14, 14, 14, 14, 14, 14, 14,
153 14, 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, 12, 12, 12, 12, 12, 12, 12,
161 12, 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, 10, 10, 10, 10, 10, 10, 10,
165 10, 10, 10, 10, 10, 10, 10, 10,
166 10, 8, 8, 8, 8, 8, 8, 8,
167 8, 6, 6, 6, 6, 4, 4, 3,
168 2, 3, 4, 4, 6, 6, 6, 6,
169 8, 8, 8, 8, 8, 8, 8, 8,
170 10, 10, 10, 10, 10, 10, 10, 10,
171 10, 10, 10, 10, 10, 10, 10, 10,
172 12, 12, 12, 12, 12, 12, 12, 12,
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 14, 14, 14, 14, 14, 14, 14, 14,
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,
186 static VLC rv_dc_lum, rv_dc_chrom;
188 int ff_rv_decode_dc(MpegEncContext *s, int n)
193 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
195 /* XXX: I don't understand why they use LONGER codes than
196 necessary. The following code would be completely useless
197 if they had thought about it !!! */
198 code = get_bits(&s->gb, 7);
200 code = (int8_t)(get_bits(&s->gb, 7) + 1);
201 } else if (code == 0x7d) {
202 code = -128 + get_bits(&s->gb, 7);
203 } else if (code == 0x7e) {
204 if (get_bits1(&s->gb) == 0)
205 code = (int8_t)(get_bits(&s->gb, 8) + 1);
207 code = (int8_t)(get_bits(&s->gb, 8));
208 } else if (code == 0x7f) {
209 skip_bits(&s->gb, 11);
216 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
219 code = get_bits(&s->gb, 9);
221 code = (int8_t)(get_bits(&s->gb, 7) + 1);
222 } else if (code == 0x1fd) {
223 code = -128 + get_bits(&s->gb, 7);
224 } else if (code == 0x1fe) {
225 skip_bits(&s->gb, 9);
228 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
238 /* read RV 1.0 compatible frame header */
239 static int rv10_decode_picture_header(MpegEncContext *s)
241 int mb_count, pb_frame, marker, mb_xy;
243 marker = get_bits1(&s->gb);
245 if (get_bits1(&s->gb))
246 s->pict_type = AV_PICTURE_TYPE_P;
248 s->pict_type = AV_PICTURE_TYPE_I;
251 av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
253 pb_frame = get_bits1(&s->gb);
255 av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
258 avpriv_request_sample(s->avctx, "pb frame");
259 return AVERROR_PATCHWELCOME;
262 s->qscale = get_bits(&s->gb, 5);
263 if (s->qscale == 0) {
264 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
265 return AVERROR_INVALIDDATA;
268 if (s->pict_type == AV_PICTURE_TYPE_I) {
269 if (s->rv10_version == 3) {
270 /* specific MPEG like DC coding not used */
271 s->last_dc[0] = get_bits(&s->gb, 8);
272 s->last_dc[1] = get_bits(&s->gb, 8);
273 s->last_dc[2] = get_bits(&s->gb, 8);
274 av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
275 s->last_dc[1], s->last_dc[2]);
278 /* if multiple packets per frame are sent, the position at which
279 to display the macroblocks is coded here */
281 mb_xy = s->mb_x + s->mb_y * s->mb_width;
282 if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
283 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
284 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
285 mb_count = get_bits(&s->gb, 12);
289 mb_count = s->mb_width * s->mb_height;
291 skip_bits(&s->gb, 3); /* ignored */
293 s->unrestricted_mv = 1;
298 static int rv20_decode_picture_header(RVDecContext *rv)
300 MpegEncContext *s = &rv->m;
301 int seq, mb_pos, i, ret;
304 i = get_bits(&s->gb, 2);
306 case 0: s->pict_type = AV_PICTURE_TYPE_I; break;
307 case 1: s->pict_type = AV_PICTURE_TYPE_I; break; //hmm ...
308 case 2: s->pict_type = AV_PICTURE_TYPE_P; break;
309 case 3: s->pict_type = AV_PICTURE_TYPE_B; break;
311 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
312 return AVERROR_INVALIDDATA;
315 if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
316 av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
319 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
320 av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
321 return AVERROR_INVALIDDATA;
324 if (get_bits1(&s->gb)) {
325 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
326 return AVERROR_INVALIDDATA;
329 s->qscale = get_bits(&s->gb, 5);
330 if (s->qscale == 0) {
331 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
332 return AVERROR_INVALIDDATA;
335 if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
336 s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
338 if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
339 seq = get_bits(&s->gb, 8) << 7;
341 seq = get_bits(&s->gb, 13) << 2;
343 rpr_bits = s->avctx->extradata[1] & 7;
346 rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
348 f = get_bits(&s->gb, rpr_bits);
351 if (s->avctx->extradata_size < 8 + 2 * f) {
352 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
353 return AVERROR_INVALIDDATA;
356 new_w = 4 * ((uint8_t*)s->avctx->extradata)[6 + 2 * f];
357 new_h = 4 * ((uint8_t*)s->avctx->extradata)[7 + 2 * f];
359 new_w = s->orig_width ;
360 new_h = s->orig_height;
362 if (new_w != s->width || new_h != s->height) {
363 AVRational old_aspect = s->avctx->sample_aspect_ratio;
364 av_log(s->avctx, AV_LOG_DEBUG,
365 "attempting to change resolution to %dx%d\n", new_w, new_h);
366 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
367 return AVERROR_INVALIDDATA;
368 ff_MPV_common_end(s);
370 // attempt to keep aspect during typical resolution switches
372 old_aspect = (AVRational){1, 1};
373 if (2 * new_w * s->height == new_h * s->width)
374 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
375 if (new_w * s->height == 2 * new_h * s->width)
376 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
377 avcodec_set_dimensions(s->avctx, new_w, new_h);
380 if ((ret = ff_MPV_common_init(s)) < 0)
384 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
385 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
388 if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
389 return AVERROR_INVALIDDATA;
391 mb_pos = ff_h263_decode_mba(s);
393 seq |= s->time & ~0x7FFF;
394 if (seq - s->time > 0x4000)
396 if (seq - s->time < -0x4000)
399 if (seq != s->time) {
400 if (s->pict_type != AV_PICTURE_TYPE_B) {
402 s->pp_time = s->time - s->last_non_b_time;
403 s->last_non_b_time = s->time;
406 s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
409 if (s->pict_type == AV_PICTURE_TYPE_B) {
410 if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
411 av_log(s->avctx, AV_LOG_DEBUG,
412 "messed up order, possible from seeking? skipping current b frame\n");
413 #define ERROR_SKIP_FRAME -123
414 return ERROR_SKIP_FRAME;
416 ff_mpeg4_init_direct_mv(s);
419 s->no_rounding = get_bits1(&s->gb);
421 if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
422 skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
425 s->unrestricted_mv = 1;
426 s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;
427 s->modified_quant = 1;
428 if (!s->avctx->lowres)
431 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
432 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
433 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
436 av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
438 return s->mb_width*s->mb_height - mb_pos;
441 static av_cold int rv10_decode_init(AVCodecContext *avctx)
443 RVDecContext *rv = avctx->priv_data;
444 MpegEncContext *s = &rv->m;
446 int major_ver, minor_ver, micro_ver, ret;
448 if (avctx->extradata_size < 8) {
449 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
450 return AVERROR_INVALIDDATA;
453 ff_MPV_decode_defaults(s);
456 s->out_format = FMT_H263;
457 s->codec_id = avctx->codec_id;
459 s->orig_width = s->width = avctx->coded_width;
460 s->orig_height = s->height = avctx->coded_height;
462 s->h263_long_vectors = ((uint8_t*)avctx->extradata)[3] & 1;
463 rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
465 major_ver = RV_GET_MAJOR_VER(rv->sub_id);
466 minor_ver = RV_GET_MINOR_VER(rv->sub_id);
467 micro_ver = RV_GET_MICRO_VER(rv->sub_id);
472 s->rv10_version = micro_ver ? 3 : 1;
473 s->obmc = micro_ver == 2;
476 if (minor_ver >= 2) {
478 s->avctx->has_b_frames = 1;
482 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
483 avpriv_request_sample(avctx, "RV1/2 version");
484 return AVERROR_PATCHWELCOME;
487 if (avctx->debug & FF_DEBUG_PICT_INFO) {
488 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
489 ((uint32_t*)avctx->extradata)[0]);
492 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
494 if ((ret = ff_MPV_common_init(s)) < 0)
497 ff_h263_decode_init_vlc();
501 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
503 rv_lum_code, 2, 2, 16384);
504 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
506 rv_chrom_code, 2, 2, 16388);
513 static av_cold int rv10_decode_end(AVCodecContext *avctx)
515 MpegEncContext *s = avctx->priv_data;
517 ff_MPV_common_end(s);
521 static int rv10_decode_packet(AVCodecContext *avctx,
522 const uint8_t *buf, int buf_size, int buf_size2)
524 RVDecContext *rv = avctx->priv_data;
525 MpegEncContext *s = &rv->m;
526 int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
528 active_bits_size = buf_size * 8;
529 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
530 if (s->codec_id == AV_CODEC_ID_RV10)
531 mb_count = rv10_decode_picture_header(s);
533 mb_count = rv20_decode_picture_header(rv);
535 if (mb_count != ERROR_SKIP_FRAME)
536 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
537 return AVERROR_INVALIDDATA;
540 if (s->mb_x >= s->mb_width ||
541 s->mb_y >= s->mb_height) {
542 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
543 return AVERROR_INVALIDDATA;
545 mb_pos = s->mb_y * s->mb_width + s->mb_x;
546 left = s->mb_width * s->mb_height - mb_pos;
547 if (mb_count > left) {
548 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
549 return AVERROR_INVALIDDATA;
552 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
553 if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?
554 ff_er_frame_end(&s->er);
556 s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
558 if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
560 ff_mpeg_er_frame_start(s);
562 if (s->current_picture_ptr->f.pict_type != s->pict_type) {
563 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
564 return AVERROR_INVALIDDATA;
569 av_dlog(avctx, "qscale=%d\n", s->qscale);
571 /* default quantization values */
572 if (s->codec_id == AV_CODEC_ID_RV10) {
574 s->first_slice_line = 1;
576 s->first_slice_line = 1;
577 s->resync_mb_x = s->mb_x;
579 start_mb_x = s->mb_x;
580 s->resync_mb_y = s->mb_y;
582 s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;
584 s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
587 if (s->modified_quant)
588 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
590 ff_set_qscale(s, s->qscale);
592 s->rv10_first_dc_coded[0] = 0;
593 s->rv10_first_dc_coded[1] = 0;
594 s->rv10_first_dc_coded[2] = 0;
598 s->block_wrap[3] = s->b8_stride;
600 s->block_wrap[5] = s->mb_stride;
601 ff_init_block_index(s);
603 /* decode each macroblock */
604 for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
606 ff_update_block_index(s);
607 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
609 s->mv_dir = MV_DIR_FORWARD;
610 s->mv_type = MV_TYPE_16X16;
611 ret = ff_h263_decode_mb(s, s->block);
613 // Repeat the slice end check from ff_h263_decode_mb with our active
615 if (ret != SLICE_ERROR) {
616 int v = show_bits(&s->gb, 16);
618 if (get_bits_count(&s->gb) + 16 > active_bits_size)
619 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
624 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
625 8 * buf_size2 >= get_bits_count(&s->gb)) {
626 active_bits_size = buf_size2 * 8;
627 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
628 8 * buf_size, active_bits_size);
632 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
633 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
634 return AVERROR_INVALIDDATA;
636 if (s->pict_type != AV_PICTURE_TYPE_B)
637 ff_h263_update_motion_val(s);
638 ff_MPV_decode_mb(s, s->block);
640 ff_h263_loop_filter(s);
642 if (++s->mb_x == s->mb_width) {
645 ff_init_block_index(s);
647 if (s->mb_x == s->resync_mb_x)
648 s->first_slice_line = 0;
649 if (ret == SLICE_END)
653 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,
656 return active_bits_size;
659 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
661 if (avctx->slice_count)
662 return avctx->slice_offset[n];
664 return AV_RL32(buf + n * 8);
667 static int rv10_decode_frame(AVCodecContext *avctx,
668 void *data, int *got_frame,
671 const uint8_t *buf = avpkt->data;
672 int buf_size = avpkt->size;
673 MpegEncContext *s = avctx->priv_data;
674 AVFrame *pict = data;
677 const uint8_t *slices_hdr = NULL;
679 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
680 s->flags = avctx->flags;
681 s->flags2 = avctx->flags2;
683 /* no supplementary picture */
688 if (!avctx->slice_count) {
689 slice_count = (*buf++) + 1;
692 if (!slice_count || buf_size <= 8 * slice_count) {
693 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
694 return AVERROR_INVALIDDATA;
697 slices_hdr = buf + 4;
698 buf += 8 * slice_count;
699 buf_size -= 8 * slice_count;
701 slice_count = avctx->slice_count;
703 for (i = 0; i < slice_count; i++) {
704 unsigned offset = get_slice_offset(avctx, slices_hdr, i);
707 if (offset >= buf_size)
708 return AVERROR_INVALIDDATA;
710 if (i + 1 == slice_count)
711 size = buf_size - offset;
713 size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
715 if (i + 2 >= slice_count)
716 size2 = buf_size - offset;
718 size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
720 if (size <= 0 || size2 <= 0 ||
721 offset + FFMAX(size, size2) > buf_size)
722 return AVERROR_INVALIDDATA;
724 if (rv10_decode_packet(avctx, buf + offset, size, size2) > 8 * size)
728 if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
729 ff_er_frame_end(&s->er);
732 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
733 if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
735 ff_print_debug_info(s, s->current_picture_ptr, pict);
736 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
737 } else if (s->last_picture_ptr != NULL) {
738 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
740 ff_print_debug_info(s, s->last_picture_ptr, pict);
741 ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
744 if (s->last_picture_ptr || s->low_delay) {
748 // so we can detect if frame_end was not called (find some nicer solution...)
749 s->current_picture_ptr = NULL;
755 AVCodec ff_rv10_decoder = {
757 .type = AVMEDIA_TYPE_VIDEO,
758 .id = AV_CODEC_ID_RV10,
759 .priv_data_size = sizeof(RVDecContext),
760 .init = rv10_decode_init,
761 .close = rv10_decode_end,
762 .decode = rv10_decode_frame,
763 .capabilities = CODEC_CAP_DR1,
765 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
766 .pix_fmts = ff_pixfmt_list_420,
769 AVCodec ff_rv20_decoder = {
771 .type = AVMEDIA_TYPE_VIDEO,
772 .id = AV_CODEC_ID_RV20,
773 .priv_data_size = sizeof(RVDecContext),
774 .init = rv10_decode_init,
775 .close = rv10_decode_end,
776 .decode = rv10_decode_frame,
777 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
778 .flush = ff_mpeg_flush,
780 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
781 .pix_fmts = ff_pixfmt_list_420,