3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer
6 * This file is part of Libav.
8 * Libav 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 * Libav 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 Libav; 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"
38 #include "mpegutils.h"
39 #include "mpegvideo.h"
40 #include "mpeg4video.h"
41 #include "mpegvideodata.h"
44 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
45 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
46 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
48 #define DC_VLC_BITS 14 // FIXME find a better solution
50 typedef struct RVDecContext {
53 int orig_width, orig_height;
56 static const uint16_t rv_lum_code[256] = {
57 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
58 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
59 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
60 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
61 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
62 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
63 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
64 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
65 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
66 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
67 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
68 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
69 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
70 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
71 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
72 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
73 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
74 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
75 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
76 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
77 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
78 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
79 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
80 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
81 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
82 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
83 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
84 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
85 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
86 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
87 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
88 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
91 static const uint8_t rv_lum_bits[256] = {
92 14, 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, 12, 12, 12, 12, 12, 12, 12,
98 12, 12, 12, 12, 12, 12, 12, 12,
99 12, 12, 12, 12, 12, 12, 12, 12,
100 12, 10, 10, 10, 10, 10, 10, 10,
101 10, 10, 10, 10, 10, 10, 10, 10,
102 10, 10, 10, 10, 10, 10, 10, 10,
103 10, 10, 10, 10, 10, 10, 10, 10,
104 10, 8, 8, 8, 8, 8, 8, 8,
105 8, 8, 8, 8, 8, 8, 8, 8,
106 8, 7, 7, 7, 7, 7, 7, 7,
107 7, 6, 6, 6, 6, 5, 5, 4,
108 2, 4, 5, 5, 6, 6, 6, 6,
109 7, 7, 7, 7, 7, 7, 7, 7,
110 8, 8, 8, 8, 8, 8, 8, 8,
111 8, 8, 8, 8, 8, 8, 8, 8,
112 10, 10, 10, 10, 10, 10, 10, 10,
113 10, 10, 10, 10, 10, 10, 10, 10,
114 10, 10, 10, 10, 10, 10, 10, 10,
115 10, 10, 10, 10, 10, 10, 10, 10,
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,
121 12, 12, 12, 12, 12, 12, 12, 12,
122 12, 12, 12, 12, 12, 12, 12, 12,
123 12, 12, 12, 12, 12, 12, 12, 12,
126 static const uint16_t rv_chrom_code[256] = {
127 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
128 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
129 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
130 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
131 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
132 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
133 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
134 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
135 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
136 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
137 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
138 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
139 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
140 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
141 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
142 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
143 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
144 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
145 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
146 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
147 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
148 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
149 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
150 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
151 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
152 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
153 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
154 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
155 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
156 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
157 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
158 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
161 static const uint8_t rv_chrom_bits[256] = {
162 16, 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, 14, 14, 14, 14, 14, 14, 14,
168 14, 14, 14, 14, 14, 14, 14, 14,
169 14, 14, 14, 14, 14, 14, 14, 14,
170 14, 12, 12, 12, 12, 12, 12, 12,
171 12, 12, 12, 12, 12, 12, 12, 12,
172 12, 12, 12, 12, 12, 12, 12, 12,
173 12, 12, 12, 12, 12, 12, 12, 12,
174 12, 10, 10, 10, 10, 10, 10, 10,
175 10, 10, 10, 10, 10, 10, 10, 10,
176 10, 8, 8, 8, 8, 8, 8, 8,
177 8, 6, 6, 6, 6, 4, 4, 3,
178 2, 3, 4, 4, 6, 6, 6, 6,
179 8, 8, 8, 8, 8, 8, 8, 8,
180 10, 10, 10, 10, 10, 10, 10, 10,
181 10, 10, 10, 10, 10, 10, 10, 10,
182 12, 12, 12, 12, 12, 12, 12, 12,
183 12, 12, 12, 12, 12, 12, 12, 12,
184 12, 12, 12, 12, 12, 12, 12, 12,
185 12, 12, 12, 12, 12, 12, 12, 12,
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,
191 14, 14, 14, 14, 14, 14, 14, 14,
192 14, 14, 14, 14, 14, 14, 14, 14,
193 14, 14, 14, 14, 14, 14, 14, 14,
196 static VLC rv_dc_lum, rv_dc_chrom;
198 int ff_rv_decode_dc(MpegEncContext *s, int n)
203 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
205 /* XXX: I don't understand why they use LONGER codes than
206 * necessary. The following code would be completely useless
207 * if they had thought about it !!! */
208 code = get_bits(&s->gb, 7);
210 code = (int8_t) (get_bits(&s->gb, 7) + 1);
211 } else if (code == 0x7d) {
212 code = -128 + get_bits(&s->gb, 7);
213 } else if (code == 0x7e) {
214 if (get_bits1(&s->gb) == 0)
215 code = (int8_t) (get_bits(&s->gb, 8) + 1);
217 code = (int8_t) (get_bits(&s->gb, 8));
218 } else if (code == 0x7f) {
219 skip_bits(&s->gb, 11);
226 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
229 code = get_bits(&s->gb, 9);
231 code = (int8_t) (get_bits(&s->gb, 7) + 1);
232 } else if (code == 0x1fd) {
233 code = -128 + get_bits(&s->gb, 7);
234 } else if (code == 0x1fe) {
235 skip_bits(&s->gb, 9);
238 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
248 /* read RV 1.0 compatible frame header */
249 static int rv10_decode_picture_header(MpegEncContext *s)
251 int mb_count, pb_frame, marker, mb_xy;
253 marker = get_bits1(&s->gb);
255 if (get_bits1(&s->gb))
256 s->pict_type = AV_PICTURE_TYPE_P;
258 s->pict_type = AV_PICTURE_TYPE_I;
261 av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
263 pb_frame = get_bits1(&s->gb);
265 ff_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
268 avpriv_request_sample(s->avctx, "PB-frame");
269 return AVERROR_PATCHWELCOME;
272 s->qscale = get_bits(&s->gb, 5);
273 if (s->qscale == 0) {
274 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
275 return AVERROR_INVALIDDATA;
278 if (s->pict_type == AV_PICTURE_TYPE_I) {
279 if (s->rv10_version == 3) {
280 /* specific MPEG like DC coding not used */
281 s->last_dc[0] = get_bits(&s->gb, 8);
282 s->last_dc[1] = get_bits(&s->gb, 8);
283 s->last_dc[2] = get_bits(&s->gb, 8);
284 ff_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
285 s->last_dc[1], s->last_dc[2]);
288 /* if multiple packets per frame are sent, the position at which
289 * to display the macroblocks is coded here */
291 mb_xy = s->mb_x + s->mb_y * s->mb_width;
292 if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
293 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
294 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
295 mb_count = get_bits(&s->gb, 12);
299 mb_count = s->mb_width * s->mb_height;
301 skip_bits(&s->gb, 3); /* ignored */
303 s->unrestricted_mv = 1;
308 static int rv20_decode_picture_header(RVDecContext *rv)
310 MpegEncContext *s = &rv->m;
311 int seq, mb_pos, i, ret;
314 i = get_bits(&s->gb, 2);
317 s->pict_type = AV_PICTURE_TYPE_I;
320 s->pict_type = AV_PICTURE_TYPE_I;
323 s->pict_type = AV_PICTURE_TYPE_P;
326 s->pict_type = AV_PICTURE_TYPE_B;
329 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
330 return AVERROR_INVALIDDATA;
333 if (!s->last_picture_ptr && s->pict_type == AV_PICTURE_TYPE_B) {
334 av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
335 return AVERROR_INVALIDDATA;
338 if (get_bits1(&s->gb)) {
339 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
340 return AVERROR_INVALIDDATA;
343 s->qscale = get_bits(&s->gb, 5);
344 if (s->qscale == 0) {
345 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
346 return AVERROR_INVALIDDATA;
349 if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
350 s->loop_filter = get_bits1(&s->gb);
352 if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
353 seq = get_bits(&s->gb, 8) << 7;
355 seq = get_bits(&s->gb, 13) << 2;
357 rpr_bits = s->avctx->extradata[1] & 7;
360 rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
362 f = get_bits(&s->gb, rpr_bits);
365 if (s->avctx->extradata_size < 8 + 2 * f) {
366 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
367 return AVERROR_INVALIDDATA;
370 new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];
371 new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];
373 new_w = rv->orig_width;
374 new_h = rv->orig_height;
376 if (new_w != s->width || new_h != s->height) {
377 av_log(s->avctx, AV_LOG_DEBUG,
378 "attempting to change resolution to %dx%d\n", new_w, new_h);
379 ff_mpv_common_end(s);
381 ret = ff_set_dimensions(s->avctx, new_w, new_h);
387 if ((ret = ff_mpv_common_init(s)) < 0)
391 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
392 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
394 } else if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
395 return AVERROR_INVALIDDATA;
397 mb_pos = ff_h263_decode_mba(s);
399 seq |= s->time & ~0x7FFF;
400 if (seq - s->time > 0x4000)
402 if (seq - s->time < -0x4000)
405 if (seq != s->time) {
406 if (s->pict_type != AV_PICTURE_TYPE_B) {
408 s->pp_time = s->time - s->last_non_b_time;
409 s->last_non_b_time = s->time;
412 s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
413 if (s->pp_time <= s->pb_time ||
414 s->pp_time <= s->pp_time - s->pb_time || s->pp_time <= 0) {
415 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible "
416 "from seeking? skipping current B-frame\n");
417 return FRAME_SKIPPED;
419 ff_mpeg4_init_direct_mv(s);
423 s->no_rounding = get_bits1(&s->gb);
425 if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
426 // binary decoder reads 3+2 bits here but they don't seem to be used
427 skip_bits(&s->gb, 5);
430 s->unrestricted_mv = 1;
431 s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;
432 s->modified_quant = 1;
435 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
436 av_log(s->avctx, AV_LOG_INFO,
437 "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
438 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,
442 assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
444 return s->mb_width * s->mb_height - mb_pos;
447 static av_cold int rv10_decode_init(AVCodecContext *avctx)
449 RVDecContext *rv = avctx->priv_data;
450 MpegEncContext *s = &rv->m;
452 int major_ver, minor_ver, micro_ver, ret;
454 if (avctx->extradata_size < 8) {
455 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
456 return AVERROR_INVALIDDATA;
458 if ((ret = av_image_check_size(avctx->coded_width,
459 avctx->coded_height, 0, avctx)) < 0)
462 ff_mpv_decode_defaults(s);
465 s->out_format = FMT_H263;
466 s->codec_id = avctx->codec_id;
469 s->width = avctx->coded_width;
471 s->height = avctx->coded_height;
473 s->h263_long_vectors = ((uint8_t *) avctx->extradata)[3] & 1;
474 rv->sub_id = AV_RB32((uint8_t *) avctx->extradata + 4);
476 major_ver = RV_GET_MAJOR_VER(rv->sub_id);
477 minor_ver = RV_GET_MINOR_VER(rv->sub_id);
478 micro_ver = RV_GET_MICRO_VER(rv->sub_id);
483 s->rv10_version = micro_ver ? 3 : 1;
484 s->obmc = micro_ver == 2;
487 if (minor_ver >= 2) {
489 s->avctx->has_b_frames = 1;
493 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
494 avpriv_request_sample(avctx, "RV1/2 version");
495 return AVERROR_PATCHWELCOME;
498 if (avctx->debug & FF_DEBUG_PICT_INFO) {
499 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
500 avctx->extradata_size >= 4 ? ((int *) avctx->extradata)[0] : -1);
503 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
506 if ((ret = ff_mpv_common_init(s)) < 0)
509 ff_h263dsp_init(&s->h263dsp);
510 ff_h263_decode_init_vlc();
514 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
516 rv_lum_code, 2, 2, 16384);
517 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
519 rv_chrom_code, 2, 2, 16388);
526 static av_cold int rv10_decode_end(AVCodecContext *avctx)
528 MpegEncContext *s = avctx->priv_data;
530 ff_mpv_common_end(s);
534 static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
535 int buf_size, int buf_size2)
537 RVDecContext *rv = avctx->priv_data;
538 MpegEncContext *s = &rv->m;
539 int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
541 active_bits_size = buf_size * 8;
542 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
543 if (s->codec_id == AV_CODEC_ID_RV10)
544 mb_count = rv10_decode_picture_header(s);
546 mb_count = rv20_decode_picture_header(rv);
548 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
549 return AVERROR_INVALIDDATA;
552 if (s->mb_x >= s->mb_width ||
553 s->mb_y >= s->mb_height) {
554 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
555 return AVERROR_INVALIDDATA;
557 mb_pos = s->mb_y * s->mb_width + s->mb_x;
558 left = s->mb_width * s->mb_height - mb_pos;
559 if (mb_count > left) {
560 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
561 return AVERROR_INVALIDDATA;
564 if ((s->mb_x == 0 && s->mb_y == 0) || !s->current_picture_ptr) {
565 // FIXME write parser so we always have complete frames?
566 if (s->current_picture_ptr) {
567 ff_er_frame_end(&s->er);
569 s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
571 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
573 ff_mpeg_er_frame_start(s);
575 if (s->current_picture_ptr->f->pict_type != s->pict_type) {
576 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
577 return AVERROR_INVALIDDATA;
581 ff_dlog(avctx, "qscale=%d\n", s->qscale);
583 /* default quantization values */
584 if (s->codec_id == AV_CODEC_ID_RV10) {
586 s->first_slice_line = 1;
588 s->first_slice_line = 1;
589 s->resync_mb_x = s->mb_x;
591 start_mb_x = s->mb_x;
592 s->resync_mb_y = s->mb_y;
594 s->y_dc_scale_table =
595 s->c_dc_scale_table = ff_aic_dc_scale_table;
597 s->y_dc_scale_table =
598 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
601 if (s->modified_quant)
602 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
604 ff_set_qscale(s, s->qscale);
606 s->rv10_first_dc_coded[0] = 0;
607 s->rv10_first_dc_coded[1] = 0;
608 s->rv10_first_dc_coded[2] = 0;
612 s->block_wrap[3] = s->b8_stride;
614 s->block_wrap[5] = s->mb_stride;
615 ff_init_block_index(s);
617 /* decode each macroblock */
618 for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
620 ff_update_block_index(s);
621 ff_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
623 s->mv_dir = MV_DIR_FORWARD;
624 s->mv_type = MV_TYPE_16X16;
625 ret = ff_h263_decode_mb(s, s->block);
627 // Repeat the slice end check from ff_h263_decode_mb with our active
629 if (ret != SLICE_ERROR) {
630 int v = show_bits(&s->gb, 16);
632 if (get_bits_count(&s->gb) + 16 > active_bits_size)
633 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
638 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
639 8 * buf_size2 >= get_bits_count(&s->gb)) {
640 active_bits_size = buf_size2 * 8;
641 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
642 8 * buf_size, active_bits_size);
646 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
647 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
649 return AVERROR_INVALIDDATA;
651 if (s->pict_type != AV_PICTURE_TYPE_B)
652 ff_h263_update_motion_val(s);
653 ff_mpv_decode_mb(s, s->block);
655 ff_h263_loop_filter(s);
657 if (++s->mb_x == s->mb_width) {
660 ff_init_block_index(s);
662 if (s->mb_x == s->resync_mb_x)
663 s->first_slice_line = 0;
664 if (ret == SLICE_END)
668 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
671 return active_bits_size;
674 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
676 if (avctx->slice_count)
677 return avctx->slice_offset[n];
679 return AV_RL32(buf + n * 8);
682 static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
685 const uint8_t *buf = avpkt->data;
686 int buf_size = avpkt->size;
687 MpegEncContext *s = avctx->priv_data;
688 AVFrame *pict = data;
691 const uint8_t *slices_hdr = NULL;
693 ff_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
695 /* no supplementary picture */
700 if (!avctx->slice_count) {
701 slice_count = (*buf++) + 1;
704 if (!slice_count || buf_size <= 8 * slice_count) {
705 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",
707 return AVERROR_INVALIDDATA;
710 slices_hdr = buf + 4;
711 buf += 8 * slice_count;
712 buf_size -= 8 * slice_count;
714 slice_count = avctx->slice_count;
716 for (i = 0; i < slice_count; i++) {
717 unsigned offset = get_slice_offset(avctx, slices_hdr, i);
720 if (offset >= buf_size)
721 return AVERROR_INVALIDDATA;
723 if (i + 1 == slice_count)
724 size = buf_size - offset;
726 size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
728 if (i + 2 >= slice_count)
729 size2 = buf_size - offset;
731 size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
733 if (size <= 0 || size2 <= 0 ||
734 offset + FFMAX(size, size2) > buf_size)
735 return AVERROR_INVALIDDATA;
737 if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2)) < 0)
744 if (s->current_picture_ptr && s->mb_y >= s->mb_height) {
745 ff_er_frame_end(&s->er);
748 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
749 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
751 ff_print_debug_info(s, s->current_picture_ptr);
752 } else if (s->last_picture_ptr) {
753 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
755 ff_print_debug_info(s, s->last_picture_ptr);
758 if (s->last_picture_ptr || s->low_delay) {
762 // so we can detect if frame_end was not called (find some nicer solution...)
763 s->current_picture_ptr = NULL;
769 AVCodec ff_rv10_decoder = {
771 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
772 .type = AVMEDIA_TYPE_VIDEO,
773 .id = AV_CODEC_ID_RV10,
774 .priv_data_size = sizeof(RVDecContext),
775 .init = rv10_decode_init,
776 .close = rv10_decode_end,
777 .decode = rv10_decode_frame,
778 .capabilities = AV_CODEC_CAP_DR1,
779 .pix_fmts = (const enum AVPixelFormat[]) {
785 AVCodec ff_rv20_decoder = {
787 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
788 .type = AVMEDIA_TYPE_VIDEO,
789 .id = AV_CODEC_ID_RV20,
790 .priv_data_size = sizeof(RVDecContext),
791 .init = rv10_decode_init,
792 .close = rv10_decode_end,
793 .decode = rv10_decode_frame,
794 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
795 .flush = ff_mpeg_flush,
796 .pix_fmts = (const enum AVPixelFormat[]) {