1000l to myself - get correct quantization for blocks 1 and 2
[ffmpeg.git] / libavcodec / rv10.c
1 /*
2  * RV10 codec
3  * Copyright (c) 2000,2001 Fabrice Bellard.
4  * Copyright (c) 2002-2004 Michael Niedermayer
5  *
6  * This file is part of FFmpeg.
7  *
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.
12  *
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.
17  *
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
21  */
22
23 /**
24  * @file rv10.c
25  * RV10 codec.
26  */
27
28 #include "avcodec.h"
29 #include "dsputil.h"
30 #include "mpegvideo.h"
31
32 //#define DEBUG
33
34 #define DC_VLC_BITS 14 //FIXME find a better solution
35
36 static const uint16_t rv_lum_code[256] =
37 {
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,
70 };
71
72 static const uint8_t rv_lum_bits[256] =
73 {
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,
106 };
107
108 static const uint16_t rv_chrom_code[256] =
109 {
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,
142 };
143
144 static const uint8_t rv_chrom_bits[256] =
145 {
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,
178 };
179
180 static VLC rv_dc_lum, rv_dc_chrom;
181
182 int rv_decode_dc(MpegEncContext *s, int n)
183 {
184     int code;
185
186     if (n < 4) {
187         code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
188         if (code < 0) {
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);
193             if (code == 0x7c) {
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);
200                 else
201                     code = (int8_t)(get_bits(&s->gb, 8));
202             } else if (code == 0x7f) {
203                 get_bits(&s->gb, 11);
204                 code = 1;
205             }
206         } else {
207             code -= 128;
208         }
209     } else {
210         code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
211         /* same remark */
212         if (code < 0) {
213             code = get_bits(&s->gb, 9);
214             if (code == 0x1fc) {
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) {
219                 get_bits(&s->gb, 9);
220                 code = 1;
221             } else {
222                 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
223                 return 0xffff;
224             }
225         } else {
226             code -= 128;
227         }
228     }
229     return -code;
230 }
231
232 #ifdef CONFIG_ENCODERS
233
234 /* write RV 1.0 compatible frame header */
235 void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
236 {
237     int full_frame= 0;
238
239     align_put_bits(&s->pb);
240
241     put_bits(&s->pb, 1, 1);     /* marker */
242
243     put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
244
245     put_bits(&s->pb, 1, 0);     /* not PB frame */
246
247     put_bits(&s->pb, 5, s->qscale);
248
249     if (s->pict_type == I_TYPE) {
250         /* specific MPEG like DC coding not used */
251     }
252     /* if multiple packets per frame are sent, the position at which
253        to display the macro blocks is coded here */
254     if(!full_frame){
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);
258     }
259
260     put_bits(&s->pb, 3, 0);     /* ignored */
261 }
262
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);
267
268     put_bits(&s->pb, 8, picture_number&0xFF); //FIXME wrong, but correct is not known
269     s->mb_x= s->mb_y= 0;
270     ff_h263_encode_mba(s);
271
272     put_bits(&s->pb, 1, s->no_rounding);
273
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);
281
282     s->h263_aic= s->pict_type == I_TYPE;
283     if(s->h263_aic){
284         s->y_dc_scale_table=
285         s->c_dc_scale_table= ff_aic_dc_scale_table;
286     }else{
287         s->y_dc_scale_table=
288         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
289     }
290 }
291
292 #if 0 /* unused, remove? */
293 static int get_num(GetBitContext *gb)
294 {
295     int n, n1;
296
297     n = get_bits(gb, 16);
298     if (n >= 0x4000) {
299         return n - 0x4000;
300     } else {
301         n1 = get_bits(gb, 16);
302         return (n << 16) | n1;
303     }
304 }
305 #endif
306
307 #endif //CONFIG_ENCODERS
308
309 /* read RV 1.0 compatible frame header */
310 static int rv10_decode_picture_header(MpegEncContext *s)
311 {
312     int mb_count, pb_frame, marker, unk, mb_xy;
313
314 //printf("ff:%d\n", full_frame);
315     marker = get_bits(&s->gb, 1);
316
317     if (get_bits(&s->gb, 1))
318         s->pict_type = P_TYPE;
319     else
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);
324
325 #ifdef DEBUG
326     av_log(s->avctx, AV_LOG_DEBUG, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
327 #endif
328
329     if (pb_frame){
330         av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
331         return -1;
332     }
333
334     s->qscale = get_bits(&s->gb, 5);
335     if(s->qscale==0){
336         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
337         return -1;
338     }
339
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);
346 #ifdef DEBUG
347             av_log(s->avctx, AV_LOG_DEBUG, "DC:%d %d %d\n",
348                    s->last_dc[0],
349                    s->last_dc[1],
350                    s->last_dc[2]);
351 #endif
352         }
353     }
354     /* if multiple packets per frame are sent, the position at which
355        to display the macro blocks is coded here */
356
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);
362     } else {
363         s->mb_x = 0;
364         s->mb_y = 0;
365         mb_count = s->mb_width * s->mb_height;
366     }
367     unk= get_bits(&s->gb, 3);   /* ignored */
368 //printf("%d\n", unk);
369     s->f_code = 1;
370     s->unrestricted_mv = 1;
371
372     return mb_count;
373 }
374
375 static int rv20_decode_picture_header(MpegEncContext *s)
376 {
377     int seq, mb_pos, i;
378
379 #if 0
380     GetBitContext gb= s->gb;
381     for(i=0; i<64; i++){
382         av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
383         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
384     }
385     av_log(s->avctx, AV_LOG_DEBUG, "\n");
386 #endif
387 #if 0
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, " ");
392     }
393     av_log(s->avctx, AV_LOG_DEBUG, "\n");
394 #endif
395
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");
399             return -1;
400         }
401     }
402
403     i= get_bits(&s->gb, 2);
404     switch(i){
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;
409     default:
410         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
411         return -1;
412     }
413
414     if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
415         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
416         return -1;
417     }
418
419     if (get_bits(&s->gb, 1)){
420         av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
421         return -1;
422     }
423
424     s->qscale = get_bits(&s->gb, 5);
425     if(s->qscale==0){
426         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
427         return -1;
428     }
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");
432             return -1;
433         }
434     }
435
436     if(s->avctx->has_b_frames){
437         int f, new_w, new_h;
438         int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
439
440         if (get_bits(&s->gb, 1)){
441             av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
442 //            return -1;
443         }
444         seq= get_bits(&s->gb, 13)<<2;
445
446         f= get_bits(&s->gb, av_log2(v)+1);
447
448         if(f){
449             new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
450             new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
451         }else{
452             new_w= s->width; //FIXME wrong we of course must save the original in the context
453             new_h= s->height;
454         }
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)
458                 return -1;
459             MPV_common_end(s);
460             s->width  = s->avctx->width = new_w;
461             s->height = s->avctx->height= new_h;
462             if (MPV_common_init(s) < 0)
463                 return -1;
464         }
465
466         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
467             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
468         }
469     }else{
470         seq= get_bits(&s->gb, 8)*128;
471     }
472
473 //     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
474     mb_pos= ff_h263_decode_mba(s);
475 /*    }else{
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;
479     }*/
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;
484     if(seq != s->time){
485         if(s->pict_type!=B_TYPE){
486             s->time= seq;
487             s->pp_time= s->time - s->last_non_b_time;
488             s->last_non_b_time= s->time;
489         }else{
490             s->time= seq;
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;
495             }
496             ff_mpeg4_init_direct_mv(s);
497         }
498     }
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));
502 }
503 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
504     s->no_rounding= get_bits1(&s->gb);
505
506     s->f_code = 1;
507     s->unrestricted_mv = 1;
508     s->h263_aic= s->pict_type == I_TYPE;
509 //    s->alt_inter_vlc=1;
510 //    s->obmc=1;
511 //    s->umvplus=1;
512     s->modified_quant=1;
513     s->loop_filter=1;
514
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);
518     }
519
520     assert(s->pict_type != B_TYPE || !s->low_delay);
521
522     return s->mb_width*s->mb_height - mb_pos;
523 }
524
525 static int rv10_decode_init(AVCodecContext *avctx)
526 {
527     MpegEncContext *s = avctx->priv_data;
528     static int done=0;
529
530     MPV_decode_defaults(s);
531
532     s->avctx= avctx;
533     s->out_format = FMT_H263;
534     s->codec_id= avctx->codec_id;
535
536     s->width = avctx->width;
537     s->height = avctx->height;
538
539     s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
540     avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
541
542     switch(avctx->sub_id){
543     case 0x10000000:
544         s->rv10_version= 0;
545         s->low_delay=1;
546         break;
547     case 0x10002000:
548         s->rv10_version= 3;
549         s->low_delay=1;
550         s->obmc=1;
551         break;
552     case 0x10003000:
553         s->rv10_version= 3;
554         s->low_delay=1;
555         break;
556     case 0x10003001:
557         s->rv10_version= 3;
558         s->low_delay=1;
559         break;
560     case 0x20001000: /* real rv20 decoder fail on this id */
561     /*case 0x20100001:
562     case 0x20101001:
563     case 0x20103001:*/
564     case 0x20100000 ... 0x2019ffff:
565         s->low_delay=1;
566         break;
567     /*case 0x20200002:
568     case 0x20201002:
569     case 0x20203002:*/
570     case 0x20200002 ... 0x202fffff:
571     case 0x30202002:
572     case 0x30203002:
573         s->low_delay=0;
574         s->avctx->has_b_frames=1;
575         break;
576     default:
577         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
578     }
579
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);
582     }
583
584     avctx->pix_fmt = PIX_FMT_YUV420P;
585
586     if (MPV_common_init(s) < 0)
587         return -1;
588
589     h263_decode_init_vlc(s);
590
591     /* init rv vlc */
592     if (!done) {
593         init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
594                  rv_lum_bits, 1, 1,
595                  rv_lum_code, 2, 2, 1);
596         init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
597                  rv_chrom_bits, 1, 1,
598                  rv_chrom_code, 2, 2, 1);
599         done = 1;
600     }
601
602     return 0;
603 }
604
605 static int rv10_decode_end(AVCodecContext *avctx)
606 {
607     MpegEncContext *s = avctx->priv_data;
608
609     MPV_common_end(s);
610     return 0;
611 }
612
613 static int rv10_decode_packet(AVCodecContext *avctx,
614                              uint8_t *buf, int buf_size)
615 {
616     MpegEncContext *s = avctx->priv_data;
617     int mb_count, mb_pos, left, start_mb_x;
618
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);
622     else
623         mb_count = rv20_decode_picture_header(s);
624     if (mb_count < 0) {
625         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
626         return -1;
627     }
628
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);
632         return -1;
633     }
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");
638         return -1;
639     }
640 //if(s->pict_type == P_TYPE) return 0;
641
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?
644             ff_er_frame_end(s);
645             MPV_frame_end(s);
646             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
647         }
648         if(MPV_frame_start(s, avctx) < 0)
649             return -1;
650         ff_er_frame_start(s);
651     }
652
653 #ifdef DEBUG
654     av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
655 #endif
656
657     /* default quantization values */
658     if(s->codec_id== CODEC_ID_RV10){
659         if(s->mb_y==0) s->first_slice_line=1;
660     }else{
661         s->first_slice_line=1;
662         s->resync_mb_x= s->mb_x;
663     }
664     start_mb_x= s->mb_x;
665     s->resync_mb_y= s->mb_y;
666     if(s->h263_aic){
667         s->y_dc_scale_table=
668         s->c_dc_scale_table= ff_aic_dc_scale_table;
669     }else{
670         s->y_dc_scale_table=
671         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
672     }
673
674     if(s->modified_quant)
675         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
676
677     ff_set_qscale(s, s->qscale);
678
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]);
683     s->block_wrap[0]=
684     s->block_wrap[1]=
685     s->block_wrap[2]=
686     s->block_wrap[3]= s->b8_stride;
687     s->block_wrap[4]=
688     s->block_wrap[5]= s->mb_stride;
689     ff_init_block_index(s);
690     /* decode each macroblock */
691
692     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
693         int ret;
694         ff_update_block_index(s);
695 #ifdef DEBUG
696         av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
697 #endif
698
699         s->mv_dir = MV_DIR_FORWARD;
700         s->mv_type = MV_TYPE_16X16;
701         ret=ff_h263_decode_mb(s, s->block);
702
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);
705             return -1;
706         }
707         if(s->pict_type != B_TYPE)
708             ff_h263_update_motion_val(s);
709         MPV_decode_mb(s, s->block);
710         if(s->loop_filter)
711             ff_h263_loop_filter(s);
712
713         if (++s->mb_x == s->mb_width) {
714             s->mb_x = 0;
715             s->mb_y++;
716             ff_init_block_index(s);
717         }
718         if(s->mb_x == s->resync_mb_x)
719             s->first_slice_line=0;
720         if(ret == SLICE_END) break;
721     }
722
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);
724
725     return buf_size;
726 }
727
728 static int rv10_decode_frame(AVCodecContext *avctx,
729                              void *data, int *data_size,
730                              uint8_t *buf, int buf_size)
731 {
732     MpegEncContext *s = avctx->priv_data;
733     int i;
734     AVFrame *pict = data;
735
736 #ifdef DEBUG
737     av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
738 #endif
739
740     /* no supplementary picture */
741     if (buf_size == 0) {
742         return 0;
743     }
744
745     if(avctx->slice_count){
746         for(i=0; i<avctx->slice_count; i++){
747             int offset= avctx->slice_offset[i];
748             int size;
749
750             if(i+1 == avctx->slice_count)
751                 size= buf_size - offset;
752             else
753                 size= avctx->slice_offset[i+1] - offset;
754
755             rv10_decode_packet(avctx, buf+offset, size);
756         }
757     }else{
758         rv10_decode_packet(avctx, buf, buf_size);
759     }
760
761     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
762         ff_er_frame_end(s);
763         MPV_frame_end(s);
764
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;
769         }
770
771         if(s->last_picture_ptr || s->low_delay){
772             *data_size = sizeof(AVFrame);
773             ff_print_debug_info(s, pict);
774         }
775         s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
776     }
777
778     return buf_size;
779 }
780
781 AVCodec rv10_decoder = {
782     "rv10",
783     CODEC_TYPE_VIDEO,
784     CODEC_ID_RV10,
785     sizeof(MpegEncContext),
786     rv10_decode_init,
787     NULL,
788     rv10_decode_end,
789     rv10_decode_frame,
790     CODEC_CAP_DR1
791 };
792
793 AVCodec rv20_decoder = {
794     "rv20",
795     CODEC_TYPE_VIDEO,
796     CODEC_ID_RV20,
797     sizeof(MpegEncContext),
798     rv10_decode_init,
799     NULL,
800     rv10_decode_end,
801     rv10_decode_frame,
802     CODEC_CAP_DR1 | CODEC_CAP_DELAY,
803     .flush= ff_mpeg_flush,
804 };
805