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 DC_VLC_BITS 14 //FIXME find a better solution
39 static const uint16_t rv_lum_code[256] =
41 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
42 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
43 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
44 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
45 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
46 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
47 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
48 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
49 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
50 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
51 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
52 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
53 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
54 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
55 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
56 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
57 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
58 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
59 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
60 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
61 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
62 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
63 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
64 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
65 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
66 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
67 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
68 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
69 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
70 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
71 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
72 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
75 static const uint8_t rv_lum_bits[256] =
77 14, 12, 12, 12, 12, 12, 12, 12,
78 12, 12, 12, 12, 12, 12, 12, 12,
79 12, 12, 12, 12, 12, 12, 12, 12,
80 12, 12, 12, 12, 12, 12, 12, 12,
81 12, 12, 12, 12, 12, 12, 12, 12,
82 12, 12, 12, 12, 12, 12, 12, 12,
83 12, 12, 12, 12, 12, 12, 12, 12,
84 12, 12, 12, 12, 12, 12, 12, 12,
85 12, 10, 10, 10, 10, 10, 10, 10,
86 10, 10, 10, 10, 10, 10, 10, 10,
87 10, 10, 10, 10, 10, 10, 10, 10,
88 10, 10, 10, 10, 10, 10, 10, 10,
89 10, 8, 8, 8, 8, 8, 8, 8,
90 8, 8, 8, 8, 8, 8, 8, 8,
91 8, 7, 7, 7, 7, 7, 7, 7,
92 7, 6, 6, 6, 6, 5, 5, 4,
93 2, 4, 5, 5, 6, 6, 6, 6,
94 7, 7, 7, 7, 7, 7, 7, 7,
95 8, 8, 8, 8, 8, 8, 8, 8,
96 8, 8, 8, 8, 8, 8, 8, 8,
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, 10, 10, 10, 10, 10, 10, 10,
101 12, 12, 12, 12, 12, 12, 12, 12,
102 12, 12, 12, 12, 12, 12, 12, 12,
103 12, 12, 12, 12, 12, 12, 12, 12,
104 12, 12, 12, 12, 12, 12, 12, 12,
105 12, 12, 12, 12, 12, 12, 12, 12,
106 12, 12, 12, 12, 12, 12, 12, 12,
107 12, 12, 12, 12, 12, 12, 12, 12,
108 12, 12, 12, 12, 12, 12, 12, 12,
111 static const uint16_t rv_chrom_code[256] =
113 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
114 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
115 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
116 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
117 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
118 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
119 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
120 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
121 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
122 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
123 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
124 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
125 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
126 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
127 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
128 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
129 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
130 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
131 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
132 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
133 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
134 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
135 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
136 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
137 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
138 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
139 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
140 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
141 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
142 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
143 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
144 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
147 static const uint8_t rv_chrom_bits[256] =
149 16, 14, 14, 14, 14, 14, 14, 14,
150 14, 14, 14, 14, 14, 14, 14, 14,
151 14, 14, 14, 14, 14, 14, 14, 14,
152 14, 14, 14, 14, 14, 14, 14, 14,
153 14, 14, 14, 14, 14, 14, 14, 14,
154 14, 14, 14, 14, 14, 14, 14, 14,
155 14, 14, 14, 14, 14, 14, 14, 14,
156 14, 14, 14, 14, 14, 14, 14, 14,
157 14, 12, 12, 12, 12, 12, 12, 12,
158 12, 12, 12, 12, 12, 12, 12, 12,
159 12, 12, 12, 12, 12, 12, 12, 12,
160 12, 12, 12, 12, 12, 12, 12, 12,
161 12, 10, 10, 10, 10, 10, 10, 10,
162 10, 10, 10, 10, 10, 10, 10, 10,
163 10, 8, 8, 8, 8, 8, 8, 8,
164 8, 6, 6, 6, 6, 4, 4, 3,
165 2, 3, 4, 4, 6, 6, 6, 6,
166 8, 8, 8, 8, 8, 8, 8, 8,
167 10, 10, 10, 10, 10, 10, 10, 10,
168 10, 10, 10, 10, 10, 10, 10, 10,
169 12, 12, 12, 12, 12, 12, 12, 12,
170 12, 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 14, 14, 14, 14, 14, 14, 14, 14,
174 14, 14, 14, 14, 14, 14, 14, 14,
175 14, 14, 14, 14, 14, 14, 14, 14,
176 14, 14, 14, 14, 14, 14, 14, 14,
177 14, 14, 14, 14, 14, 14, 14, 14,
178 14, 14, 14, 14, 14, 14, 14, 14,
179 14, 14, 14, 14, 14, 14, 14, 14,
180 14, 14, 14, 14, 14, 14, 14, 14,
183 static VLC rv_dc_lum, rv_dc_chrom;
185 int rv_decode_dc(MpegEncContext *s, int n)
190 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
192 /* XXX: I don't understand why they use LONGER codes than
193 necessary. The following code would be completely useless
194 if they had thought about it !!! */
195 code = get_bits(&s->gb, 7);
197 code = (int8_t)(get_bits(&s->gb, 7) + 1);
198 } else if (code == 0x7d) {
199 code = -128 + get_bits(&s->gb, 7);
200 } else if (code == 0x7e) {
201 if (get_bits1(&s->gb) == 0)
202 code = (int8_t)(get_bits(&s->gb, 8) + 1);
204 code = (int8_t)(get_bits(&s->gb, 8));
205 } else if (code == 0x7f) {
206 skip_bits(&s->gb, 11);
213 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
216 code = get_bits(&s->gb, 9);
218 code = (int8_t)(get_bits(&s->gb, 7) + 1);
219 } else if (code == 0x1fd) {
220 code = -128 + get_bits(&s->gb, 7);
221 } else if (code == 0x1fe) {
222 skip_bits(&s->gb, 9);
225 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
235 /* read RV 1.0 compatible frame header */
236 static int rv10_decode_picture_header(MpegEncContext *s)
238 int mb_count, pb_frame, marker, unk, mb_xy;
240 marker = get_bits1(&s->gb);
242 if (get_bits1(&s->gb))
243 s->pict_type = FF_P_TYPE;
245 s->pict_type = FF_I_TYPE;
246 if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
247 pb_frame = get_bits1(&s->gb);
249 av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
252 av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
256 s->qscale = get_bits(&s->gb, 5);
258 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
262 if (s->pict_type == FF_I_TYPE) {
263 if (s->rv10_version == 3) {
264 /* specific MPEG like DC coding not used */
265 s->last_dc[0] = get_bits(&s->gb, 8);
266 s->last_dc[1] = get_bits(&s->gb, 8);
267 s->last_dc[2] = get_bits(&s->gb, 8);
268 av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
269 s->last_dc[1], s->last_dc[2]);
272 /* if multiple packets per frame are sent, the position at which
273 to display the macroblocks is coded here */
275 mb_xy= s->mb_x + s->mb_y*s->mb_width;
276 if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
277 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
278 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
279 mb_count = get_bits(&s->gb, 12);
283 mb_count = s->mb_width * s->mb_height;
285 unk= get_bits(&s->gb, 3); /* ignored */
287 s->unrestricted_mv = 1;
292 static int rv20_decode_picture_header(MpegEncContext *s)
297 GetBitContext gb= s->gb;
299 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
300 if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
302 av_log(s->avctx, AV_LOG_DEBUG, "\n");
305 av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
306 for(i=0; i<s->avctx->extradata_size; i++){
307 av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
308 if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
310 av_log(s->avctx, AV_LOG_DEBUG, "\n");
313 if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
314 if (get_bits(&s->gb, 3)){
315 av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
320 i= get_bits(&s->gb, 2);
322 case 0: s->pict_type= FF_I_TYPE; break;
323 case 1: s->pict_type= FF_I_TYPE; break; //hmm ...
324 case 2: s->pict_type= FF_P_TYPE; break;
325 case 3: s->pict_type= FF_B_TYPE; break;
327 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
331 if(s->last_picture_ptr==NULL && s->pict_type==FF_B_TYPE){
332 av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
336 if (get_bits1(&s->gb)){
337 av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
341 s->qscale = get_bits(&s->gb, 5);
343 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
346 if(s->avctx->sub_id == 0x30203002){
347 if (get_bits1(&s->gb)){
348 av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
353 if(s->avctx->has_b_frames){
355 int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
357 if (get_bits1(&s->gb)){
358 av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
360 seq= get_bits(&s->gb, 13)<<2;
362 f= get_bits(&s->gb, av_log2(v)+1);
365 new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
366 new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
368 new_w= s->orig_width ;
369 new_h= s->orig_height;
371 if(new_w != s->width || new_h != s->height){
372 av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
373 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
376 avcodec_set_dimensions(s->avctx, new_w, new_h);
379 if (MPV_common_init(s) < 0)
383 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
384 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
387 seq= get_bits(&s->gb, 8)*128;
390 // if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
391 mb_pos= ff_h263_decode_mba(s);
393 mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
394 s->mb_x= mb_pos % s->mb_width;
395 s->mb_y= mb_pos / s->mb_width;
397 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
398 seq |= s->time &~0x7FFF;
399 if(seq - s->time > 0x4000) seq -= 0x8000;
400 if(seq - s->time < -0x4000) seq += 0x8000;
402 if(s->pict_type!=FF_B_TYPE){
404 s->pp_time= s->time - s->last_non_b_time;
405 s->last_non_b_time= s->time;
408 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
409 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
410 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
411 return FRAME_SKIPPED;
413 ff_mpeg4_init_direct_mv(s);
416 // printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
417 /*for(i=0; i<32; i++){
418 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
420 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
421 s->no_rounding= get_bits1(&s->gb);
424 s->unrestricted_mv = 1;
425 s->h263_aic= s->pict_type == FF_I_TYPE;
426 // s->alt_inter_vlc=1;
430 if(!s->avctx->lowres)
433 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
434 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
435 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
438 assert(s->pict_type != FF_B_TYPE || !s->low_delay);
440 return s->mb_width*s->mb_height - mb_pos;
443 static av_cold int rv10_decode_init(AVCodecContext *avctx)
445 MpegEncContext *s = avctx->priv_data;
448 if (avctx->extradata_size < 8) {
449 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
453 MPV_decode_defaults(s);
456 s->out_format = FMT_H263;
457 s->codec_id= avctx->codec_id;
459 s->orig_width = s->width = avctx->coded_width;
460 s->orig_height= s->height = avctx->coded_height;
462 s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
463 avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
465 if (avctx->sub_id == 0x10000000) {
468 } else if (avctx->sub_id == 0x10001000) {
471 } else if (avctx->sub_id == 0x10002000) {
475 } else if (avctx->sub_id == 0x10003000) {
478 } else if (avctx->sub_id == 0x10003001) {
481 } else if ( avctx->sub_id == 0x20001000
482 || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
484 } else if ( avctx->sub_id == 0x30202002
485 || avctx->sub_id == 0x30203002
486 || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
488 s->avctx->has_b_frames=1;
490 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
492 if(avctx->debug & FF_DEBUG_PICT_INFO){
493 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
496 avctx->pix_fmt = PIX_FMT_YUV420P;
498 if (MPV_common_init(s) < 0)
501 h263_decode_init_vlc(s);
505 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
507 rv_lum_code, 2, 2, 16384);
508 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
510 rv_chrom_code, 2, 2, 16388);
517 static av_cold int rv10_decode_end(AVCodecContext *avctx)
519 MpegEncContext *s = avctx->priv_data;
525 static int rv10_decode_packet(AVCodecContext *avctx,
526 const uint8_t *buf, int buf_size, int buf_size2)
528 MpegEncContext *s = avctx->priv_data;
529 int mb_count, mb_pos, left, start_mb_x;
531 init_get_bits(&s->gb, buf, buf_size*8);
532 if(s->codec_id ==CODEC_ID_RV10)
533 mb_count = rv10_decode_picture_header(s);
535 mb_count = rv20_decode_picture_header(s);
537 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
541 if (s->mb_x >= s->mb_width ||
542 s->mb_y >= s->mb_height) {
543 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
546 mb_pos = s->mb_y * s->mb_width + s->mb_x;
547 left = s->mb_width * s->mb_height - mb_pos;
548 if (mb_count > left) {
549 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
553 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
554 if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
557 s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
559 if(MPV_frame_start(s, avctx) < 0)
561 ff_er_frame_start(s);
564 av_dlog(avctx, "qscale=%d\n", s->qscale);
566 /* default quantization values */
567 if(s->codec_id== CODEC_ID_RV10){
568 if(s->mb_y==0) s->first_slice_line=1;
570 s->first_slice_line=1;
571 s->resync_mb_x= s->mb_x;
574 s->resync_mb_y= s->mb_y;
577 s->c_dc_scale_table= ff_aic_dc_scale_table;
580 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
583 if(s->modified_quant)
584 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
586 ff_set_qscale(s, s->qscale);
588 s->rv10_first_dc_coded[0] = 0;
589 s->rv10_first_dc_coded[1] = 0;
590 s->rv10_first_dc_coded[2] = 0;
594 s->block_wrap[3]= s->b8_stride;
596 s->block_wrap[5]= s->mb_stride;
597 ff_init_block_index(s);
598 /* decode each macroblock */
600 for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
602 ff_update_block_index(s);
603 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
605 s->mv_dir = MV_DIR_FORWARD;
606 s->mv_type = MV_TYPE_16X16;
607 ret=ff_h263_decode_mb(s, s->block);
609 if (ret != SLICE_ERROR && s->gb.size_in_bits < get_bits_count(&s->gb) && 8*buf_size2 >= get_bits_count(&s->gb)){
610 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n", s->gb.size_in_bits, 8*buf_size2);
611 s->gb.size_in_bits= 8*buf_size2;
615 if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
616 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
619 if(s->pict_type != FF_B_TYPE)
620 ff_h263_update_motion_val(s);
621 MPV_decode_mb(s, s->block);
623 ff_h263_loop_filter(s);
625 if (++s->mb_x == s->mb_width) {
628 ff_init_block_index(s);
630 if(s->mb_x == s->resync_mb_x)
631 s->first_slice_line=0;
632 if(ret == SLICE_END) break;
635 ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
637 return s->gb.size_in_bits;
640 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
642 if(avctx->slice_count) return avctx->slice_offset[n];
643 else return AV_RL32(buf + n*8);
646 static int rv10_decode_frame(AVCodecContext *avctx,
647 void *data, int *data_size,
650 const uint8_t *buf = avpkt->data;
651 int buf_size = avpkt->size;
652 MpegEncContext *s = avctx->priv_data;
654 AVFrame *pict = data;
656 const uint8_t *slices_hdr = NULL;
658 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
660 /* no supplementary picture */
665 if(!avctx->slice_count){
666 slice_count = (*buf++) + 1;
667 slices_hdr = buf + 4;
668 buf += 8 * slice_count;
670 slice_count = avctx->slice_count;
672 for(i=0; i<slice_count; i++){
673 int offset= get_slice_offset(avctx, slices_hdr, i);
676 if(i+1 == slice_count)
677 size= buf_size - offset;
679 size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
681 if(i+2 >= slice_count)
682 size2= buf_size - offset;
684 size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
686 if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
690 if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
694 if (s->pict_type == FF_B_TYPE || s->low_delay) {
695 *pict= *(AVFrame*)s->current_picture_ptr;
696 } else if (s->last_picture_ptr != NULL) {
697 *pict= *(AVFrame*)s->last_picture_ptr;
700 if(s->last_picture_ptr || s->low_delay){
701 *data_size = sizeof(AVFrame);
702 ff_print_debug_info(s, pict);
704 s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
710 AVCodec ff_rv10_decoder = {
714 sizeof(MpegEncContext),
721 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
722 .pix_fmts= ff_pixfmt_list_420,
725 AVCodec ff_rv20_decoder = {
729 sizeof(MpegEncContext),
734 CODEC_CAP_DR1 | CODEC_CAP_DELAY,
735 .flush= ff_mpeg_flush,
737 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
738 .pix_fmts= ff_pixfmt_list_420,