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"
31 #include "mpegvideo.h"
32 #include "mpeg4video.h"
37 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
38 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
39 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
41 #define DC_VLC_BITS 14 //FIXME find a better solution
43 typedef struct RVDecContext {
48 static const uint16_t rv_lum_code[256] =
50 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
51 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
52 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
53 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
54 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
55 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
56 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
57 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
58 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
59 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
60 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
61 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
62 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
63 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
64 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
65 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
66 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
67 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
68 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
69 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
70 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
71 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
72 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
73 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
74 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
75 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
76 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
77 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
78 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
79 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
80 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
81 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
84 static const uint8_t rv_lum_bits[256] =
86 14, 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, 12, 12, 12, 12, 12, 12, 12,
94 12, 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, 10, 10, 10, 10, 10, 10, 10,
98 10, 8, 8, 8, 8, 8, 8, 8,
99 8, 8, 8, 8, 8, 8, 8, 8,
100 8, 7, 7, 7, 7, 7, 7, 7,
101 7, 6, 6, 6, 6, 5, 5, 4,
102 2, 4, 5, 5, 6, 6, 6, 6,
103 7, 7, 7, 7, 7, 7, 7, 7,
104 8, 8, 8, 8, 8, 8, 8, 8,
105 8, 8, 8, 8, 8, 8, 8, 8,
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 10, 10, 10, 10, 10, 10, 10, 10,
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,
117 12, 12, 12, 12, 12, 12, 12, 12,
120 static const uint16_t rv_chrom_code[256] =
122 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
123 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
124 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
125 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
126 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
127 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
128 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
129 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
130 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
131 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
132 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
133 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
134 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
135 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
136 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
137 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
138 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
139 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
140 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
141 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
142 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
143 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
144 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
145 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
146 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
147 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
148 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
149 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
150 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
151 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
152 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
153 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
156 static 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,
192 static VLC rv_dc_lum, rv_dc_chrom;
194 int ff_rv_decode_dc(MpegEncContext *s, int n)
199 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
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);
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);
213 code = (int8_t)(get_bits(&s->gb, 8));
214 } else if (code == 0x7f) {
215 skip_bits(&s->gb, 11);
222 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
225 code = get_bits(&s->gb, 9);
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);
234 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
244 /* read RV 1.0 compatible frame header */
245 static int rv10_decode_picture_header(MpegEncContext *s)
247 int mb_count, pb_frame, marker, mb_xy;
249 marker = get_bits1(&s->gb);
251 if (get_bits1(&s->gb))
252 s->pict_type = AV_PICTURE_TYPE_P;
254 s->pict_type = AV_PICTURE_TYPE_I;
255 if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
256 pb_frame = get_bits1(&s->gb);
258 av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
261 av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
265 s->qscale = get_bits(&s->gb, 5);
267 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
271 if (s->pict_type == AV_PICTURE_TYPE_I) {
272 if (s->rv10_version == 3) {
273 /* specific MPEG like DC coding not used */
274 s->last_dc[0] = get_bits(&s->gb, 8);
275 s->last_dc[1] = get_bits(&s->gb, 8);
276 s->last_dc[2] = get_bits(&s->gb, 8);
277 av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
278 s->last_dc[1], s->last_dc[2]);
281 /* if multiple packets per frame are sent, the position at which
282 to display the macroblocks is coded here */
284 mb_xy= s->mb_x + s->mb_y*s->mb_width;
285 if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
286 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
287 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
288 mb_count = get_bits(&s->gb, 12);
292 mb_count = s->mb_width * s->mb_height;
294 skip_bits(&s->gb, 3); /* ignored */
296 s->unrestricted_mv = 1;
301 static int rv20_decode_picture_header(RVDecContext *rv)
303 MpegEncContext *s = &rv->m;
308 GetBitContext gb= s->gb;
310 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
311 if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
313 av_log(s->avctx, AV_LOG_DEBUG, "\n");
316 av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
317 for(i=0; i<s->avctx->extradata_size; i++){
318 av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
319 if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
321 av_log(s->avctx, AV_LOG_DEBUG, "\n");
324 i= get_bits(&s->gb, 2);
326 case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
327 case 1: s->pict_type= AV_PICTURE_TYPE_I; break; //hmm ...
328 case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
329 case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
331 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
335 if(s->low_delay && s->pict_type==AV_PICTURE_TYPE_B){
336 av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
339 if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
340 av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
344 if (get_bits1(&s->gb)){
345 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
349 s->qscale = get_bits(&s->gb, 5);
351 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
355 if(RV_GET_MINOR_VER(rv->sub_id) >= 2)
356 s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
358 if(RV_GET_MINOR_VER(rv->sub_id) <= 1)
359 seq = get_bits(&s->gb, 8) << 7;
361 seq = get_bits(&s->gb, 13) << 2;
363 rpr_bits = s->avctx->extradata[1] & 7;
366 rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
368 f = get_bits(&s->gb, rpr_bits);
371 new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
372 new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
374 new_w= s->orig_width ;
375 new_h= s->orig_height;
377 if(new_w != s->width || new_h != s->height){
378 AVRational old_aspect = s->avctx->sample_aspect_ratio;
379 av_log(s->avctx, AV_LOG_DEBUG, "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)
382 ff_MPV_common_end(s);
384 // attempt to keep aspect during typical resolution switches
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 avcodec_set_dimensions(s->avctx, new_w, new_h);
394 if (ff_MPV_common_init(s) < 0)
398 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
399 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
402 if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
403 return AVERROR_INVALIDDATA;
405 mb_pos = ff_h263_decode_mba(s);
407 seq |= s->time &~0x7FFF;
408 if(seq - s->time > 0x4000) seq -= 0x8000;
409 if(seq - s->time < -0x4000) seq += 0x8000;
411 if(s->pict_type!=AV_PICTURE_TYPE_B){
413 s->pp_time= s->time - s->last_non_b_time;
414 s->last_non_b_time= s->time;
417 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
420 if (s->pict_type==AV_PICTURE_TYPE_B) {
421 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
422 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
423 return FRAME_SKIPPED;
425 ff_mpeg4_init_direct_mv(s);
428 s->no_rounding= get_bits1(&s->gb);
430 if(RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
431 skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
434 s->unrestricted_mv = 1;
435 s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
436 // s->alt_inter_vlc=1;
440 if(!s->avctx->lowres)
443 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
444 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
445 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
448 av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
450 return s->mb_width*s->mb_height - mb_pos;
453 static av_cold int rv10_decode_init(AVCodecContext *avctx)
455 RVDecContext *rv = avctx->priv_data;
456 MpegEncContext *s = &rv->m;
458 int major_ver, minor_ver, micro_ver;
460 if (avctx->extradata_size < 8) {
461 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
465 ff_MPV_decode_defaults(s);
468 s->out_format = FMT_H263;
469 s->codec_id= avctx->codec_id;
471 s->orig_width = s->width = avctx->coded_width;
472 s->orig_height= s->height = avctx->coded_height;
474 s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
475 rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
477 major_ver = RV_GET_MAJOR_VER(rv->sub_id);
478 minor_ver = RV_GET_MINOR_VER(rv->sub_id);
479 micro_ver = RV_GET_MICRO_VER(rv->sub_id);
484 s->rv10_version = micro_ver ? 3 : 1;
485 s->obmc = micro_ver == 2;
488 if (minor_ver >= 2) {
490 s->avctx->has_b_frames = 1;
494 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
495 av_log_missing_feature(avctx, "RV1/2 version", 1);
496 return AVERROR_PATCHWELCOME;
499 if(avctx->debug & FF_DEBUG_PICT_INFO){
500 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id, ((uint32_t*)avctx->extradata)[0]);
503 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
505 if (ff_MPV_common_init(s) < 0)
508 ff_h263_decode_init_vlc();
512 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
514 rv_lum_code, 2, 2, 16384);
515 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
517 rv_chrom_code, 2, 2, 16388);
524 static av_cold int rv10_decode_end(AVCodecContext *avctx)
526 MpegEncContext *s = avctx->priv_data;
528 ff_MPV_common_end(s);
532 static int rv10_decode_packet(AVCodecContext *avctx,
533 const uint8_t *buf, int buf_size, int buf_size2)
535 RVDecContext *rv = avctx->priv_data;
536 MpegEncContext *s = &rv->m;
537 int mb_count, mb_pos, left, start_mb_x, active_bits_size;
539 active_bits_size = buf_size * 8;
540 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
541 if(s->codec_id ==AV_CODEC_ID_RV10)
542 mb_count = rv10_decode_picture_header(s);
544 mb_count = rv20_decode_picture_header(rv);
546 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
550 if (s->mb_x >= s->mb_width ||
551 s->mb_y >= s->mb_height) {
552 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
555 mb_pos = s->mb_y * s->mb_width + s->mb_x;
556 left = s->mb_width * s->mb_height - mb_pos;
557 if (mb_count > left) {
558 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
562 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
563 if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
564 ff_er_frame_end(&s->er);
566 s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
568 if(ff_MPV_frame_start(s, avctx) < 0)
570 ff_mpeg_er_frame_start(s);
572 if (s->current_picture_ptr->f.pict_type != s->pict_type) {
573 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
579 av_dlog(avctx, "qscale=%d\n", s->qscale);
581 /* default quantization values */
582 if(s->codec_id== AV_CODEC_ID_RV10){
583 if(s->mb_y==0) s->first_slice_line=1;
585 s->first_slice_line=1;
586 s->resync_mb_x= s->mb_x;
589 s->resync_mb_y= s->mb_y;
592 s->c_dc_scale_table= ff_aic_dc_scale_table;
595 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
598 if(s->modified_quant)
599 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
601 ff_set_qscale(s, s->qscale);
603 s->rv10_first_dc_coded[0] = 0;
604 s->rv10_first_dc_coded[1] = 0;
605 s->rv10_first_dc_coded[2] = 0;
609 s->block_wrap[3]= s->b8_stride;
611 s->block_wrap[5]= s->mb_stride;
612 ff_init_block_index(s);
613 /* decode each macroblock */
615 for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
617 ff_update_block_index(s);
618 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
620 s->mv_dir = MV_DIR_FORWARD;
621 s->mv_type = MV_TYPE_16X16;
622 ret=ff_h263_decode_mb(s, s->block);
624 // Repeat the slice end check from ff_h263_decode_mb with our active
626 if (ret != SLICE_ERROR) {
627 int v = show_bits(&s->gb, 16);
629 if (get_bits_count(&s->gb) + 16 > active_bits_size)
630 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
635 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
636 8 * buf_size2 >= get_bits_count(&s->gb)) {
637 active_bits_size = buf_size2 * 8;
638 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
639 8 * buf_size, active_bits_size);
643 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
644 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
647 if(s->pict_type != AV_PICTURE_TYPE_B)
648 ff_h263_update_motion_val(s);
649 ff_MPV_decode_mb(s, s->block);
651 ff_h263_loop_filter(s);
653 if (++s->mb_x == s->mb_width) {
656 ff_init_block_index(s);
658 if(s->mb_x == s->resync_mb_x)
659 s->first_slice_line=0;
660 if(ret == SLICE_END) break;
663 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
665 return active_bits_size;
668 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
670 if(avctx->slice_count) return avctx->slice_offset[n];
671 else return AV_RL32(buf + n*8);
674 static int rv10_decode_frame(AVCodecContext *avctx,
675 void *data, int *got_frame,
678 const uint8_t *buf = avpkt->data;
679 int buf_size = avpkt->size;
680 MpegEncContext *s = avctx->priv_data;
682 AVFrame *pict = data;
684 const uint8_t *slices_hdr = NULL;
686 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
687 s->flags = avctx->flags;
688 s->flags2 = avctx->flags2;
690 /* no supplementary picture */
695 if(!avctx->slice_count){
696 slice_count = (*buf++) + 1;
699 if (!slice_count || buf_size <= 8 * slice_count) {
700 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
701 return AVERROR_INVALIDDATA;
704 slices_hdr = buf + 4;
705 buf += 8 * slice_count;
706 buf_size -= 8 * slice_count;
708 slice_count = avctx->slice_count;
710 for(i=0; i<slice_count; i++){
711 unsigned offset = get_slice_offset(avctx, slices_hdr, i);
714 if (offset >= buf_size)
715 return AVERROR_INVALIDDATA;
717 if(i+1 == slice_count)
718 size= buf_size - offset;
720 size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
722 if(i+2 >= slice_count)
723 size2= buf_size - offset;
725 size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
727 if (size <= 0 || size2 <= 0 ||
728 offset + FFMAX(size, size2) > buf_size)
729 return AVERROR_INVALIDDATA;
731 if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
735 if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
736 ff_er_frame_end(&s->er);
739 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
740 *pict = s->current_picture_ptr->f;
741 } else if (s->last_picture_ptr != NULL) {
742 *pict = s->last_picture_ptr->f;
745 if(s->last_picture_ptr || s->low_delay){
747 ff_print_debug_info(s, pict);
749 s->current_picture_ptr= NULL; // so we can detect if frame_end was not called (find some nicer solution...)
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,