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 "mpegvideo.h"
31 #include "mpeg4video.h"
36 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
37 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
38 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
40 #define DC_VLC_BITS 14 //FIXME find a better solution
42 typedef struct RVDecContext {
47 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] =
85 14, 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, 12, 12, 12, 12, 12, 12, 12,
93 12, 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, 10, 10, 10, 10, 10, 10, 10,
97 10, 8, 8, 8, 8, 8, 8, 8,
98 8, 8, 8, 8, 8, 8, 8, 8,
99 8, 7, 7, 7, 7, 7, 7, 7,
100 7, 6, 6, 6, 6, 5, 5, 4,
101 2, 4, 5, 5, 6, 6, 6, 6,
102 7, 7, 7, 7, 7, 7, 7, 7,
103 8, 8, 8, 8, 8, 8, 8, 8,
104 8, 8, 8, 8, 8, 8, 8, 8,
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 10, 10, 10, 10, 10, 10, 10, 10,
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,
116 12, 12, 12, 12, 12, 12, 12, 12,
119 static const uint16_t rv_chrom_code[256] =
121 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
122 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
123 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
124 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
125 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
126 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
127 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
128 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
129 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
130 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
131 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
132 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
133 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
134 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
135 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
136 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
137 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
138 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
139 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
140 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
141 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
142 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
143 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
144 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
145 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
146 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
147 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
148 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
149 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
150 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
151 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
152 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
155 static const uint8_t rv_chrom_bits[256] =
157 16, 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, 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, 12, 12, 12, 12, 12, 12, 12,
166 12, 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, 10, 10, 10, 10, 10, 10, 10,
170 10, 10, 10, 10, 10, 10, 10, 10,
171 10, 8, 8, 8, 8, 8, 8, 8,
172 8, 6, 6, 6, 6, 4, 4, 3,
173 2, 3, 4, 4, 6, 6, 6, 6,
174 8, 8, 8, 8, 8, 8, 8, 8,
175 10, 10, 10, 10, 10, 10, 10, 10,
176 10, 10, 10, 10, 10, 10, 10, 10,
177 12, 12, 12, 12, 12, 12, 12, 12,
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 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,
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,
191 static VLC rv_dc_lum, rv_dc_chrom;
193 int ff_rv_decode_dc(MpegEncContext *s, int n)
198 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
200 /* XXX: I don't understand why they use LONGER codes than
201 necessary. The following code would be completely useless
202 if they had thought about it !!! */
203 code = get_bits(&s->gb, 7);
205 code = (int8_t)(get_bits(&s->gb, 7) + 1);
206 } else if (code == 0x7d) {
207 code = -128 + get_bits(&s->gb, 7);
208 } else if (code == 0x7e) {
209 if (get_bits1(&s->gb) == 0)
210 code = (int8_t)(get_bits(&s->gb, 8) + 1);
212 code = (int8_t)(get_bits(&s->gb, 8));
213 } else if (code == 0x7f) {
214 skip_bits(&s->gb, 11);
221 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
224 code = get_bits(&s->gb, 9);
226 code = (int8_t)(get_bits(&s->gb, 7) + 1);
227 } else if (code == 0x1fd) {
228 code = -128 + get_bits(&s->gb, 7);
229 } else if (code == 0x1fe) {
230 skip_bits(&s->gb, 9);
233 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
243 /* read RV 1.0 compatible frame header */
244 static int rv10_decode_picture_header(MpegEncContext *s)
246 int mb_count, pb_frame, marker, mb_xy;
248 marker = get_bits1(&s->gb);
250 if (get_bits1(&s->gb))
251 s->pict_type = AV_PICTURE_TYPE_P;
253 s->pict_type = AV_PICTURE_TYPE_I;
254 if(!marker) 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 av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
264 s->qscale = get_bits(&s->gb, 5);
266 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
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;
307 GetBitContext gb= s->gb;
309 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
310 if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
312 av_log(s->avctx, AV_LOG_DEBUG, "\n");
315 av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
316 for(i=0; i<s->avctx->extradata_size; i++){
317 av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
318 if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
320 av_log(s->avctx, AV_LOG_DEBUG, "\n");
323 i= get_bits(&s->gb, 2);
325 case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
326 case 1: s->pict_type= AV_PICTURE_TYPE_I; break; //hmm ...
327 case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
328 case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
330 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
334 if(s->low_delay && s->pict_type==AV_PICTURE_TYPE_B){
335 av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
338 if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
339 av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
343 if (get_bits1(&s->gb)){
344 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
348 s->qscale = get_bits(&s->gb, 5);
350 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
354 if(RV_GET_MINOR_VER(rv->sub_id) >= 2)
355 s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
357 if(RV_GET_MINOR_VER(rv->sub_id) <= 1)
358 seq = get_bits(&s->gb, 8) << 7;
360 seq = get_bits(&s->gb, 13) << 2;
362 rpr_bits = s->avctx->extradata[1] & 7;
365 rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
367 f = get_bits(&s->gb, rpr_bits);
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= s->orig_width ;
374 new_h= s->orig_height;
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, "attempting to change resolution to %dx%d\n", new_w, new_h);
379 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
381 ff_MPV_common_end(s);
383 // attempt to keep aspect during typical resolution switches
385 old_aspect = (AVRational){1, 1};
386 if (2 * new_w * s->height == new_h * s->width)
387 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
388 if (new_w * s->height == 2 * new_h * s->width)
389 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
390 avcodec_set_dimensions(s->avctx, new_w, new_h);
393 if (ff_MPV_common_init(s) < 0)
397 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
398 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
401 if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
402 return AVERROR_INVALIDDATA;
404 mb_pos = ff_h263_decode_mba(s);
406 seq |= s->time &~0x7FFF;
407 if(seq - s->time > 0x4000) seq -= 0x8000;
408 if(seq - s->time < -0x4000) seq += 0x8000;
410 if(s->pict_type!=AV_PICTURE_TYPE_B){
412 s->pp_time= s->time - s->last_non_b_time;
413 s->last_non_b_time= s->time;
416 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
419 if (s->pict_type==AV_PICTURE_TYPE_B) {
420 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
421 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
422 return FRAME_SKIPPED;
424 ff_mpeg4_init_direct_mv(s);
427 s->no_rounding= get_bits1(&s->gb);
429 if(RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
430 skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
433 s->unrestricted_mv = 1;
434 s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
435 // s->alt_inter_vlc=1;
439 if(!s->avctx->lowres)
442 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
443 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
444 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
447 av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
449 return s->mb_width*s->mb_height - mb_pos;
452 static av_cold int rv10_decode_init(AVCodecContext *avctx)
454 RVDecContext *rv = avctx->priv_data;
455 MpegEncContext *s = &rv->m;
457 int major_ver, minor_ver, micro_ver;
459 if (avctx->extradata_size < 8) {
460 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
464 ff_MPV_decode_defaults(s);
467 s->out_format = FMT_H263;
468 s->codec_id= avctx->codec_id;
470 s->orig_width = s->width = avctx->coded_width;
471 s->orig_height= 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 av_log_missing_feature(avctx, "RV1/2 version", 1);
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, ((uint32_t*)avctx->extradata)[0]);
502 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
504 if (ff_MPV_common_init(s) < 0)
507 ff_h263_decode_init_vlc();
511 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
513 rv_lum_code, 2, 2, 16384);
514 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
516 rv_chrom_code, 2, 2, 16388);
523 static av_cold int rv10_decode_end(AVCodecContext *avctx)
525 MpegEncContext *s = avctx->priv_data;
527 ff_MPV_common_end(s);
531 static int rv10_decode_packet(AVCodecContext *avctx,
532 const uint8_t *buf, int buf_size, int buf_size2)
534 RVDecContext *rv = avctx->priv_data;
535 MpegEncContext *s = &rv->m;
536 int mb_count, mb_pos, left, start_mb_x, active_bits_size;
538 active_bits_size = buf_size * 8;
539 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
540 if(s->codec_id ==AV_CODEC_ID_RV10)
541 mb_count = rv10_decode_picture_header(s);
543 mb_count = rv20_decode_picture_header(rv);
545 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
549 if (s->mb_x >= s->mb_width ||
550 s->mb_y >= s->mb_height) {
551 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
554 mb_pos = s->mb_y * s->mb_width + s->mb_x;
555 left = s->mb_width * s->mb_height - mb_pos;
556 if (mb_count > left) {
557 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
561 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
562 if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
563 ff_er_frame_end(&s->er);
565 s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
567 if(ff_MPV_frame_start(s, avctx) < 0)
569 ff_mpeg_er_frame_start(s);
571 if (s->current_picture_ptr->f.pict_type != s->pict_type) {
572 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
578 av_dlog(avctx, "qscale=%d\n", s->qscale);
580 /* default quantization values */
581 if(s->codec_id== AV_CODEC_ID_RV10){
582 if(s->mb_y==0) s->first_slice_line=1;
584 s->first_slice_line=1;
585 s->resync_mb_x= s->mb_x;
588 s->resync_mb_y= s->mb_y;
591 s->c_dc_scale_table= ff_aic_dc_scale_table;
594 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
597 if(s->modified_quant)
598 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
600 ff_set_qscale(s, s->qscale);
602 s->rv10_first_dc_coded[0] = 0;
603 s->rv10_first_dc_coded[1] = 0;
604 s->rv10_first_dc_coded[2] = 0;
608 s->block_wrap[3]= s->b8_stride;
610 s->block_wrap[5]= s->mb_stride;
611 ff_init_block_index(s);
612 /* decode each macroblock */
614 for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
616 ff_update_block_index(s);
617 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
619 s->mv_dir = MV_DIR_FORWARD;
620 s->mv_type = MV_TYPE_16X16;
621 ret=ff_h263_decode_mb(s, s->block);
623 // Repeat the slice end check from ff_h263_decode_mb with our active
625 if (ret != SLICE_ERROR) {
626 int v = show_bits(&s->gb, 16);
628 if (get_bits_count(&s->gb) + 16 > active_bits_size)
629 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
634 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
635 8 * buf_size2 >= get_bits_count(&s->gb)) {
636 active_bits_size = buf_size2 * 8;
637 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
638 8 * buf_size, active_bits_size);
642 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
643 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
646 if(s->pict_type != AV_PICTURE_TYPE_B)
647 ff_h263_update_motion_val(s);
648 ff_MPV_decode_mb(s, s->block);
650 ff_h263_loop_filter(s);
652 if (++s->mb_x == s->mb_width) {
655 ff_init_block_index(s);
657 if(s->mb_x == s->resync_mb_x)
658 s->first_slice_line=0;
659 if(ret == SLICE_END) break;
662 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
664 return active_bits_size;
667 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
669 if(avctx->slice_count) return avctx->slice_offset[n];
670 else return AV_RL32(buf + n*8);
673 static int rv10_decode_frame(AVCodecContext *avctx,
674 void *data, int *got_frame,
677 const uint8_t *buf = avpkt->data;
678 int buf_size = avpkt->size;
679 MpegEncContext *s = avctx->priv_data;
681 AVFrame *pict = data;
683 const uint8_t *slices_hdr = NULL;
685 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
686 s->flags = avctx->flags;
687 s->flags2 = avctx->flags2;
689 /* no supplementary picture */
694 if(!avctx->slice_count){
695 slice_count = (*buf++) + 1;
698 if (!slice_count || buf_size <= 8 * slice_count) {
699 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
700 return AVERROR_INVALIDDATA;
703 slices_hdr = buf + 4;
704 buf += 8 * slice_count;
705 buf_size -= 8 * slice_count;
707 slice_count = avctx->slice_count;
709 for(i=0; i<slice_count; i++){
710 unsigned offset = get_slice_offset(avctx, slices_hdr, i);
713 if (offset >= buf_size)
714 return AVERROR_INVALIDDATA;
716 if(i+1 == slice_count)
717 size= buf_size - offset;
719 size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
721 if(i+2 >= slice_count)
722 size2= buf_size - offset;
724 size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
726 if (size <= 0 || size2 <= 0 ||
727 offset + FFMAX(size, size2) > buf_size)
728 return AVERROR_INVALIDDATA;
730 if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
734 if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
735 ff_er_frame_end(&s->er);
738 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
739 *pict = s->current_picture_ptr->f;
740 } else if (s->last_picture_ptr != NULL) {
741 *pict = s->last_picture_ptr->f;
744 if(s->last_picture_ptr || s->low_delay){
746 ff_print_debug_info(s, pict);
748 s->current_picture_ptr= NULL; // so we can detect if frame_end was not called (find some nicer solution...)
754 AVCodec ff_rv10_decoder = {
756 .type = AVMEDIA_TYPE_VIDEO,
757 .id = AV_CODEC_ID_RV10,
758 .priv_data_size = sizeof(RVDecContext),
759 .init = rv10_decode_init,
760 .close = rv10_decode_end,
761 .decode = rv10_decode_frame,
762 .capabilities = CODEC_CAP_DR1,
764 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
765 .pix_fmts = ff_pixfmt_list_420,
768 AVCodec ff_rv20_decoder = {
770 .type = AVMEDIA_TYPE_VIDEO,
771 .id = AV_CODEC_ID_RV20,
772 .priv_data_size = sizeof(RVDecContext),
773 .init = rv10_decode_init,
774 .close = rv10_decode_end,
775 .decode = rv10_decode_frame,
776 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
777 .flush = ff_mpeg_flush,
779 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
780 .pix_fmts = ff_pixfmt_list_420,