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
30 #include "mpegvideo.h"
34 #define DC_VLC_BITS 14 //FIXME find a better solution
36 static const uint16_t rv_lum_code[256] =
38 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
39 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
40 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
41 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
42 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
43 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
44 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
45 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
46 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
47 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
48 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
49 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
50 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
51 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
52 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
53 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
54 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
55 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
56 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
57 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
58 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
59 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
60 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
61 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
62 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
63 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
64 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
65 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
66 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
67 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
68 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
69 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
72 static const uint8_t rv_lum_bits[256] =
74 14, 12, 12, 12, 12, 12, 12, 12,
75 12, 12, 12, 12, 12, 12, 12, 12,
76 12, 12, 12, 12, 12, 12, 12, 12,
77 12, 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, 10, 10, 10, 10, 10, 10, 10,
83 10, 10, 10, 10, 10, 10, 10, 10,
84 10, 10, 10, 10, 10, 10, 10, 10,
85 10, 10, 10, 10, 10, 10, 10, 10,
86 10, 8, 8, 8, 8, 8, 8, 8,
87 8, 8, 8, 8, 8, 8, 8, 8,
88 8, 7, 7, 7, 7, 7, 7, 7,
89 7, 6, 6, 6, 6, 5, 5, 4,
90 2, 4, 5, 5, 6, 6, 6, 6,
91 7, 7, 7, 7, 7, 7, 7, 7,
92 8, 8, 8, 8, 8, 8, 8, 8,
93 8, 8, 8, 8, 8, 8, 8, 8,
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, 10, 10, 10, 10, 10, 10, 10,
98 12, 12, 12, 12, 12, 12, 12, 12,
99 12, 12, 12, 12, 12, 12, 12, 12,
100 12, 12, 12, 12, 12, 12, 12, 12,
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,
108 static const uint16_t rv_chrom_code[256] =
110 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
111 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
112 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
113 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
114 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
115 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
116 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
117 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
118 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
119 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
120 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
121 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
122 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
123 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
124 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
125 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
126 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
127 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
128 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
129 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
130 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
131 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
132 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
133 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
134 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
135 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
136 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
137 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
138 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
139 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
140 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
141 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
144 static const uint8_t rv_chrom_bits[256] =
146 16, 14, 14, 14, 14, 14, 14, 14,
147 14, 14, 14, 14, 14, 14, 14, 14,
148 14, 14, 14, 14, 14, 14, 14, 14,
149 14, 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, 12, 12, 12, 12, 12, 12, 12,
155 12, 12, 12, 12, 12, 12, 12, 12,
156 12, 12, 12, 12, 12, 12, 12, 12,
157 12, 12, 12, 12, 12, 12, 12, 12,
158 12, 10, 10, 10, 10, 10, 10, 10,
159 10, 10, 10, 10, 10, 10, 10, 10,
160 10, 8, 8, 8, 8, 8, 8, 8,
161 8, 6, 6, 6, 6, 4, 4, 3,
162 2, 3, 4, 4, 6, 6, 6, 6,
163 8, 8, 8, 8, 8, 8, 8, 8,
164 10, 10, 10, 10, 10, 10, 10, 10,
165 10, 10, 10, 10, 10, 10, 10, 10,
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, 12, 12, 12, 12, 12, 12, 12,
170 14, 14, 14, 14, 14, 14, 14, 14,
171 14, 14, 14, 14, 14, 14, 14, 14,
172 14, 14, 14, 14, 14, 14, 14, 14,
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,
180 static VLC rv_dc_lum, rv_dc_chrom;
182 int rv_decode_dc(MpegEncContext *s, int n)
187 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
189 /* XXX: I don't understand why they use LONGER codes than
190 necessary. The following code would be completely useless
191 if they had thought about it !!! */
192 code = get_bits(&s->gb, 7);
194 code = (int8_t)(get_bits(&s->gb, 7) + 1);
195 } else if (code == 0x7d) {
196 code = -128 + get_bits(&s->gb, 7);
197 } else if (code == 0x7e) {
198 if (get_bits(&s->gb, 1) == 0)
199 code = (int8_t)(get_bits(&s->gb, 8) + 1);
201 code = (int8_t)(get_bits(&s->gb, 8));
202 } else if (code == 0x7f) {
203 get_bits(&s->gb, 11);
210 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
213 code = get_bits(&s->gb, 9);
215 code = (int8_t)(get_bits(&s->gb, 7) + 1);
216 } else if (code == 0x1fd) {
217 code = -128 + get_bits(&s->gb, 7);
218 } else if (code == 0x1fe) {
222 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
232 #ifdef CONFIG_ENCODERS
234 /* write RV 1.0 compatible frame header */
235 void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
239 align_put_bits(&s->pb);
241 put_bits(&s->pb, 1, 1); /* marker */
243 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
245 put_bits(&s->pb, 1, 0); /* not PB frame */
247 put_bits(&s->pb, 5, s->qscale);
249 if (s->pict_type == I_TYPE) {
250 /* specific MPEG like DC coding not used */
252 /* if multiple packets per frame are sent, the position at which
253 to display the macro blocks is coded here */
255 put_bits(&s->pb, 6, 0); /* mb_x */
256 put_bits(&s->pb, 6, 0); /* mb_y */
257 put_bits(&s->pb, 12, s->mb_width * s->mb_height);
260 put_bits(&s->pb, 3, 0); /* ignored */
263 void rv20_encode_picture_header(MpegEncContext *s, int picture_number){
264 put_bits(&s->pb, 2, s->pict_type); //I 0 vs. 1 ?
265 put_bits(&s->pb, 1, 0); /* unknown bit */
266 put_bits(&s->pb, 5, s->qscale);
268 put_bits(&s->pb, 8, picture_number&0xFF); //FIXME wrong, but correct is not known
270 ff_h263_encode_mba(s);
272 put_bits(&s->pb, 1, s->no_rounding);
274 assert(s->f_code == 1);
275 assert(s->unrestricted_mv == 1);
276 // assert(s->h263_aic== (s->pict_type == I_TYPE));
277 assert(s->alt_inter_vlc == 0);
278 assert(s->umvplus == 0);
279 assert(s->modified_quant==1);
280 assert(s->loop_filter==1);
282 s->h263_aic= s->pict_type == I_TYPE;
285 s->c_dc_scale_table= ff_aic_dc_scale_table;
288 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
292 #if 0 /* unused, remove? */
293 static int get_num(GetBitContext *gb)
297 n = get_bits(gb, 16);
301 n1 = get_bits(gb, 16);
302 return (n << 16) | n1;
307 #endif //CONFIG_ENCODERS
309 /* read RV 1.0 compatible frame header */
310 static int rv10_decode_picture_header(MpegEncContext *s)
312 int mb_count, pb_frame, marker, unk, mb_xy;
314 //printf("ff:%d\n", full_frame);
315 marker = get_bits(&s->gb, 1);
317 if (get_bits(&s->gb, 1))
318 s->pict_type = P_TYPE;
320 s->pict_type = I_TYPE;
321 //printf("h:%X ver:%d\n",h,s->rv10_version);
322 if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
323 pb_frame = get_bits(&s->gb, 1);
326 av_log(s->avctx, AV_LOG_DEBUG, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
330 av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
334 s->qscale = get_bits(&s->gb, 5);
336 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
340 if (s->pict_type == I_TYPE) {
341 if (s->rv10_version == 3) {
342 /* specific MPEG like DC coding not used */
343 s->last_dc[0] = get_bits(&s->gb, 8);
344 s->last_dc[1] = get_bits(&s->gb, 8);
345 s->last_dc[2] = get_bits(&s->gb, 8);
347 av_log(s->avctx, AV_LOG_DEBUG, "DC:%d %d %d\n",
354 /* if multiple packets per frame are sent, the position at which
355 to display the macro blocks is coded here */
357 mb_xy= s->mb_x + s->mb_y*s->mb_width;
358 if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
359 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
360 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
361 mb_count = get_bits(&s->gb, 12);
365 mb_count = s->mb_width * s->mb_height;
367 unk= get_bits(&s->gb, 3); /* ignored */
368 //printf("%d\n", unk);
370 s->unrestricted_mv = 1;
375 static int rv20_decode_picture_header(MpegEncContext *s)
380 GetBitContext gb= s->gb;
382 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
383 if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
385 av_log(s->avctx, AV_LOG_DEBUG, "\n");
388 av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
389 for(i=0; i<s->avctx->extradata_size; i++){
390 av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
391 if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
393 av_log(s->avctx, AV_LOG_DEBUG, "\n");
396 if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
397 if (get_bits(&s->gb, 3)){
398 av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
403 i= get_bits(&s->gb, 2);
405 case 0: s->pict_type= I_TYPE; break;
406 case 1: s->pict_type= I_TYPE; break; //hmm ...
407 case 2: s->pict_type= P_TYPE; break;
408 case 3: s->pict_type= B_TYPE; break;
410 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
414 if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
415 av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
419 if (get_bits(&s->gb, 1)){
420 av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
424 s->qscale = get_bits(&s->gb, 5);
426 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
429 if(s->avctx->sub_id == 0x30203002){
430 if (get_bits(&s->gb, 1)){
431 av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
436 if(s->avctx->has_b_frames){
438 int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
440 if (get_bits(&s->gb, 1)){
441 av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
444 seq= get_bits(&s->gb, 13)<<2;
446 f= get_bits(&s->gb, av_log2(v)+1);
449 new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
450 new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
452 new_w= s->width; //FIXME wrong we of course must save the original in the context
455 if(new_w != s->width || new_h != s->height){
456 av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
457 if (avcodec_check_dimensions(s->avctx, new_h, new_w) < 0)
460 s->width = s->avctx->width = new_w;
461 s->height = s->avctx->height= new_h;
462 if (MPV_common_init(s) < 0)
466 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
467 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
470 seq= get_bits(&s->gb, 8)*128;
473 // if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
474 mb_pos= ff_h263_decode_mba(s);
476 mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
477 s->mb_x= mb_pos % s->mb_width;
478 s->mb_y= mb_pos / s->mb_width;
480 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
481 seq |= s->time &~0x7FFF;
482 if(seq - s->time > 0x4000) seq -= 0x8000;
483 if(seq - s->time < -0x4000) seq += 0x8000;
485 if(s->pict_type!=B_TYPE){
487 s->pp_time= s->time - s->last_non_b_time;
488 s->last_non_b_time= s->time;
491 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
492 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
493 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
494 return FRAME_SKIPPED;
496 ff_mpeg4_init_direct_mv(s);
499 // printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
500 /*for(i=0; i<32; i++){
501 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
503 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
504 s->no_rounding= get_bits1(&s->gb);
507 s->unrestricted_mv = 1;
508 s->h263_aic= s->pict_type == I_TYPE;
509 // s->alt_inter_vlc=1;
515 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
516 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
517 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
520 assert(s->pict_type != B_TYPE || !s->low_delay);
522 return s->mb_width*s->mb_height - mb_pos;
525 static int rv10_decode_init(AVCodecContext *avctx)
527 MpegEncContext *s = avctx->priv_data;
530 MPV_decode_defaults(s);
533 s->out_format = FMT_H263;
534 s->codec_id= avctx->codec_id;
536 s->width = avctx->width;
537 s->height = avctx->height;
539 s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
540 avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
542 switch(avctx->sub_id){
560 case 0x20001000: /* real rv20 decoder fail on this id */
564 case 0x20100000 ... 0x2019ffff:
570 case 0x20200002 ... 0x202fffff:
574 s->avctx->has_b_frames=1;
577 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
580 if(avctx->debug & FF_DEBUG_PICT_INFO){
581 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
584 avctx->pix_fmt = PIX_FMT_YUV420P;
586 if (MPV_common_init(s) < 0)
589 h263_decode_init_vlc(s);
593 init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
595 rv_lum_code, 2, 2, 1);
596 init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
598 rv_chrom_code, 2, 2, 1);
605 static int rv10_decode_end(AVCodecContext *avctx)
607 MpegEncContext *s = avctx->priv_data;
613 static int rv10_decode_packet(AVCodecContext *avctx,
614 uint8_t *buf, int buf_size)
616 MpegEncContext *s = avctx->priv_data;
617 int mb_count, mb_pos, left, start_mb_x;
619 init_get_bits(&s->gb, buf, buf_size*8);
620 if(s->codec_id ==CODEC_ID_RV10)
621 mb_count = rv10_decode_picture_header(s);
623 mb_count = rv20_decode_picture_header(s);
625 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
629 if (s->mb_x >= s->mb_width ||
630 s->mb_y >= s->mb_height) {
631 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
634 mb_pos = s->mb_y * s->mb_width + s->mb_x;
635 left = s->mb_width * s->mb_height - mb_pos;
636 if (mb_count > left) {
637 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
640 //if(s->pict_type == P_TYPE) return 0;
642 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
643 if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
646 s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
648 if(MPV_frame_start(s, avctx) < 0)
650 ff_er_frame_start(s);
654 av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
657 /* default quantization values */
658 if(s->codec_id== CODEC_ID_RV10){
659 if(s->mb_y==0) s->first_slice_line=1;
661 s->first_slice_line=1;
662 s->resync_mb_x= s->mb_x;
665 s->resync_mb_y= s->mb_y;
668 s->c_dc_scale_table= ff_aic_dc_scale_table;
671 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
674 if(s->modified_quant)
675 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
677 ff_set_qscale(s, s->qscale);
679 s->rv10_first_dc_coded[0] = 0;
680 s->rv10_first_dc_coded[1] = 0;
681 s->rv10_first_dc_coded[2] = 0;
682 //printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
686 s->block_wrap[3]= s->b8_stride;
688 s->block_wrap[5]= s->mb_stride;
689 ff_init_block_index(s);
690 /* decode each macroblock */
692 for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
694 ff_update_block_index(s);
696 av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
699 s->mv_dir = MV_DIR_FORWARD;
700 s->mv_type = MV_TYPE_16X16;
701 ret=ff_h263_decode_mb(s, s->block);
703 if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
704 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
707 if(s->pict_type != B_TYPE)
708 ff_h263_update_motion_val(s);
709 MPV_decode_mb(s, s->block);
711 ff_h263_loop_filter(s);
713 if (++s->mb_x == s->mb_width) {
716 ff_init_block_index(s);
718 if(s->mb_x == s->resync_mb_x)
719 s->first_slice_line=0;
720 if(ret == SLICE_END) break;
723 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);
728 static int rv10_decode_frame(AVCodecContext *avctx,
729 void *data, int *data_size,
730 uint8_t *buf, int buf_size)
732 MpegEncContext *s = avctx->priv_data;
734 AVFrame *pict = data;
737 av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
740 /* no supplementary picture */
745 if(avctx->slice_count){
746 for(i=0; i<avctx->slice_count; i++){
747 int offset= avctx->slice_offset[i];
750 if(i+1 == avctx->slice_count)
751 size= buf_size - offset;
753 size= avctx->slice_offset[i+1] - offset;
755 rv10_decode_packet(avctx, buf+offset, size);
758 rv10_decode_packet(avctx, buf, buf_size);
761 if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
765 if (s->pict_type == B_TYPE || s->low_delay) {
766 *pict= *(AVFrame*)s->current_picture_ptr;
767 } else if (s->last_picture_ptr != NULL) {
768 *pict= *(AVFrame*)s->last_picture_ptr;
771 if(s->last_picture_ptr || s->low_delay){
772 *data_size = sizeof(AVFrame);
773 ff_print_debug_info(s, pict);
775 s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
781 AVCodec rv10_decoder = {
785 sizeof(MpegEncContext),
793 AVCodec rv20_decoder = {
797 sizeof(MpegEncContext),
802 CODEC_CAP_DR1 | CODEC_CAP_DELAY,
803 .flush= ff_mpeg_flush,