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
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, mb_xy;
240 marker = get_bits1(&s->gb);
242 if (get_bits1(&s->gb))
243 s->pict_type = AV_PICTURE_TYPE_P;
245 s->pict_type = AV_PICTURE_TYPE_I;
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 == AV_PICTURE_TYPE_I) {
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 skip_bits(&s->gb, 3); /* ignored */
287 s->unrestricted_mv = 1;
292 static int rv20_decode_picture_header(MpegEncContext *s)
296 if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
297 if (get_bits(&s->gb, 3)){
298 av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
303 i= get_bits(&s->gb, 2);
305 case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
306 case 1: s->pict_type= AV_PICTURE_TYPE_I; break; //hmm ...
307 case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
308 case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
310 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
314 if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
315 av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
319 if (get_bits1(&s->gb)){
320 av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
324 s->qscale = get_bits(&s->gb, 5);
326 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
329 if(s->avctx->sub_id == 0x30203002){
330 if (get_bits1(&s->gb)){
331 av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
336 if(s->avctx->has_b_frames){
338 int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
340 if (get_bits1(&s->gb)){
341 av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
343 seq= get_bits(&s->gb, 13)<<2;
345 f= get_bits(&s->gb, av_log2(v)+1);
348 new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
349 new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
351 new_w= s->orig_width ;
352 new_h= s->orig_height;
354 if(new_w != s->width || new_h != s->height){
355 av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
356 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
359 avcodec_set_dimensions(s->avctx, new_w, new_h);
362 if (MPV_common_init(s) < 0)
366 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
367 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
370 seq= get_bits(&s->gb, 8)*128;
373 // if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
374 mb_pos= ff_h263_decode_mba(s);
376 mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
377 s->mb_x= mb_pos % s->mb_width;
378 s->mb_y= mb_pos / s->mb_width;
380 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
381 seq |= s->time &~0x7FFF;
382 if(seq - s->time > 0x4000) seq -= 0x8000;
383 if(seq - s->time < -0x4000) seq += 0x8000;
385 if(s->pict_type!=AV_PICTURE_TYPE_B){
387 s->pp_time= s->time - s->last_non_b_time;
388 s->last_non_b_time= s->time;
391 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
392 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
393 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
394 return FRAME_SKIPPED;
396 ff_mpeg4_init_direct_mv(s);
399 // printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
400 /*for(i=0; i<32; i++){
401 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
403 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
404 s->no_rounding= get_bits1(&s->gb);
407 s->unrestricted_mv = 1;
408 s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
409 // s->alt_inter_vlc=1;
413 if(!s->avctx->lowres)
416 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
417 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
418 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
421 assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
423 return s->mb_width*s->mb_height - mb_pos;
426 static av_cold int rv10_decode_init(AVCodecContext *avctx)
428 MpegEncContext *s = avctx->priv_data;
431 if (avctx->extradata_size < 8) {
432 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
436 MPV_decode_defaults(s);
439 s->out_format = FMT_H263;
440 s->codec_id= avctx->codec_id;
442 s->orig_width = s->width = avctx->coded_width;
443 s->orig_height= s->height = avctx->coded_height;
445 s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
446 avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
448 if (avctx->sub_id == 0x10000000) {
451 } else if (avctx->sub_id == 0x10001000) {
454 } else if (avctx->sub_id == 0x10002000) {
458 } else if (avctx->sub_id == 0x10003000) {
461 } else if (avctx->sub_id == 0x10003001) {
464 } else if ( avctx->sub_id == 0x20001000
465 || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
467 } else if ( avctx->sub_id == 0x30202002
468 || avctx->sub_id == 0x30203002
469 || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
471 s->avctx->has_b_frames=1;
473 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
475 if(avctx->debug & FF_DEBUG_PICT_INFO){
476 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
479 avctx->pix_fmt = PIX_FMT_YUV420P;
481 if (MPV_common_init(s) < 0)
484 h263_decode_init_vlc(s);
488 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
490 rv_lum_code, 2, 2, 16384);
491 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
493 rv_chrom_code, 2, 2, 16388);
500 static av_cold int rv10_decode_end(AVCodecContext *avctx)
502 MpegEncContext *s = avctx->priv_data;
508 static int rv10_decode_packet(AVCodecContext *avctx,
509 const uint8_t *buf, int buf_size, int buf_size2)
511 MpegEncContext *s = avctx->priv_data;
512 int mb_count, mb_pos, left, start_mb_x;
514 init_get_bits(&s->gb, buf, buf_size*8);
515 if(s->codec_id ==CODEC_ID_RV10)
516 mb_count = rv10_decode_picture_header(s);
518 mb_count = rv20_decode_picture_header(s);
520 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
524 if (s->mb_x >= s->mb_width ||
525 s->mb_y >= s->mb_height) {
526 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
529 mb_pos = s->mb_y * s->mb_width + s->mb_x;
530 left = s->mb_width * s->mb_height - mb_pos;
531 if (mb_count > left) {
532 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
536 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
537 if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
540 s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
542 if(MPV_frame_start(s, avctx) < 0)
544 ff_er_frame_start(s);
547 av_dlog(avctx, "qscale=%d\n", s->qscale);
549 /* default quantization values */
550 if(s->codec_id== CODEC_ID_RV10){
551 if(s->mb_y==0) s->first_slice_line=1;
553 s->first_slice_line=1;
554 s->resync_mb_x= s->mb_x;
557 s->resync_mb_y= s->mb_y;
560 s->c_dc_scale_table= ff_aic_dc_scale_table;
563 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
566 if(s->modified_quant)
567 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
569 ff_set_qscale(s, s->qscale);
571 s->rv10_first_dc_coded[0] = 0;
572 s->rv10_first_dc_coded[1] = 0;
573 s->rv10_first_dc_coded[2] = 0;
577 s->block_wrap[3]= s->b8_stride;
579 s->block_wrap[5]= s->mb_stride;
580 ff_init_block_index(s);
581 /* decode each macroblock */
583 for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
585 ff_update_block_index(s);
586 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
588 s->mv_dir = MV_DIR_FORWARD;
589 s->mv_type = MV_TYPE_16X16;
590 ret=ff_h263_decode_mb(s, s->block);
592 if (ret != SLICE_ERROR && s->gb.size_in_bits < get_bits_count(&s->gb) && 8*buf_size2 >= get_bits_count(&s->gb)){
593 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n", s->gb.size_in_bits, 8*buf_size2);
594 s->gb.size_in_bits= 8*buf_size2;
598 if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
599 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
602 if(s->pict_type != AV_PICTURE_TYPE_B)
603 ff_h263_update_motion_val(s);
604 MPV_decode_mb(s, s->block);
606 ff_h263_loop_filter(s);
608 if (++s->mb_x == s->mb_width) {
611 ff_init_block_index(s);
613 if(s->mb_x == s->resync_mb_x)
614 s->first_slice_line=0;
615 if(ret == SLICE_END) break;
618 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);
620 return s->gb.size_in_bits;
623 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
625 if(avctx->slice_count) return avctx->slice_offset[n];
626 else return AV_RL32(buf + n*8);
629 static int rv10_decode_frame(AVCodecContext *avctx,
630 void *data, int *data_size,
633 const uint8_t *buf = avpkt->data;
634 int buf_size = avpkt->size;
635 MpegEncContext *s = avctx->priv_data;
637 AVFrame *pict = data;
639 const uint8_t *slices_hdr = NULL;
641 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
643 /* no supplementary picture */
648 if(!avctx->slice_count){
649 slice_count = (*buf++) + 1;
650 slices_hdr = buf + 4;
651 buf += 8 * slice_count;
653 slice_count = avctx->slice_count;
655 for(i=0; i<slice_count; i++){
656 int offset= get_slice_offset(avctx, slices_hdr, i);
659 if(i+1 == slice_count)
660 size= buf_size - offset;
662 size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
664 if(i+2 >= slice_count)
665 size2= buf_size - offset;
667 size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
669 if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
673 if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
677 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
678 *pict= *(AVFrame*)s->current_picture_ptr;
679 } else if (s->last_picture_ptr != NULL) {
680 *pict= *(AVFrame*)s->last_picture_ptr;
683 if(s->last_picture_ptr || s->low_delay){
684 *data_size = sizeof(AVFrame);
685 ff_print_debug_info(s, pict);
687 s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
693 AVCodec ff_rv10_decoder = {
695 .type = AVMEDIA_TYPE_VIDEO,
697 .priv_data_size = sizeof(MpegEncContext),
698 .init = rv10_decode_init,
699 .close = rv10_decode_end,
700 .decode = rv10_decode_frame,
701 .capabilities = CODEC_CAP_DR1,
703 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
704 .pix_fmts= ff_pixfmt_list_420,
707 AVCodec ff_rv20_decoder = {
709 .type = AVMEDIA_TYPE_VIDEO,
711 .priv_data_size = sizeof(MpegEncContext),
712 .init = rv10_decode_init,
713 .close = rv10_decode_end,
714 .decode = rv10_decode_frame,
715 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
716 .flush= ff_mpeg_flush,
718 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
719 .pix_fmts= ff_pixfmt_list_420,