optionally (use_lpc=2) support Cholesky factorization for finding the lpc coeficients
[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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 #if 0 /* unused, remove? */
291 static int get_num(GetBitContext *gb)
292 {
293     int n, n1;
294
295     n = get_bits(gb, 16);
296     if (n >= 0x4000) {
297         return n - 0x4000;
298     } else {
299         n1 = get_bits(gb, 16);
300         return (n << 16) | n1;
301     }
302 }
303 #endif
304
305 #endif //CONFIG_ENCODERS
306
307 /* read RV 1.0 compatible frame header */
308 static int rv10_decode_picture_header(MpegEncContext *s)
309 {
310     int mb_count, pb_frame, marker, unk, mb_xy;
311
312 //printf("ff:%d\n", full_frame);
313     marker = get_bits(&s->gb, 1);
314
315     if (get_bits(&s->gb, 1))
316         s->pict_type = P_TYPE;
317     else
318         s->pict_type = I_TYPE;
319 //printf("h:%X ver:%d\n",h,s->rv10_version);
320     if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
321     pb_frame = get_bits(&s->gb, 1);
322
323 #ifdef DEBUG
324     av_log(s->avctx, AV_LOG_DEBUG, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
325 #endif
326
327     if (pb_frame){
328         av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
329         return -1;
330     }
331
332     s->qscale = get_bits(&s->gb, 5);
333     if(s->qscale==0){
334         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
335         return -1;
336     }
337
338     if (s->pict_type == I_TYPE) {
339         if (s->rv10_version == 3) {
340             /* specific MPEG like DC coding not used */
341             s->last_dc[0] = get_bits(&s->gb, 8);
342             s->last_dc[1] = get_bits(&s->gb, 8);
343             s->last_dc[2] = get_bits(&s->gb, 8);
344 #ifdef DEBUG
345             av_log(s->avctx, AV_LOG_DEBUG, "DC:%d %d %d\n",
346                    s->last_dc[0],
347                    s->last_dc[1],
348                    s->last_dc[2]);
349 #endif
350         }
351     }
352     /* if multiple packets per frame are sent, the position at which
353        to display the macro blocks is coded here */
354
355     mb_xy= s->mb_x + s->mb_y*s->mb_width;
356     if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
357         s->mb_x = get_bits(&s->gb, 6); /* mb_x */
358         s->mb_y = get_bits(&s->gb, 6); /* mb_y */
359         mb_count = get_bits(&s->gb, 12);
360     } else {
361         s->mb_x = 0;
362         s->mb_y = 0;
363         mb_count = s->mb_width * s->mb_height;
364     }
365     unk= get_bits(&s->gb, 3);   /* ignored */
366 //printf("%d\n", unk);
367     s->f_code = 1;
368     s->unrestricted_mv = 1;
369
370     return mb_count;
371 }
372
373 static int rv20_decode_picture_header(MpegEncContext *s)
374 {
375     int seq, mb_pos, i;
376
377 #if 0
378     GetBitContext gb= s->gb;
379     for(i=0; i<64; i++){
380         av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
381         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
382     }
383     av_log(s->avctx, AV_LOG_DEBUG, "\n");
384 #endif
385 #if 0
386     for(i=0; i<s->avctx->extradata_size; i++){
387         av_log(s->avctx, AV_LOG_DEBUG, "%2X ", ((uint8_t*)s->avctx->extradata)[i]);
388         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
389     }
390     av_log(s->avctx, AV_LOG_DEBUG, "\n");
391 #endif
392
393     if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
394         if (get_bits(&s->gb, 3)){
395             av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
396             return -1;
397         }
398     }
399
400     i= get_bits(&s->gb, 2);
401     switch(i){
402     case 0: s->pict_type= I_TYPE; break;
403     case 1: s->pict_type= I_TYPE; break; //hmm ...
404     case 2: s->pict_type= P_TYPE; break;
405     case 3: s->pict_type= B_TYPE; break;
406     default:
407         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
408         return -1;
409     }
410
411     if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
412         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
413         return -1;
414     }
415
416     if (get_bits(&s->gb, 1)){
417         av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
418         return -1;
419     }
420
421     s->qscale = get_bits(&s->gb, 5);
422     if(s->qscale==0){
423         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
424         return -1;
425     }
426     if(s->avctx->sub_id == 0x30203002){
427         if (get_bits(&s->gb, 1)){
428             av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
429             return -1;
430         }
431     }
432
433     if(s->avctx->has_b_frames){
434         int f=9;
435         int v= s->avctx->extradata_size >= 4 ? ((uint8_t*)s->avctx->extradata)[1] : 0;
436
437         if (get_bits(&s->gb, 1)){
438             av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
439 //            return -1;
440         }
441         seq= get_bits(&s->gb, 14)<<1;
442
443         if(v)
444             f= get_bits(&s->gb, av_log2(v));
445
446         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
447             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
448         }
449     }else{
450         seq= get_bits(&s->gb, 8)*128;
451     }
452
453 //     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
454     mb_pos= ff_h263_decode_mba(s);
455 /*    }else{
456         mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
457         s->mb_x= mb_pos % s->mb_width;
458         s->mb_y= mb_pos / s->mb_width;
459     }*/
460 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
461     seq |= s->time &~0x7FFF;
462     if(seq - s->time >  0x4000) seq -= 0x8000;
463     if(seq - s->time < -0x4000) seq += 0x8000;
464     if(seq != s->time){
465         if(s->pict_type!=B_TYPE){
466             s->time= seq;
467             s->pp_time= s->time - s->last_non_b_time;
468             s->last_non_b_time= s->time;
469         }else{
470             s->time= seq;
471             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
472             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
473                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
474                 return FRAME_SKIPPED;
475             }
476         }
477     }
478 //    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
479 /*for(i=0; i<32; i++){
480     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
481 }
482 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
483     s->no_rounding= get_bits1(&s->gb);
484
485     s->f_code = 1;
486     s->unrestricted_mv = 1;
487     s->h263_aic= s->pict_type == I_TYPE;
488 //    s->alt_inter_vlc=1;
489 //    s->obmc=1;
490 //    s->umvplus=1;
491     s->modified_quant=1;
492     s->loop_filter=1;
493
494     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
495             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
496                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
497     }
498
499     assert(s->pict_type != B_TYPE || !s->low_delay);
500
501     return s->mb_width*s->mb_height - mb_pos;
502 }
503
504 static int rv10_decode_init(AVCodecContext *avctx)
505 {
506     MpegEncContext *s = avctx->priv_data;
507     static int done=0;
508
509     MPV_decode_defaults(s);
510
511     s->avctx= avctx;
512     s->out_format = FMT_H263;
513     s->codec_id= avctx->codec_id;
514
515     s->width = avctx->width;
516     s->height = avctx->height;
517
518     switch(avctx->sub_id){
519     case 0x10000000:
520         s->rv10_version= 0;
521         s->h263_long_vectors=0;
522         s->low_delay=1;
523         break;
524     case 0x10002000:
525         s->rv10_version= 3;
526         s->h263_long_vectors=1;
527         s->low_delay=1;
528         s->obmc=1;
529         break;
530     case 0x10003000:
531         s->rv10_version= 3;
532         s->h263_long_vectors=1;
533         s->low_delay=1;
534         break;
535     case 0x10003001:
536         s->rv10_version= 3;
537         s->h263_long_vectors=0;
538         s->low_delay=1;
539         break;
540     case 0x20001000: /* real rv20 decoder fail on this id */
541     /*case 0x20100001:
542     case 0x20101001:
543     case 0x20103001:*/
544     case 0x20100000 ... 0x2019ffff:
545         s->low_delay=1;
546         break;
547     /*case 0x20200002:
548     case 0x20201002:
549     case 0x20203002:*/
550     case 0x20200002 ... 0x202fffff:
551     case 0x30202002:
552     case 0x30203002:
553         s->low_delay=0;
554         s->avctx->has_b_frames=1;
555         break;
556     default:
557         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
558     }
559
560     if(avctx->debug & FF_DEBUG_PICT_INFO){
561         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
562     }
563
564     avctx->pix_fmt = PIX_FMT_YUV420P;
565
566     if (MPV_common_init(s) < 0)
567         return -1;
568
569     h263_decode_init_vlc(s);
570
571     /* init rv vlc */
572     if (!done) {
573         init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
574                  rv_lum_bits, 1, 1,
575                  rv_lum_code, 2, 2, 1);
576         init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
577                  rv_chrom_bits, 1, 1,
578                  rv_chrom_code, 2, 2, 1);
579         done = 1;
580     }
581
582     return 0;
583 }
584
585 static int rv10_decode_end(AVCodecContext *avctx)
586 {
587     MpegEncContext *s = avctx->priv_data;
588
589     MPV_common_end(s);
590     return 0;
591 }
592
593 static int rv10_decode_packet(AVCodecContext *avctx,
594                              uint8_t *buf, int buf_size)
595 {
596     MpegEncContext *s = avctx->priv_data;
597     int mb_count, mb_pos, left;
598
599     init_get_bits(&s->gb, buf, buf_size*8);
600     if(s->codec_id ==CODEC_ID_RV10)
601         mb_count = rv10_decode_picture_header(s);
602     else
603         mb_count = rv20_decode_picture_header(s);
604     if (mb_count < 0) {
605         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
606         return -1;
607     }
608
609     if (s->mb_x >= s->mb_width ||
610         s->mb_y >= s->mb_height) {
611         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
612         return -1;
613     }
614     mb_pos = s->mb_y * s->mb_width + s->mb_x;
615     left = s->mb_width * s->mb_height - mb_pos;
616     if (mb_count > left) {
617         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
618         return -1;
619     }
620 //if(s->pict_type == P_TYPE) return 0;
621
622     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
623         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
624             ff_er_frame_end(s);
625             MPV_frame_end(s);
626             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
627         }
628         if(MPV_frame_start(s, avctx) < 0)
629             return -1;
630         ff_er_frame_start(s);
631     }
632
633 #ifdef DEBUG
634     av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
635 #endif
636
637     /* default quantization values */
638     if(s->codec_id== CODEC_ID_RV10){
639         if(s->mb_y==0) s->first_slice_line=1;
640     }else{
641         s->first_slice_line=1;
642     }
643     s->resync_mb_x= s->mb_x;
644     s->resync_mb_y= s->mb_y;
645     if(s->h263_aic){
646         s->y_dc_scale_table=
647         s->c_dc_scale_table= ff_aic_dc_scale_table;
648     }else{
649         s->y_dc_scale_table=
650         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
651     }
652
653     if(s->modified_quant)
654         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
655
656     ff_set_qscale(s, s->qscale);
657
658     s->rv10_first_dc_coded[0] = 0;
659     s->rv10_first_dc_coded[1] = 0;
660     s->rv10_first_dc_coded[2] = 0;
661 //printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
662     s->block_wrap[0]=
663     s->block_wrap[1]=
664     s->block_wrap[2]=
665     s->block_wrap[3]= s->b8_stride;
666     s->block_wrap[4]=
667     s->block_wrap[5]= s->mb_stride;
668     ff_init_block_index(s);
669     /* decode each macroblock */
670
671     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
672         int ret;
673         ff_update_block_index(s);
674 #ifdef DEBUG
675         av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
676 #endif
677
678         s->mv_dir = MV_DIR_FORWARD;
679         s->mv_type = MV_TYPE_16X16;
680         ret=ff_h263_decode_mb(s, s->block);
681
682         if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
683             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
684             return -1;
685         }
686         if(s->pict_type != B_TYPE)
687             ff_h263_update_motion_val(s);
688         MPV_decode_mb(s, s->block);
689         if(s->loop_filter)
690             ff_h263_loop_filter(s);
691
692         if (++s->mb_x == s->mb_width) {
693             s->mb_x = 0;
694             s->mb_y++;
695             ff_init_block_index(s);
696         }
697         if(s->mb_x == s->resync_mb_x)
698             s->first_slice_line=0;
699         if(ret == SLICE_END) break;
700     }
701
702     ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
703
704     return buf_size;
705 }
706
707 static int rv10_decode_frame(AVCodecContext *avctx,
708                              void *data, int *data_size,
709                              uint8_t *buf, int buf_size)
710 {
711     MpegEncContext *s = avctx->priv_data;
712     int i;
713     AVFrame *pict = data;
714
715 #ifdef DEBUG
716     av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
717 #endif
718
719     /* no supplementary picture */
720     if (buf_size == 0) {
721         return 0;
722     }
723
724     if(avctx->slice_count){
725         for(i=0; i<avctx->slice_count; i++){
726             int offset= avctx->slice_offset[i];
727             int size;
728
729             if(i+1 == avctx->slice_count)
730                 size= buf_size - offset;
731             else
732                 size= avctx->slice_offset[i+1] - offset;
733
734             rv10_decode_packet(avctx, buf+offset, size);
735         }
736     }else{
737         rv10_decode_packet(avctx, buf, buf_size);
738     }
739
740     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
741         ff_er_frame_end(s);
742         MPV_frame_end(s);
743
744         if (s->pict_type == B_TYPE || s->low_delay) {
745             *pict= *(AVFrame*)s->current_picture_ptr;
746         } else if (s->last_picture_ptr != NULL) {
747             *pict= *(AVFrame*)s->last_picture_ptr;
748         }
749
750         if(s->last_picture_ptr || s->low_delay){
751             *data_size = sizeof(AVFrame);
752             ff_print_debug_info(s, pict);
753         }
754         s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
755     }
756
757     return buf_size;
758 }
759
760 AVCodec rv10_decoder = {
761     "rv10",
762     CODEC_TYPE_VIDEO,
763     CODEC_ID_RV10,
764     sizeof(MpegEncContext),
765     rv10_decode_init,
766     NULL,
767     rv10_decode_end,
768     rv10_decode_frame,
769     CODEC_CAP_DR1
770 };
771
772 AVCodec rv20_decoder = {
773     "rv20",
774     CODEC_TYPE_VIDEO,
775     CODEC_ID_RV20,
776     sizeof(MpegEncContext),
777     rv10_decode_init,
778     NULL,
779     rv10_decode_end,
780     rv10_decode_frame,
781     CODEC_CAP_DR1 | CODEC_CAP_DELAY,
782     .flush= ff_mpeg_flush,
783 };
784