repositories / deb_ffmpeg.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Debian version 2.4.3~trusty1
[deb_ffmpeg.git] / ffmpeg / libavcodec / rv10.c
CommitLineData
2ba45a60
DM		 1/*
2 * RV10/RV20 decoder
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer
5 *
6 * This file is part of FFmpeg.
7 *
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.
12 *
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.
17 *
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
21 */
22
23/**
24 * @file
25 * RV10/RV20 decoder
26 */
27
28#include <inttypes.h>
29
30#include "libavutil/imgutils.h"
31
32#include "avcodec.h"
33#include "error_resilience.h"
34#include "h263.h"
35#include "internal.h"
36#include "mpeg_er.h"
37#include "mpegvideo.h"
38#include "mpeg4video.h"
39
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)
43
44#define DC_VLC_BITS 14 // FIXME find a better solution
45
46typedef struct RVDecContext {
47 MpegEncContext m;
48 int sub_id;
49 int orig_width, orig_height;
50} RVDecContext;
51
52static const uint16_t rv_lum_code[256] = {
53 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
54 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
55 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
56 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
57 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
58 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
59 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
60 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
61 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
62 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
63 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
64 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
65 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
66 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
67 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
68 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
69 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
70 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
71 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
72 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
73 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
74 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
75 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
76 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
77 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
78 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
79 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
80 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
81 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
82 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
83 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
84 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
85};
86
87static const uint8_t rv_lum_bits[256] = {
88 14, 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, 12, 12, 12, 12, 12, 12, 12,
96 12, 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, 10, 10, 10, 10, 10, 10, 10,
100 10, 8, 8, 8, 8, 8, 8, 8,
101 8, 8, 8, 8, 8, 8, 8, 8,
102 8, 7, 7, 7, 7, 7, 7, 7,
103 7, 6, 6, 6, 6, 5, 5, 4,
104 2, 4, 5, 5, 6, 6, 6, 6,
105 7, 7, 7, 7, 7, 7, 7, 7,
106 8, 8, 8, 8, 8, 8, 8, 8,
107 8, 8, 8, 8, 8, 8, 8, 8,
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 10, 10, 10, 10, 10, 10, 10, 10,
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,
119 12, 12, 12, 12, 12, 12, 12, 12,
120};
121
122static const uint16_t rv_chrom_code[256] = {
123 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
124 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
125 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
126 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
127 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
128 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
129 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
130 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
131 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
132 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
133 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
134 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
135 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
136 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
137 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
138 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
139 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
140 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
141 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
142 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
143 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
144 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
145 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
146 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
147 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
148 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
149 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
150 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
151 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
152 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
153 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
154 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
155};
156
157static const uint8_t rv_chrom_bits[256] = {
158 16, 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, 14, 14, 14, 14, 14, 14, 14,
166 14, 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, 12, 12, 12, 12, 12, 12, 12,
170 12, 10, 10, 10, 10, 10, 10, 10,
171 10, 10, 10, 10, 10, 10, 10, 10,
172 10, 8, 8, 8, 8, 8, 8, 8,
173 8, 6, 6, 6, 6, 4, 4, 3,
174 2, 3, 4, 4, 6, 6, 6, 6,
175 8, 8, 8, 8, 8, 8, 8, 8,
176 10, 10, 10, 10, 10, 10, 10, 10,
177 10, 10, 10, 10, 10, 10, 10, 10,
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 12, 12, 12, 12, 12, 12, 12, 12,
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,
189 14, 14, 14, 14, 14, 14, 14, 14,
190};
191
192static VLC rv_dc_lum, rv_dc_chrom;
193
194int ff_rv_decode_dc(MpegEncContext *s, int n)
195{
196 int code;
197
198 if (n < 4) {
199 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
200 if (code < 0) {
201 /* XXX: I don't understand why they use LONGER codes than
202 * necessary. The following code would be completely useless
203 * if they had thought about it !!! */
204 code = get_bits(&s->gb, 7);
205 if (code == 0x7c) {
206 code = (int8_t) (get_bits(&s->gb, 7) + 1);
207 } else if (code == 0x7d) {
208 code = -128 + get_bits(&s->gb, 7);
209 } else if (code == 0x7e) {
210 if (get_bits1(&s->gb) == 0)
211 code = (int8_t) (get_bits(&s->gb, 8) + 1);
212 else
213 code = (int8_t) (get_bits(&s->gb, 8));
214 } else if (code == 0x7f) {
215 skip_bits(&s->gb, 11);
216 code = 1;
217 }
218 } else {
219 code -= 128;
220 }
221 } else {
222 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
223 /* same remark */
224 if (code < 0) {
225 code = get_bits(&s->gb, 9);
226 if (code == 0x1fc) {
227 code = (int8_t) (get_bits(&s->gb, 7) + 1);
228 } else if (code == 0x1fd) {
229 code = -128 + get_bits(&s->gb, 7);
230 } else if (code == 0x1fe) {
231 skip_bits(&s->gb, 9);
232 code = 1;
233 } else {
234 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
235 return 0xffff;
236 }
237 } else {
238 code -= 128;
239 }
240 }
241 return -code;
242}
243
244/* read RV 1.0 compatible frame header */
245static int rv10_decode_picture_header(MpegEncContext *s)
246{
247 int mb_count, pb_frame, marker, mb_xy;
248
249 marker = get_bits1(&s->gb);
250
251 if (get_bits1(&s->gb))
252 s->pict_type = AV_PICTURE_TYPE_P;
253 else
254 s->pict_type = AV_PICTURE_TYPE_I;
255
256 if (!marker)
257 av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
258
259 pb_frame = get_bits1(&s->gb);
260
261 av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
262
263 if (pb_frame) {
264 avpriv_request_sample(s->avctx, "pb frame");
265 return AVERROR_PATCHWELCOME;
266 }
267
268 s->qscale = get_bits(&s->gb, 5);
269 if (s->qscale == 0) {
270 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
271 return AVERROR_INVALIDDATA;
272 }
273
274 if (s->pict_type == AV_PICTURE_TYPE_I) {
275 if (s->rv10_version == 3) {
276 /* specific MPEG like DC coding not used */
277 s->last_dc[0] = get_bits(&s->gb, 8);
278 s->last_dc[1] = get_bits(&s->gb, 8);
279 s->last_dc[2] = get_bits(&s->gb, 8);
280 av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
281 s->last_dc[1], s->last_dc[2]);
282 }
283 }
284 /* if multiple packets per frame are sent, the position at which
285 * to display the macroblocks is coded here */
286
287 mb_xy = s->mb_x + s->mb_y * s->mb_width;
288 if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
289 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
290 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
291 mb_count = get_bits(&s->gb, 12);
292 } else {
293 s->mb_x = 0;
294 s->mb_y = 0;
295 mb_count = s->mb_width * s->mb_height;
296 }
297 skip_bits(&s->gb, 3); /* ignored */
298 s->f_code = 1;
299 s->unrestricted_mv = 1;
300
301 return mb_count;
302}
303
304static int rv20_decode_picture_header(RVDecContext *rv)
305{
306 MpegEncContext *s = &rv->m;
307 int seq, mb_pos, i, ret;
308 int rpr_max;
309
310 i = get_bits(&s->gb, 2);
311 switch (i) {
312 case 0:
313 s->pict_type = AV_PICTURE_TYPE_I;
314 break;
315 case 1:
316 s->pict_type = AV_PICTURE_TYPE_I;
317 break; // hmm ...
318 case 2:
319 s->pict_type = AV_PICTURE_TYPE_P;
320 break;
321 case 3:
322 s->pict_type = AV_PICTURE_TYPE_B;
323 break;
324 default:
325 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
326 return AVERROR_INVALIDDATA;
327 }
328
329 if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
330 av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
331 return -1;
332 }
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;
336 }
337
338 if (get_bits1(&s->gb)) {
339 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
340 return AVERROR_INVALIDDATA;
341 }
342
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;
347 }
348
349 if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
350 s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
351
352 if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
353 seq = get_bits(&s->gb, 8) << 7;
354 else
355 seq = get_bits(&s->gb, 13) << 2;
356
357 rpr_max = s->avctx->extradata[1] & 7;
358 if (rpr_max) {
359 int f, new_w, new_h;
360 int rpr_bits = av_log2(rpr_max) + 1;
361
362 f = get_bits(&s->gb, rpr_bits);
363
364 if (f) {
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;
368 }
369
370 new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];
371 new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];
372 } else {
373 new_w = rv->orig_width;
374 new_h = rv->orig_height;
375 }
376 if (new_w != s->width || new_h != s->height) {
377 AVRational old_aspect = s->avctx->sample_aspect_ratio;
378 av_log(s->avctx, AV_LOG_DEBUG,
379 "attempting to change resolution to %dx%d\n", new_w, new_h);
380 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
381 return AVERROR_INVALIDDATA;
382 ff_mpv_common_end(s);
383
384 // attempt to keep aspect during typical resolution switches
385 if (!old_aspect.num)
386 old_aspect = (AVRational){1, 1};
387 if (2 * new_w * s->height == new_h * s->width)
388 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
389 if (new_w * s->height == 2 * new_h * s->width)
390 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
391
392 ret = ff_set_dimensions(s->avctx, new_w, new_h);
393 if (ret < 0)
394 return ret;
395
396 s->width = new_w;
397 s->height = new_h;
398 if ((ret = ff_mpv_common_init(s)) < 0)
399 return ret;
400 }
401
402 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
403 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max);
404 }
405 }
406 if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
407 return AVERROR_INVALIDDATA;
408
409 mb_pos = ff_h263_decode_mba(s);
410
411 seq |= s->time & ~0x7FFF;
412 if (seq - s->time > 0x4000)
413 seq -= 0x8000;
414 if (seq - s->time < -0x4000)
415 seq += 0x8000;
416
417 if (seq != s->time) {
418 if (s->pict_type != AV_PICTURE_TYPE_B) {
419 s->time = seq;
420 s->pp_time = s->time - s->last_non_b_time;
421 s->last_non_b_time = s->time;
422 } else {
423 s->time = seq;
424 s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
425 }
426 }
427 if (s->pict_type == AV_PICTURE_TYPE_B) {
428 if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
429 av_log(s->avctx, AV_LOG_DEBUG,
430 "messed up order, possible from seeking? skipping current b frame\n");
431#define ERROR_SKIP_FRAME -123
432 return ERROR_SKIP_FRAME;
433 }
434 ff_mpeg4_init_direct_mv(s);
435 }
436
437 s->no_rounding = get_bits1(&s->gb);
438
439 if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
440 // binary decoder reads 3+2 bits here but they don't seem to be used
441 skip_bits(&s->gb, 5);
442
443 s->f_code = 1;
444 s->unrestricted_mv = 1;
445 s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;
446 s->modified_quant = 1;
447 if (!s->avctx->lowres)
448 s->loop_filter = 1;
449
450 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
451 av_log(s->avctx, AV_LOG_INFO,
452 "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
453 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,
454 s->no_rounding);
455 }
456
457 av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
458
459 return s->mb_width * s->mb_height - mb_pos;
460}
461
462static av_cold int rv10_decode_init(AVCodecContext *avctx)
463{
464 RVDecContext *rv = avctx->priv_data;
465 MpegEncContext *s = &rv->m;
466 static int done = 0;
467 int major_ver, minor_ver, micro_ver, ret;
468
469 if (avctx->extradata_size < 8) {
470 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
471 return AVERROR_INVALIDDATA;
472 }
473 if ((ret = av_image_check_size(avctx->coded_width,
474 avctx->coded_height, 0, avctx)) < 0)
475 return ret;
476
477 ff_mpv_decode_defaults(s);
478 ff_mpv_decode_init(s, avctx);
479
480 s->out_format = FMT_H263;
481
482 rv->orig_width =
483 s->width = avctx->coded_width;
484 rv->orig_height =
485 s->height = avctx->coded_height;
486
487 s->h263_long_vectors = ((uint8_t *) avctx->extradata)[3] & 1;
488 rv->sub_id = AV_RB32((uint8_t *) avctx->extradata + 4);
489
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);
493
494 s->low_delay = 1;
495 switch (major_ver) {
496 case 1:
497 s->rv10_version = micro_ver ? 3 : 1;
498 s->obmc = micro_ver == 2;
499 break;
500 case 2:
501 if (minor_ver >= 2) {
502 s->low_delay = 0;
503 s->avctx->has_b_frames = 1;
504 }
505 break;
506 default:
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;
510 }
511
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]);
515 }
516
517 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
518
519 ff_mpv_idct_init(s);
520 if ((ret = ff_mpv_common_init(s)) < 0)
521 return ret;
522
523 ff_h263dsp_init(&s->h263dsp);
524 ff_h263_decode_init_vlc();
525
526 /* init rv vlc */
527 if (!done) {
528 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
529 rv_lum_bits, 1, 1,
530 rv_lum_code, 2, 2, 16384);
531 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
532 rv_chrom_bits, 1, 1,
533 rv_chrom_code, 2, 2, 16388);
534 done = 1;
535 }
536
537 return 0;
538}
539
540static av_cold int rv10_decode_end(AVCodecContext *avctx)
541{
542 MpegEncContext *s = avctx->priv_data;
543
544 ff_mpv_common_end(s);
545 return 0;
546}
547
548static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
549 int buf_size, int buf_size2)
550{
551 RVDecContext *rv = avctx->priv_data;
552 MpegEncContext *s = &rv->m;
553 int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
554
555 active_bits_size = buf_size * 8;
556 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
557 if (s->codec_id == AV_CODEC_ID_RV10)
558 mb_count = rv10_decode_picture_header(s);
559 else
560 mb_count = rv20_decode_picture_header(rv);
561 if (mb_count < 0) {
562 if (mb_count != ERROR_SKIP_FRAME)
563 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
564 return AVERROR_INVALIDDATA;
565 }
566
567 if (s->mb_x >= s->mb_width ||
568 s->mb_y >= s->mb_height) {
569 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
570 return AVERROR_INVALIDDATA;
571 }
572 mb_pos = s->mb_y * s->mb_width + s->mb_x;
573 left = s->mb_width * s->mb_height - mb_pos;
574 if (mb_count > left) {
575 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
576 return AVERROR_INVALIDDATA;
577 }
578
579 if ((s->mb_x == 0 && s->mb_y == 0) || !s->current_picture_ptr) {
580 // FIXME write parser so we always have complete frames?
581 if (s->current_picture_ptr) {
582 ff_er_frame_end(&s->er);
583 ff_mpv_frame_end(s);
584 s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
585 }
586 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
587 return ret;
588 ff_mpeg_er_frame_start(s);
589 } else {
590 if (s->current_picture_ptr->f->pict_type != s->pict_type) {
591 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
592 return AVERROR_INVALIDDATA;
593 }
594 }
595
596
597 av_dlog(avctx, "qscale=%d\n", s->qscale);
598
599 /* default quantization values */
600 if (s->codec_id == AV_CODEC_ID_RV10) {
601 if (s->mb_y == 0)
602 s->first_slice_line = 1;
603 } else {
604 s->first_slice_line = 1;
605 s->resync_mb_x = s->mb_x;
606 }
607 start_mb_x = s->mb_x;
608 s->resync_mb_y = s->mb_y;
609 if (s->h263_aic) {
610 s->y_dc_scale_table =
611 s->c_dc_scale_table = ff_aic_dc_scale_table;
612 } else {
613 s->y_dc_scale_table =
614 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
615 }
616
617 if (s->modified_quant)
618 s->chroma_qscale_table = ff_h263_chroma_qscale_table;
619
620 ff_set_qscale(s, s->qscale);
621
622 s->rv10_first_dc_coded[0] = 0;
623 s->rv10_first_dc_coded[1] = 0;
624 s->rv10_first_dc_coded[2] = 0;
625 s->block_wrap[0] =
626 s->block_wrap[1] =
627 s->block_wrap[2] =
628 s->block_wrap[3] = s->b8_stride;
629 s->block_wrap[4] =
630 s->block_wrap[5] = s->mb_stride;
631 ff_init_block_index(s);
632
633 /* decode each macroblock */
634 for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
635 int ret;
636 ff_update_block_index(s);
637 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
638
639 s->mv_dir = MV_DIR_FORWARD;
640 s->mv_type = MV_TYPE_16X16;
641 ret = ff_h263_decode_mb(s, s->block);
642
643 // Repeat the slice end check from ff_h263_decode_mb with our active
644 // bitstream size
645 if (ret != SLICE_ERROR) {
646 int v = show_bits(&s->gb, 16);
647
648 if (get_bits_count(&s->gb) + 16 > active_bits_size)
649 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
650
651 if (!v)
652 ret = SLICE_END;
653 }
654 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
655 8 * buf_size2 >= get_bits_count(&s->gb)) {
656 active_bits_size = buf_size2 * 8;
657 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
658 8 * buf_size, active_bits_size);
659 ret = SLICE_OK;
660 }
661
662 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
663 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
664 s->mb_y);
665 return AVERROR_INVALIDDATA;
666 }
667 if (s->pict_type != AV_PICTURE_TYPE_B)
668 ff_h263_update_motion_val(s);
669 ff_mpv_decode_mb(s, s->block);
670 if (s->loop_filter)
671 ff_h263_loop_filter(s);
672
673 if (++s->mb_x == s->mb_width) {
674 s->mb_x = 0;
675 s->mb_y++;
676 ff_init_block_index(s);
677 }
678 if (s->mb_x == s->resync_mb_x)
679 s->first_slice_line = 0;
680 if (ret == SLICE_END)
681 break;
682 }
683
684 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
685 ER_MB_END);
686
687 return active_bits_size;
688}
689
690static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
691{
692 if (avctx->slice_count)
693 return avctx->slice_offset[n];
694 else
695 return AV_RL32(buf + n * 8);
696}
697
698static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
699 AVPacket *avpkt)
700{
701 const uint8_t *buf = avpkt->data;
702 int buf_size = avpkt->size;
703 MpegEncContext *s = avctx->priv_data;
704 AVFrame *pict = data;
705 int i, ret;
706 int slice_count;
707 const uint8_t *slices_hdr = NULL;
708
709 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
710 s->flags = avctx->flags;
711 s->flags2 = avctx->flags2;
712
713 /* no supplementary picture */
714 if (buf_size == 0) {
715 return 0;
716 }
717
718 if (!avctx->slice_count) {
719 slice_count = (*buf++) + 1;
720 buf_size--;
721
722 if (!slice_count || buf_size <= 8 * slice_count) {
723 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",
724 slice_count);
725 return AVERROR_INVALIDDATA;
726 }
727
728 slices_hdr = buf + 4;
729 buf += 8 * slice_count;
730 buf_size -= 8 * slice_count;
731 } else
732 slice_count = avctx->slice_count;
733
734 for (i = 0; i < slice_count; i++) {
735 unsigned offset = get_slice_offset(avctx, slices_hdr, i);
736 int size, size2;
737
738 if (offset >= buf_size)
739 return AVERROR_INVALIDDATA;
740
741 if (i + 1 == slice_count)
742 size = buf_size - offset;
743 else
744 size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
745
746 if (i + 2 >= slice_count)
747 size2 = buf_size - offset;
748 else
749 size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
750
751 if (size <= 0 || size2 <= 0 ||
752 offset + FFMAX(size, size2) > buf_size)
753 return AVERROR_INVALIDDATA;
754
755 if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2)) < 0)
756 return ret;
757
758 if (ret > 8 * size)
759 i++;
760 }
761
762 if (s->current_picture_ptr && s->mb_y >= s->mb_height) {
763 ff_er_frame_end(&s->er);
764 ff_mpv_frame_end(s);
765
766 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
767 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
768 return ret;
769 ff_print_debug_info(s, s->current_picture_ptr, pict);
770 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
771 } else if (s->last_picture_ptr) {
772 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
773 return ret;
774 ff_print_debug_info(s, s->last_picture_ptr, pict);
775 ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
776 }
777
778 if (s->last_picture_ptr || s->low_delay) {
779 *got_frame = 1;
780 }
781
782 // so we can detect if frame_end was not called (find some nicer solution...)
783 s->current_picture_ptr = NULL;
784 }
785
786 return avpkt->size;
787}
788
789AVCodec ff_rv10_decoder = {
790 .name = "rv10",
791 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
792 .type = AVMEDIA_TYPE_VIDEO,
793 .id = AV_CODEC_ID_RV10,
794 .priv_data_size = sizeof(RVDecContext),
795 .init = rv10_decode_init,
796 .close = rv10_decode_end,
797 .decode = rv10_decode_frame,
798 .capabilities = CODEC_CAP_DR1,
799 .max_lowres = 3,
800 .pix_fmts = (const enum AVPixelFormat[]) {
801 AV_PIX_FMT_YUV420P,
802 AV_PIX_FMT_NONE
803 },
804};
805
806AVCodec ff_rv20_decoder = {
807 .name = "rv20",
808 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
809 .type = AVMEDIA_TYPE_VIDEO,
810 .id = AV_CODEC_ID_RV20,
811 .priv_data_size = sizeof(RVDecContext),
812 .init = rv10_decode_init,
813 .close = rv10_decode_end,
814 .decode = rv10_decode_frame,
815 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
816 .flush = ff_mpeg_flush,
817 .max_lowres = 3,
818 .pix_fmts = (const enum AVPixelFormat[]) {
819 AV_PIX_FMT_YUV420P,
820 AV_PIX_FMT_NONE
821 },
822};
ffmpeg Piment Noir Debian package repository