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);
458 s->width = s->avctx->width = new_w;
459 s->height = s->avctx->height= new_h;
460 if (MPV_common_init(s) < 0)
464 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
465 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
468 seq= get_bits(&s->gb, 8)*128;
471 // if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
472 mb_pos= ff_h263_decode_mba(s);
474 mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
475 s->mb_x= mb_pos % s->mb_width;
476 s->mb_y= mb_pos / s->mb_width;
478 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
479 seq |= s->time &~0x7FFF;
480 if(seq - s->time > 0x4000) seq -= 0x8000;
481 if(seq - s->time < -0x4000) seq += 0x8000;
483 if(s->pict_type!=B_TYPE){
485 s->pp_time= s->time - s->last_non_b_time;
486 s->last_non_b_time= s->time;
489 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
490 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
491 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
492 return FRAME_SKIPPED;
494 ff_mpeg4_init_direct_mv(s);
497 // printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
498 /*for(i=0; i<32; i++){
499 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
501 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
502 s->no_rounding= get_bits1(&s->gb);
505 s->unrestricted_mv = 1;
506 s->h263_aic= s->pict_type == I_TYPE;
507 // s->alt_inter_vlc=1;
513 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
514 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
515 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
518 assert(s->pict_type != B_TYPE || !s->low_delay);
520 return s->mb_width*s->mb_height - mb_pos;
523 static int rv10_decode_init(AVCodecContext *avctx)
525 MpegEncContext *s = avctx->priv_data;
528 MPV_decode_defaults(s);
531 s->out_format = FMT_H263;
532 s->codec_id= avctx->codec_id;
534 s->width = avctx->width;
535 s->height = avctx->height;
537 s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
538 avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
540 switch(avctx->sub_id){
558 case 0x20001000: /* real rv20 decoder fail on this id */
562 case 0x20100000 ... 0x2019ffff:
568 case 0x20200002 ... 0x202fffff:
572 s->avctx->has_b_frames=1;
575 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
578 if(avctx->debug & FF_DEBUG_PICT_INFO){
579 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
582 avctx->pix_fmt = PIX_FMT_YUV420P;
584 if (MPV_common_init(s) < 0)
587 h263_decode_init_vlc(s);
591 init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
593 rv_lum_code, 2, 2, 1);
594 init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
596 rv_chrom_code, 2, 2, 1);
603 static int rv10_decode_end(AVCodecContext *avctx)
605 MpegEncContext *s = avctx->priv_data;
611 static int rv10_decode_packet(AVCodecContext *avctx,
612 uint8_t *buf, int buf_size)
614 MpegEncContext *s = avctx->priv_data;
615 int mb_count, mb_pos, left, start_mb_x;
617 init_get_bits(&s->gb, buf, buf_size*8);
618 if(s->codec_id ==CODEC_ID_RV10)
619 mb_count = rv10_decode_picture_header(s);
621 mb_count = rv20_decode_picture_header(s);
623 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
627 if (s->mb_x >= s->mb_width ||
628 s->mb_y >= s->mb_height) {
629 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
632 mb_pos = s->mb_y * s->mb_width + s->mb_x;
633 left = s->mb_width * s->mb_height - mb_pos;
634 if (mb_count > left) {
635 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
638 //if(s->pict_type == P_TYPE) return 0;
640 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
641 if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
644 s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
646 if(MPV_frame_start(s, avctx) < 0)
648 ff_er_frame_start(s);
652 av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
655 /* default quantization values */
656 if(s->codec_id== CODEC_ID_RV10){
657 if(s->mb_y==0) s->first_slice_line=1;
659 s->first_slice_line=1;
660 s->resync_mb_x= s->mb_x;
663 s->resync_mb_y= s->mb_y;
666 s->c_dc_scale_table= ff_aic_dc_scale_table;
669 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
672 if(s->modified_quant)
673 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
675 ff_set_qscale(s, s->qscale);
677 s->rv10_first_dc_coded[0] = 0;
678 s->rv10_first_dc_coded[1] = 0;
679 s->rv10_first_dc_coded[2] = 0;
680 //printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
684 s->block_wrap[3]= s->b8_stride;
686 s->block_wrap[5]= s->mb_stride;
687 ff_init_block_index(s);
688 /* decode each macroblock */
690 for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
692 ff_update_block_index(s);
694 av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
697 s->mv_dir = MV_DIR_FORWARD;
698 s->mv_type = MV_TYPE_16X16;
699 ret=ff_h263_decode_mb(s, s->block);
701 if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
702 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
705 if(s->pict_type != B_TYPE)
706 ff_h263_update_motion_val(s);
707 MPV_decode_mb(s, s->block);
709 ff_h263_loop_filter(s);
711 if (++s->mb_x == s->mb_width) {
714 ff_init_block_index(s);
716 if(s->mb_x == s->resync_mb_x)
717 s->first_slice_line=0;
718 if(ret == SLICE_END) break;
721 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);
726 static int rv10_decode_frame(AVCodecContext *avctx,
727 void *data, int *data_size,
728 uint8_t *buf, int buf_size)
730 MpegEncContext *s = avctx->priv_data;
732 AVFrame *pict = data;
735 av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
738 /* no supplementary picture */
743 if(avctx->slice_count){
744 for(i=0; i<avctx->slice_count; i++){
745 int offset= avctx->slice_offset[i];
748 if(i+1 == avctx->slice_count)
749 size= buf_size - offset;
751 size= avctx->slice_offset[i+1] - offset;
753 rv10_decode_packet(avctx, buf+offset, size);
756 rv10_decode_packet(avctx, buf, buf_size);
759 if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
763 if (s->pict_type == B_TYPE || s->low_delay) {
764 *pict= *(AVFrame*)s->current_picture_ptr;
765 } else if (s->last_picture_ptr != NULL) {
766 *pict= *(AVFrame*)s->last_picture_ptr;
769 if(s->last_picture_ptr || s->low_delay){
770 *data_size = sizeof(AVFrame);
771 ff_print_debug_info(s, pict);
773 s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
779 AVCodec rv10_decoder = {
783 sizeof(MpegEncContext),
791 AVCodec rv20_decoder = {
795 sizeof(MpegEncContext),
800 CODEC_CAP_DR1 | CODEC_CAP_DELAY,
801 .flush= ff_mpeg_flush,