avoid buf_size == 0 checks in every decoder
[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 library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 /**
22  * @file rv10.c
23  * RV10 codec.
24  */
25  
26 #include "avcodec.h"
27 #include "dsputil.h"
28 #include "mpegvideo.h"
29
30 //#define DEBUG
31
32 #define DC_VLC_BITS 14 //FIXME find a better solution
33
34 static const uint16_t rv_lum_code[256] =
35 {
36  0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
37  0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
38  0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
39  0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
40  0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
41  0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
42  0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
43  0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
44  0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
45  0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
46  0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
47  0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
48  0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
49  0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
50  0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
51  0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
52  0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
53  0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
54  0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
55  0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
56  0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
57  0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
58  0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
59  0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
60  0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
61  0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
62  0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
63  0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
64  0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
65  0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
66  0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
67  0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
68 };
69
70 static const uint8_t rv_lum_bits[256] = 
71 {
72  14, 12, 12, 12, 12, 12, 12, 12,
73  12, 12, 12, 12, 12, 12, 12, 12,
74  12, 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, 10, 10, 10, 10, 10, 10, 10,
81  10, 10, 10, 10, 10, 10, 10, 10,
82  10, 10, 10, 10, 10, 10, 10, 10,
83  10, 10, 10, 10, 10, 10, 10, 10,
84  10,  8,  8,  8,  8,  8,  8,  8,
85   8,  8,  8,  8,  8,  8,  8,  8,
86   8,  7,  7,  7,  7,  7,  7,  7,
87   7,  6,  6,  6,  6,  5,  5,  4,
88   2,  4,  5,  5,  6,  6,  6,  6,
89   7,  7,  7,  7,  7,  7,  7,  7,
90   8,  8,  8,  8,  8,  8,  8,  8,
91   8,  8,  8,  8,  8,  8,  8,  8,
92  10, 10, 10, 10, 10, 10, 10, 10,
93  10, 10, 10, 10, 10, 10, 10, 10,
94  10, 10, 10, 10, 10, 10, 10, 10,
95  10, 10, 10, 10, 10, 10, 10, 10,
96  12, 12, 12, 12, 12, 12, 12, 12,
97  12, 12, 12, 12, 12, 12, 12, 12,
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 };
105
106 static const uint16_t rv_chrom_code[256] =
107 {
108  0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
109  0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
110  0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
111  0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
112  0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
113  0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
114  0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
115  0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
116  0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
117  0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
118  0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
119  0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
120  0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
121  0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
122  0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
123  0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
124  0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
125  0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
126  0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
127  0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
128  0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
129  0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
130  0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
131  0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
132  0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
133  0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
134  0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
135  0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
136  0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
137  0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
138  0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
139  0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
140 };
141
142 static const uint8_t rv_chrom_bits[256] =
143 {
144  16, 14, 14, 14, 14, 14, 14, 14,
145  14, 14, 14, 14, 14, 14, 14, 14,
146  14, 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, 12, 12, 12, 12, 12, 12, 12,
153  12, 12, 12, 12, 12, 12, 12, 12,
154  12, 12, 12, 12, 12, 12, 12, 12,
155  12, 12, 12, 12, 12, 12, 12, 12,
156  12, 10, 10, 10, 10, 10, 10, 10,
157  10, 10, 10, 10, 10, 10, 10, 10,
158  10,  8,  8,  8,  8,  8,  8,  8,
159   8,  6,  6,  6,  6,  4,  4,  3,
160   2,  3,  4,  4,  6,  6,  6,  6,
161   8,  8,  8,  8,  8,  8,  8,  8,
162  10, 10, 10, 10, 10, 10, 10, 10,
163  10, 10, 10, 10, 10, 10, 10, 10,
164  12, 12, 12, 12, 12, 12, 12, 12,
165  12, 12, 12, 12, 12, 12, 12, 12,
166  12, 12, 12, 12, 12, 12, 12, 12,
167  12, 12, 12, 12, 12, 12, 12, 12,
168  14, 14, 14, 14, 14, 14, 14, 14,
169  14, 14, 14, 14, 14, 14, 14, 14,
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 };
177
178 static VLC rv_dc_lum, rv_dc_chrom;
179
180 int rv_decode_dc(MpegEncContext *s, int n)
181 {
182     int code;
183
184     if (n < 4) {
185         code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
186         if (code < 0) {
187             /* XXX: I don't understand why they use LONGER codes than
188                necessary. The following code would be completely useless
189                if they had thought about it !!! */
190             code = get_bits(&s->gb, 7);
191             if (code == 0x7c) {
192                 code = (int8_t)(get_bits(&s->gb, 7) + 1);
193             } else if (code == 0x7d) {
194                 code = -128 + get_bits(&s->gb, 7);
195             } else if (code == 0x7e) {
196                 if (get_bits(&s->gb, 1) == 0)
197                     code = (int8_t)(get_bits(&s->gb, 8) + 1);
198                 else
199                     code = (int8_t)(get_bits(&s->gb, 8));
200             } else if (code == 0x7f) {
201                 get_bits(&s->gb, 11);
202                 code = 1;
203             }
204         } else {
205             code -= 128;
206         }
207     } else {
208         code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
209         /* same remark */
210         if (code < 0) {
211             code = get_bits(&s->gb, 9);
212             if (code == 0x1fc) {
213                 code = (int8_t)(get_bits(&s->gb, 7) + 1);
214             } else if (code == 0x1fd) {
215                 code = -128 + get_bits(&s->gb, 7);
216             } else if (code == 0x1fe) {
217                 get_bits(&s->gb, 9);
218                 code = 1;
219             } else {
220                 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
221                 return 0xffff;
222             }
223         } else {
224             code -= 128;
225         }
226     }
227     return -code;
228 }
229
230 #ifdef CONFIG_ENCODERS
231
232 /* write RV 1.0 compatible frame header */
233 void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
234 {
235     int full_frame= 0;
236
237     align_put_bits(&s->pb);
238     
239     put_bits(&s->pb, 1, 1);     /* marker */
240
241     put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
242
243     put_bits(&s->pb, 1, 0);     /* not PB frame */
244
245     put_bits(&s->pb, 5, s->qscale);
246
247     if (s->pict_type == I_TYPE) {
248         /* specific MPEG like DC coding not used */
249     }
250     /* if multiple packets per frame are sent, the position at which
251        to display the macro blocks is coded here */
252     if(!full_frame){
253         put_bits(&s->pb, 6, 0); /* mb_x */
254         put_bits(&s->pb, 6, 0); /* mb_y */
255         put_bits(&s->pb, 12, s->mb_width * s->mb_height);
256     }
257
258     put_bits(&s->pb, 3, 0);     /* ignored */
259 }
260
261 void rv20_encode_picture_header(MpegEncContext *s, int picture_number){
262     put_bits(&s->pb, 2, s->pict_type); //I 0 vs. 1 ?
263     put_bits(&s->pb, 1, 0);     /* unknown bit */
264     put_bits(&s->pb, 5, s->qscale);
265         
266     put_bits(&s->pb, 8, picture_number&0xFF); //FIXME wrong, but correct is not known
267     s->mb_x= s->mb_y= 0;
268     ff_h263_encode_mba(s);
269     
270     put_bits(&s->pb, 1, s->no_rounding);
271     
272     assert(s->f_code == 1);
273     assert(s->unrestricted_mv == 1);
274 //    assert(s->h263_aic== (s->pict_type == I_TYPE));
275     assert(s->alt_inter_vlc == 0);
276     assert(s->umvplus == 0);
277     assert(s->modified_quant==1);
278     assert(s->loop_filter==1);
279
280     s->h263_aic= s->pict_type == I_TYPE;
281     if(s->h263_aic){
282         s->y_dc_scale_table= 
283         s->c_dc_scale_table= ff_aic_dc_scale_table;
284     }else{
285         s->y_dc_scale_table=
286         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
287     }
288 }
289
290 static int get_num(GetBitContext *gb)
291 {
292     int n, n1;
293
294     n = get_bits(gb, 16);
295     if (n >= 0x4000) {
296         return n - 0x4000;
297     } else {
298         n1 = get_bits(gb, 16);
299         return (n << 16) | n1;
300     }
301 }
302
303 #endif //CONFIG_ENCODERS
304
305 /* read RV 1.0 compatible frame header */
306 static int rv10_decode_picture_header(MpegEncContext *s)
307 {
308     int mb_count, pb_frame, marker, unk, mb_xy;
309     
310 //printf("ff:%d\n", full_frame);
311     marker = get_bits(&s->gb, 1);
312
313     if (get_bits(&s->gb, 1))
314         s->pict_type = P_TYPE;
315     else
316         s->pict_type = I_TYPE;
317 //printf("h:%X ver:%d\n",h,s->rv10_version);
318     if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
319     pb_frame = get_bits(&s->gb, 1);
320
321 #ifdef DEBUG
322     printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
323 #endif
324     
325     if (pb_frame){
326         av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
327         return -1;
328     }
329
330     s->qscale = get_bits(&s->gb, 5);
331     if(s->qscale==0){
332         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
333         return -1;
334     }
335
336     if (s->pict_type == I_TYPE) {
337         if (s->rv10_version == 3) {
338             /* specific MPEG like DC coding not used */
339             s->last_dc[0] = get_bits(&s->gb, 8);
340             s->last_dc[1] = get_bits(&s->gb, 8);
341             s->last_dc[2] = get_bits(&s->gb, 8);
342 #ifdef DEBUG
343             printf("DC:%d %d %d\n",
344                    s->last_dc[0],
345                    s->last_dc[1],
346                    s->last_dc[2]);
347 #endif
348         }
349     }
350     /* if multiple packets per frame are sent, the position at which
351        to display the macro blocks is coded here */
352
353     mb_xy= s->mb_x + s->mb_y*s->mb_width;
354     if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
355         s->mb_x = get_bits(&s->gb, 6);  /* mb_x */
356         s->mb_y = get_bits(&s->gb, 6);  /* mb_y */
357         mb_count = get_bits(&s->gb, 12);
358     } else {
359         s->mb_x = 0;
360         s->mb_y = 0;
361         mb_count = s->mb_width * s->mb_height;
362     }
363     unk= get_bits(&s->gb, 3);   /* ignored */
364 //printf("%d\n", unk);
365     s->f_code = 1;
366     s->unrestricted_mv = 1;
367
368     return mb_count;
369 }
370
371 static int rv20_decode_picture_header(MpegEncContext *s)
372 {
373     int seq, mb_pos, i;
374     
375 #if 0
376     GetBitContext gb= s->gb;
377     for(i=0; i<64; i++){
378         av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
379         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
380     }
381     av_log(s->avctx, AV_LOG_DEBUG, "\n");
382 #endif
383 #if 0
384     for(i=0; i<s->avctx->extradata_size; i++){
385         av_log(s->avctx, AV_LOG_DEBUG, "%2X ", ((uint8_t*)s->avctx->extradata)[i]);
386         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
387     }
388     av_log(s->avctx, AV_LOG_DEBUG, "\n");
389 #endif
390     
391     if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
392         if (get_bits(&s->gb, 3)){
393             av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
394             return -1;
395         } 
396     }   
397
398     i= get_bits(&s->gb, 2);
399     switch(i){
400     case 0: s->pict_type= I_TYPE; break;
401     case 1: s->pict_type= I_TYPE; break; //hmm ...
402     case 2: s->pict_type= P_TYPE; break;
403     case 3: s->pict_type= B_TYPE; break;
404     default: 
405         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
406         return -1;
407     }
408     
409     if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
410         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
411         return -1;
412     }
413     
414     if (get_bits(&s->gb, 1)){
415         av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
416         return -1;
417     }
418
419     s->qscale = get_bits(&s->gb, 5);
420     if(s->qscale==0){
421         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
422         return -1;
423     }
424     if(s->avctx->sub_id == 0x30203002){
425         if (get_bits(&s->gb, 1)){
426             av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
427             return -1;
428         }
429     }
430         
431     if(s->avctx->has_b_frames){
432         int f=9;
433         int v= s->avctx->extradata_size >= 4 ? ((uint8_t*)s->avctx->extradata)[1] : 0;
434
435         if (get_bits(&s->gb, 1)){
436             av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
437 //            return -1;
438         }
439         seq= get_bits(&s->gb, 14)<<1;
440
441         if(v>1 || (s->avctx->sub_id < 0x20201002 && v>0)){
442             f= get_bits(&s->gb, av_log2(v-1)+1);
443         }
444         
445         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
446             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
447         }
448
449         mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
450         s->mb_x= mb_pos % s->mb_width;
451         s->mb_y= mb_pos / s->mb_width;
452     }else{
453         seq= get_bits(&s->gb, 8)*128;
454         mb_pos= ff_h263_decode_mba(s);
455     }
456 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
457     seq |= s->time &~0x7FFF;
458     if(seq - s->time >  0x4000) seq -= 0x8000;
459     if(seq - s->time < -0x4000) seq += 0x8000;
460     if(seq != s->time){  
461         if(s->pict_type!=B_TYPE){
462             s->time= seq;
463             s->pp_time= s->time - s->last_non_b_time;
464             s->last_non_b_time= s->time;
465         }else{
466             s->time= seq;
467             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
468             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
469                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, seeking?, skiping current b frame\n");
470                 return FRAME_SKIPED;
471             }
472         }
473     }
474 //    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
475 /*for(i=0; i<32; i++){
476     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
477 }
478 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
479     s->no_rounding= get_bits1(&s->gb);
480     
481     s->f_code = 1;
482     s->unrestricted_mv = 1;
483     s->h263_aic= s->pict_type == I_TYPE;
484 //    s->alt_inter_vlc=1;
485 //    s->obmc=1;
486 //    s->umvplus=1;
487     s->modified_quant=1;
488     s->loop_filter=1;
489     
490     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
491             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n", 
492                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
493     }
494
495     assert(s->pict_type != B_TYPE || !s->low_delay);
496
497     return s->mb_width*s->mb_height - mb_pos;
498 }
499
500 static int rv10_decode_init(AVCodecContext *avctx)
501 {
502     MpegEncContext *s = avctx->priv_data;
503     static int done=0;
504
505     MPV_decode_defaults(s);
506     
507     s->avctx= avctx;
508     s->out_format = FMT_H263;
509     s->codec_id= avctx->codec_id;
510
511     s->width = avctx->width;
512     s->height = avctx->height;
513
514     switch(avctx->sub_id){
515     case 0x10000000:
516         s->rv10_version= 0;
517         s->h263_long_vectors=0;
518         s->low_delay=1;
519         break;
520     case 0x10002000:
521         s->rv10_version= 3;
522         s->h263_long_vectors=1;
523         s->low_delay=1;
524         s->obmc=1;
525         break;
526     case 0x10003000:
527         s->rv10_version= 3;
528         s->h263_long_vectors=1;
529         s->low_delay=1;
530         break;
531     case 0x10003001:
532         s->rv10_version= 3;
533         s->h263_long_vectors=0;
534         s->low_delay=1;
535         break;
536     case 0x20001000:
537     case 0x20100001:
538     case 0x20101001:
539     case 0x20103001:
540         s->low_delay=1;
541         break;
542     case 0x20200002:
543     case 0x20201002:
544     case 0x30202002:
545     case 0x30203002:
546         s->low_delay=0;
547         s->avctx->has_b_frames=1;
548         break;
549     default:
550         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
551     }
552     
553     if(avctx->debug & FF_DEBUG_PICT_INFO){
554         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
555     }
556     
557     if (MPV_common_init(s) < 0)
558         return -1;
559
560     h263_decode_init_vlc(s);
561
562     /* init rv vlc */
563     if (!done) {
564         init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
565                  rv_lum_bits, 1, 1,
566                  rv_lum_code, 2, 2, 1);
567         init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
568                  rv_chrom_bits, 1, 1,
569                  rv_chrom_code, 2, 2, 1);
570         done = 1;
571     }
572     
573     avctx->pix_fmt = PIX_FMT_YUV420P;
574
575     return 0;
576 }
577
578 static int rv10_decode_end(AVCodecContext *avctx)
579 {
580     MpegEncContext *s = avctx->priv_data;
581
582     MPV_common_end(s);
583     return 0;
584 }
585
586 static int rv10_decode_packet(AVCodecContext *avctx, 
587                              uint8_t *buf, int buf_size)
588 {
589     MpegEncContext *s = avctx->priv_data;
590     int mb_count, mb_pos, left;
591
592     init_get_bits(&s->gb, buf, buf_size*8);
593     if(s->codec_id ==CODEC_ID_RV10)
594         mb_count = rv10_decode_picture_header(s);
595     else
596         mb_count = rv20_decode_picture_header(s);
597     if (mb_count < 0) {
598         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
599         return -1;
600     }
601     
602     if (s->mb_x >= s->mb_width ||
603         s->mb_y >= s->mb_height) {
604         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
605         return -1;
606     }
607     mb_pos = s->mb_y * s->mb_width + s->mb_x;
608     left = s->mb_width * s->mb_height - mb_pos;
609     if (mb_count > left) {
610         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
611         return -1;
612     }
613 //if(s->pict_type == P_TYPE) return 0;
614
615     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
616         if(MPV_frame_start(s, avctx) < 0)
617             return -1;
618     }
619
620 #ifdef DEBUG
621     printf("qscale=%d\n", s->qscale);
622 #endif
623
624     /* default quantization values */
625     if(s->codec_id== CODEC_ID_RV10){
626         if(s->mb_y==0) s->first_slice_line=1;
627     }else{
628         s->first_slice_line=1;    
629         s->resync_mb_x= s->mb_x;
630         s->resync_mb_y= s->mb_y;
631     }
632     if(s->h263_aic){
633         s->y_dc_scale_table= 
634         s->c_dc_scale_table= ff_aic_dc_scale_table;
635     }else{
636         s->y_dc_scale_table=
637         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
638     }
639
640     if(s->modified_quant)
641         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
642         
643     ff_set_qscale(s, s->qscale);
644
645     s->rv10_first_dc_coded[0] = 0;
646     s->rv10_first_dc_coded[1] = 0;
647     s->rv10_first_dc_coded[2] = 0;
648 //printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
649     s->block_wrap[0]=
650     s->block_wrap[1]=
651     s->block_wrap[2]=
652     s->block_wrap[3]= s->b8_stride;
653     s->block_wrap[4]=
654     s->block_wrap[5]= s->mb_stride;
655     ff_init_block_index(s);
656     /* decode each macroblock */
657
658     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
659         int ret;
660         ff_update_block_index(s);
661 #ifdef DEBUG
662         printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
663 #endif
664
665         s->dsp.clear_blocks(s->block[0]);
666         s->mv_dir = MV_DIR_FORWARD;
667         s->mv_type = MV_TYPE_16X16; 
668         ret=ff_h263_decode_mb(s, s->block);
669
670         if (ret == SLICE_ERROR) {
671             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
672             return -1;
673         }
674         if(s->pict_type != B_TYPE)
675             ff_h263_update_motion_val(s);
676         MPV_decode_mb(s, s->block);
677         if(s->loop_filter)
678             ff_h263_loop_filter(s);
679
680         if (++s->mb_x == s->mb_width) {
681             s->mb_x = 0;
682             s->mb_y++;
683             ff_init_block_index(s);
684         }
685         if(s->mb_x == s->resync_mb_x)
686             s->first_slice_line=0;
687         if(ret == SLICE_END) break;
688     }
689
690     return buf_size;
691 }
692
693 static int rv10_decode_frame(AVCodecContext *avctx, 
694                              void *data, int *data_size,
695                              uint8_t *buf, int buf_size)
696 {
697     MpegEncContext *s = avctx->priv_data;
698     int i;
699     AVFrame *pict = data; 
700
701 #ifdef DEBUG
702     printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
703 #endif
704
705     /* no supplementary picture */
706     if (buf_size == 0) {
707         return 0;
708     }
709
710     if(avctx->slice_count){
711         for(i=0; i<avctx->slice_count; i++){
712             int offset= avctx->slice_offset[i];
713             int size;
714             
715             if(i+1 == avctx->slice_count)
716                 size= buf_size - offset;
717             else
718                 size= avctx->slice_offset[i+1] - offset;
719
720             if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
721                 return -1;
722         }
723     }else{
724         if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
725             return -1;
726     }
727     
728     if(s->mb_y>=s->mb_height){
729         MPV_frame_end(s);
730     
731         if(s->pict_type==B_TYPE || s->low_delay){
732             *pict= *(AVFrame*)&s->current_picture;
733             ff_print_debug_info(s, pict);
734         } else {
735             *pict= *(AVFrame*)&s->last_picture;
736             ff_print_debug_info(s, pict);
737         }
738         if(s->last_picture_ptr || s->low_delay)
739             *data_size = sizeof(AVFrame);
740     }
741
742     return buf_size;
743 }
744
745 AVCodec rv10_decoder = {
746     "rv10",
747     CODEC_TYPE_VIDEO,
748     CODEC_ID_RV10,
749     sizeof(MpegEncContext),
750     rv10_decode_init,
751     NULL,
752     rv10_decode_end,
753     rv10_decode_frame,
754     CODEC_CAP_DR1
755 };
756
757 AVCodec rv20_decoder = {
758     "rv20",
759     CODEC_TYPE_VIDEO,
760     CODEC_ID_RV20,
761     sizeof(MpegEncContext),
762     rv10_decode_init,
763     NULL,
764     rv10_decode_end,
765     rv10_decode_frame,
766     CODEC_CAP_DR1 | CODEC_CAP_DELAY,
767     .flush= ff_mpeg_flush,
768 };
769