06f2b4e7d0aa7e65917757510a4e6dbaf81c1834
[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 static int get_num(GetBitContext *gb)
262 {
263     int n, n1;
264
265     n = get_bits(gb, 16);
266     if (n >= 0x4000) {
267         return n - 0x4000;
268     } else {
269         n1 = get_bits(gb, 16);
270         return (n << 16) | n1;
271     }
272 }
273
274 #endif //CONFIG_ENCODERS
275
276 /* read RV 1.0 compatible frame header */
277 static int rv10_decode_picture_header(MpegEncContext *s)
278 {
279     int mb_count, pb_frame, marker, full_frame, unk;
280     
281     full_frame= s->avctx->slice_count==1;
282 //printf("ff:%d\n", full_frame);
283     marker = get_bits(&s->gb, 1);
284
285     if (get_bits(&s->gb, 1))
286         s->pict_type = P_TYPE;
287     else
288         s->pict_type = I_TYPE;
289 //printf("h:%X ver:%d\n",h,s->rv10_version);
290     if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
291     pb_frame = get_bits(&s->gb, 1);
292
293 #ifdef DEBUG
294     printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
295 #endif
296     
297     if (pb_frame){
298         av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
299         return -1;
300     }
301
302     s->qscale = get_bits(&s->gb, 5);
303     if(s->qscale==0){
304         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
305         return -1;
306     }
307
308     if (s->pict_type == I_TYPE) {
309         if (s->rv10_version == 3) {
310             /* specific MPEG like DC coding not used */
311             s->last_dc[0] = get_bits(&s->gb, 8);
312             s->last_dc[1] = get_bits(&s->gb, 8);
313             s->last_dc[2] = get_bits(&s->gb, 8);
314 #ifdef DEBUG
315             printf("DC:%d %d %d\n",
316                    s->last_dc[0],
317                    s->last_dc[1],
318                    s->last_dc[2]);
319 #endif
320         }
321     }
322     /* if multiple packets per frame are sent, the position at which
323        to display the macro blocks is coded here */
324     if ((!full_frame) || show_bits(&s->gb, 12)==0) {
325         s->mb_x = get_bits(&s->gb, 6);  /* mb_x */
326         s->mb_y = get_bits(&s->gb, 6);  /* mb_y */
327         mb_count = get_bits(&s->gb, 12);
328     } else {
329         s->mb_x = 0;
330         s->mb_y = 0;
331         mb_count = s->mb_width * s->mb_height;
332     }
333     unk= get_bits(&s->gb, 3);   /* ignored */
334 //printf("%d\n", unk);
335     s->f_code = 1;
336     s->unrestricted_mv = 1;
337
338     return mb_count;
339 }
340
341 static int rv20_decode_picture_header(MpegEncContext *s)
342 {
343     int seq, mb_pos, i;
344     
345     if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
346         if (get_bits(&s->gb, 3)){
347             av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
348             return -1;
349         } 
350     }   
351
352     i= get_bits(&s->gb, 2);
353     switch(i){
354     case 0: s->pict_type= I_TYPE; break;
355     case 1: s->pict_type= I_TYPE; break; //hmm ...
356     case 2: s->pict_type= P_TYPE; break;
357     case 3: s->pict_type= B_TYPE; break;
358     default: 
359         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
360         return -1;
361     }
362     
363     if (get_bits(&s->gb, 1)){
364         av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
365         return -1;
366     }
367
368     s->qscale = get_bits(&s->gb, 5);
369     if(s->qscale==0){
370         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
371         return -1;
372     }
373     if(s->avctx->sub_id == 0x30203002){
374         if (get_bits(&s->gb, 1)){
375             av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
376             return -1;
377         }
378     }
379         
380     if(s->avctx->has_b_frames){
381         if (get_bits(&s->gb, 1)){
382 //            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
383 //            return -1;
384         }
385         seq= get_bits(&s->gb, 15);
386         mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
387         s->mb_x= mb_pos % s->mb_width;
388         s->mb_y= mb_pos / s->mb_width;
389     }else{
390         seq= get_bits(&s->gb, 8)*128;
391         mb_pos= ff_h263_decode_mba(s);
392     }
393 //printf("%d\n", seq);
394     seq |= s->time &~0x7FFF;
395     if(seq - s->time >  0x4000) seq -= 0x8000;
396     if(seq - s->time < -0x4000) seq += 0x8000;
397     if(seq != s->time){  
398         if(s->pict_type!=B_TYPE){
399             s->time= seq;
400             s->pp_time= s->time - s->last_non_b_time;
401             s->last_non_b_time= s->time;
402         }else{
403             s->time= seq;
404             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
405             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
406                 printf("messed up order, seeking?, skiping current b frame\n");
407                 return FRAME_SKIPED;
408             }
409         }
410     }
411 //    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
412
413     s->no_rounding= get_bits1(&s->gb);
414     
415     s->f_code = 1;
416     s->unrestricted_mv = 1;
417     s->h263_aic= s->pict_type == I_TYPE;
418 //    s->alt_inter_vlc=1;
419 //    s->obmc=1;
420 //    s->umvplus=1;
421     s->modified_quant=1;
422     s->loop_filter=1;
423     
424     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
425             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n", 
426                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
427     }
428
429     assert(s->pict_type != B_TYPE || !s->low_delay);
430
431     return s->mb_width*s->mb_height - mb_pos;
432 }
433
434 static int rv10_decode_init(AVCodecContext *avctx)
435 {
436     MpegEncContext *s = avctx->priv_data;
437     static int done=0;
438
439     s->avctx= avctx;
440     s->out_format = FMT_H263;
441     s->codec_id= avctx->codec_id;
442
443     s->width = avctx->width;
444     s->height = avctx->height;
445
446     switch(avctx->sub_id){
447     case 0x10000000:
448         s->rv10_version= 0;
449         s->h263_long_vectors=0;
450         s->low_delay=1;
451         break;
452     case 0x10002000:
453         s->rv10_version= 3;
454         s->h263_long_vectors=1;
455         s->low_delay=1;
456         s->obmc=1;
457         break;
458     case 0x10003000:
459         s->rv10_version= 3;
460         s->h263_long_vectors=1;
461         s->low_delay=1;
462         break;
463     case 0x10003001:
464         s->rv10_version= 3;
465         s->h263_long_vectors=0;
466         s->low_delay=1;
467         break;
468     case 0x20001000:
469     case 0x20100001:
470     case 0x20101001:
471         s->low_delay=1;
472         break;
473     case 0x20200002:
474     case 0x30202002:
475     case 0x30203002:
476         s->low_delay=0;
477         s->avctx->has_b_frames=1;
478         break;
479     default:
480         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
481     }
482 //printf("ver:%X\n", avctx->sub_id);
483     if (MPV_common_init(s) < 0)
484         return -1;
485
486     h263_decode_init_vlc(s);
487
488     s->progressive_sequence=1;
489
490     /* init rv vlc */
491     if (!done) {
492         init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
493                  rv_lum_bits, 1, 1,
494                  rv_lum_code, 2, 2);
495         init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
496                  rv_chrom_bits, 1, 1,
497                  rv_chrom_code, 2, 2);
498         done = 1;
499     }
500     
501     avctx->pix_fmt = PIX_FMT_YUV420P;
502
503     return 0;
504 }
505
506 static int rv10_decode_end(AVCodecContext *avctx)
507 {
508     MpegEncContext *s = avctx->priv_data;
509
510     MPV_common_end(s);
511     return 0;
512 }
513
514 static int rv10_decode_packet(AVCodecContext *avctx, 
515                              uint8_t *buf, int buf_size)
516 {
517     MpegEncContext *s = avctx->priv_data;
518     int i, mb_count, mb_pos, left;
519
520     init_get_bits(&s->gb, buf, buf_size*8);
521 #if 0
522     for(i=0; i<buf_size*8 && i<200; i++)
523         printf("%d", get_bits1(&s->gb));
524     printf("\n");
525     return 0;
526 #endif
527     if(s->codec_id ==CODEC_ID_RV10)
528         mb_count = rv10_decode_picture_header(s);
529     else
530         mb_count = rv20_decode_picture_header(s);
531     if (mb_count < 0) {
532         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
533         return -1;
534     }
535     
536     if (s->mb_x >= s->mb_width ||
537         s->mb_y >= s->mb_height) {
538         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
539         return -1;
540     }
541     mb_pos = s->mb_y * s->mb_width + s->mb_x;
542     left = s->mb_width * s->mb_height - mb_pos;
543     if (mb_count > left) {
544         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
545         return -1;
546     }
547 //if(s->pict_type == P_TYPE) return 0;
548
549     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
550         if(MPV_frame_start(s, avctx) < 0)
551             return -1;
552     }
553
554     if(s->pict_type == B_TYPE){ //FIXME remove after cleaning mottion_val indexing
555         memset(s->current_picture.motion_val[0], 0, sizeof(int16_t)*2*(s->mb_width*2+2)*(s->mb_height*2+2));
556     }
557
558 #ifdef DEBUG
559     printf("qscale=%d\n", s->qscale);
560 #endif
561
562     /* default quantization values */
563     if(s->codec_id== CODEC_ID_RV10){
564         if(s->mb_y==0) s->first_slice_line=1;
565     }else{
566         s->first_slice_line=1;    
567         s->resync_mb_x= s->mb_x;
568         s->resync_mb_y= s->mb_y;
569     }
570     if(s->h263_aic){
571         s->y_dc_scale_table= 
572         s->c_dc_scale_table= ff_aic_dc_scale_table;
573     }else{
574         s->y_dc_scale_table=
575         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
576     }
577
578     if(s->modified_quant)
579         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
580         
581     ff_set_qscale(s, s->qscale);
582
583     s->rv10_first_dc_coded[0] = 0;
584     s->rv10_first_dc_coded[1] = 0;
585     s->rv10_first_dc_coded[2] = 0;
586 //printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
587     s->block_wrap[0]=
588     s->block_wrap[1]=
589     s->block_wrap[2]=
590     s->block_wrap[3]= s->mb_width*2 + 2;
591     s->block_wrap[4]=
592     s->block_wrap[5]= s->mb_width + 2;
593     ff_init_block_index(s);
594     /* decode each macroblock */
595
596     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
597         int ret;
598         ff_update_block_index(s);
599 #ifdef DEBUG
600         printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
601 #endif
602
603         s->dsp.clear_blocks(s->block[0]);
604         s->mv_dir = MV_DIR_FORWARD;
605         s->mv_type = MV_TYPE_16X16; 
606         ret=ff_h263_decode_mb(s, s->block);
607
608         if (ret == SLICE_ERROR) {
609             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
610             return -1;
611         }
612         if(s->pict_type != B_TYPE)
613             ff_h263_update_motion_val(s);
614         MPV_decode_mb(s, s->block);
615         if(s->loop_filter)
616             ff_h263_loop_filter(s);
617
618         if (++s->mb_x == s->mb_width) {
619             s->mb_x = 0;
620             s->mb_y++;
621             ff_init_block_index(s);
622         }
623         if(s->mb_x == s->resync_mb_x)
624             s->first_slice_line=0;
625         if(ret == SLICE_END) break;
626     }
627
628     return buf_size;
629 }
630
631 static int rv10_decode_frame(AVCodecContext *avctx, 
632                              void *data, int *data_size,
633                              uint8_t *buf, int buf_size)
634 {
635     MpegEncContext *s = avctx->priv_data;
636     int i;
637     AVFrame *pict = data; 
638
639 #ifdef DEBUG
640     printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
641 #endif
642
643     /* no supplementary picture */
644     if (buf_size == 0) {
645         *data_size = 0;
646         return 0;
647     }
648
649     if(avctx->slice_count){
650         for(i=0; i<avctx->slice_count; i++){
651             int offset= avctx->slice_offset[i];
652             int size;
653             
654             if(i+1 == avctx->slice_count)
655                 size= buf_size - offset;
656             else
657                 size= avctx->slice_offset[i+1] - offset;
658
659             if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
660                 return -1;
661         }
662     }else{
663         if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
664             return -1;
665     }
666     
667     if(s->pict_type == B_TYPE){ //FIXME remove after cleaning mottion_val indexing
668         memset(s->current_picture.motion_val[0], 0, sizeof(int16_t)*2*(s->mb_width*2+2)*(s->mb_height*2+2));
669     }
670
671     if(s->mb_y>=s->mb_height){
672         MPV_frame_end(s);
673     
674         if(s->pict_type==B_TYPE || s->low_delay){
675             *pict= *(AVFrame*)&s->current_picture;
676             ff_print_debug_info(s, pict);
677         } else {
678             *pict= *(AVFrame*)&s->last_picture;
679             ff_print_debug_info(s, pict);
680         }
681         
682         *data_size = sizeof(AVFrame);
683     }else{
684         *data_size = 0;
685     }
686
687     return buf_size;
688 }
689
690 AVCodec rv10_decoder = {
691     "rv10",
692     CODEC_TYPE_VIDEO,
693     CODEC_ID_RV10,
694     sizeof(MpegEncContext),
695     rv10_decode_init,
696     NULL,
697     rv10_decode_end,
698     rv10_decode_frame,
699     CODEC_CAP_DR1
700 };
701
702 AVCodec rv20_decoder = {
703     "rv20",
704     CODEC_TYPE_VIDEO,
705     CODEC_ID_RV20,
706     sizeof(MpegEncContext),
707     rv10_decode_init,
708     NULL,
709     rv10_decode_end,
710     rv10_decode_frame,
711     CODEC_CAP_DR1
712 };
713