Replace pitch_delay_int array with single variable.
[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 libavcodec/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_bits1(&s->gb) == 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                 skip_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                 skip_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
233 #if CONFIG_RV10_ENCODER || CONFIG_RV20_ENCODER
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 == FF_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 == FF_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 macroblocks 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_sbits(&s->pb, 8, picture_number); //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 == FF_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 == FF_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_RV10_ENCODER || CONFIG_RV20_ENCODER */
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_bits1(&s->gb);
316
317     if (get_bits1(&s->gb))
318         s->pict_type = FF_P_TYPE;
319     else
320         s->pict_type = FF_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_bits1(&s->gb);
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 == FF_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 macroblocks 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= FF_I_TYPE; break;
406     case 1: s->pict_type= FF_I_TYPE; break; //hmm ...
407     case 2: s->pict_type= FF_P_TYPE; break;
408     case 3: s->pict_type= FF_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==FF_B_TYPE){
415         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
416         return -1;
417     }
418
419     if (get_bits1(&s->gb)){
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_bits1(&s->gb)){
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_bits1(&s->gb)){
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!=FF_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 == FF_I_TYPE;
509 //    s->alt_inter_vlc=1;
510 //    s->obmc=1;
511 //    s->umvplus=1;
512     s->modified_quant=1;
513     if(!s->avctx->lowres)
514         s->loop_filter=1;
515
516     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
517             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
518                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
519     }
520
521     assert(s->pict_type != FF_B_TYPE || !s->low_delay);
522
523     return s->mb_width*s->mb_height - mb_pos;
524 }
525
526 static av_cold int rv10_decode_init(AVCodecContext *avctx)
527 {
528     MpegEncContext *s = avctx->priv_data;
529     static int done=0;
530
531     if (avctx->extradata_size < 8) {
532         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
533         return -1;
534     }
535
536     MPV_decode_defaults(s);
537
538     s->avctx= avctx;
539     s->out_format = FMT_H263;
540     s->codec_id= avctx->codec_id;
541
542     s->width = avctx->coded_width;
543     s->height = avctx->coded_height;
544
545     s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
546     avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
547
548     if (avctx->sub_id == 0x10000000) {
549         s->rv10_version= 0;
550         s->low_delay=1;
551     } else if (avctx->sub_id == 0x10001000) {
552         s->rv10_version= 3;
553         s->low_delay=1;
554     } else if (avctx->sub_id == 0x10002000) {
555         s->rv10_version= 3;
556         s->low_delay=1;
557         s->obmc=1;
558     } else if (avctx->sub_id == 0x10003000) {
559         s->rv10_version= 3;
560         s->low_delay=1;
561     } else if (avctx->sub_id == 0x10003001) {
562         s->rv10_version= 3;
563         s->low_delay=1;
564     } else if (    avctx->sub_id == 0x20001000
565                || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
566         s->low_delay=1;
567     } else if (    avctx->sub_id == 0x30202002
568                ||  avctx->sub_id == 0x30203002
569                || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
570         s->low_delay=0;
571         s->avctx->has_b_frames=1;
572     } else
573         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
574
575     if(avctx->debug & FF_DEBUG_PICT_INFO){
576         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
577     }
578
579     avctx->pix_fmt = PIX_FMT_YUV420P;
580
581     if (MPV_common_init(s) < 0)
582         return -1;
583
584     h263_decode_init_vlc(s);
585
586     /* init rv vlc */
587     if (!done) {
588         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
589                  rv_lum_bits, 1, 1,
590                  rv_lum_code, 2, 2, 16384);
591         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
592                  rv_chrom_bits, 1, 1,
593                  rv_chrom_code, 2, 2, 16388);
594         done = 1;
595     }
596
597     return 0;
598 }
599
600 static av_cold int rv10_decode_end(AVCodecContext *avctx)
601 {
602     MpegEncContext *s = avctx->priv_data;
603
604     MPV_common_end(s);
605     return 0;
606 }
607
608 static int rv10_decode_packet(AVCodecContext *avctx,
609                              const uint8_t *buf, int buf_size)
610 {
611     MpegEncContext *s = avctx->priv_data;
612     int mb_count, mb_pos, left, start_mb_x;
613
614     init_get_bits(&s->gb, buf, buf_size*8);
615     if(s->codec_id ==CODEC_ID_RV10)
616         mb_count = rv10_decode_picture_header(s);
617     else
618         mb_count = rv20_decode_picture_header(s);
619     if (mb_count < 0) {
620         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
621         return -1;
622     }
623
624     if (s->mb_x >= s->mb_width ||
625         s->mb_y >= s->mb_height) {
626         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
627         return -1;
628     }
629     mb_pos = s->mb_y * s->mb_width + s->mb_x;
630     left = s->mb_width * s->mb_height - mb_pos;
631     if (mb_count > left) {
632         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
633         return -1;
634     }
635 //if(s->pict_type == FF_P_TYPE) return 0;
636
637     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
638         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
639             ff_er_frame_end(s);
640             MPV_frame_end(s);
641             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
642         }
643         if(MPV_frame_start(s, avctx) < 0)
644             return -1;
645         ff_er_frame_start(s);
646     }
647
648 #ifdef DEBUG
649     av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
650 #endif
651
652     /* default quantization values */
653     if(s->codec_id== CODEC_ID_RV10){
654         if(s->mb_y==0) s->first_slice_line=1;
655     }else{
656         s->first_slice_line=1;
657         s->resync_mb_x= s->mb_x;
658     }
659     start_mb_x= s->mb_x;
660     s->resync_mb_y= s->mb_y;
661     if(s->h263_aic){
662         s->y_dc_scale_table=
663         s->c_dc_scale_table= ff_aic_dc_scale_table;
664     }else{
665         s->y_dc_scale_table=
666         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
667     }
668
669     if(s->modified_quant)
670         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
671
672     ff_set_qscale(s, s->qscale);
673
674     s->rv10_first_dc_coded[0] = 0;
675     s->rv10_first_dc_coded[1] = 0;
676     s->rv10_first_dc_coded[2] = 0;
677 //printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
678     s->block_wrap[0]=
679     s->block_wrap[1]=
680     s->block_wrap[2]=
681     s->block_wrap[3]= s->b8_stride;
682     s->block_wrap[4]=
683     s->block_wrap[5]= s->mb_stride;
684     ff_init_block_index(s);
685     /* decode each macroblock */
686
687     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
688         int ret;
689         ff_update_block_index(s);
690 #ifdef DEBUG
691         av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
692 #endif
693
694         s->mv_dir = MV_DIR_FORWARD;
695         s->mv_type = MV_TYPE_16X16;
696         ret=ff_h263_decode_mb(s, s->block);
697
698         if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
699             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
700             return -1;
701         }
702         if(s->pict_type != FF_B_TYPE)
703             ff_h263_update_motion_val(s);
704         MPV_decode_mb(s, s->block);
705         if(s->loop_filter)
706             ff_h263_loop_filter(s);
707
708         if (++s->mb_x == s->mb_width) {
709             s->mb_x = 0;
710             s->mb_y++;
711             ff_init_block_index(s);
712         }
713         if(s->mb_x == s->resync_mb_x)
714             s->first_slice_line=0;
715         if(ret == SLICE_END) break;
716     }
717
718     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);
719
720     return buf_size;
721 }
722
723 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
724 {
725     if(avctx->slice_count) return avctx->slice_offset[n];
726     else                   return AV_RL32(buf + n*8);
727 }
728
729 static int rv10_decode_frame(AVCodecContext *avctx,
730                              void *data, int *data_size,
731                              AVPacket *avpkt)
732 {
733     const uint8_t *buf = avpkt->data;
734     int buf_size = avpkt->size;
735     MpegEncContext *s = avctx->priv_data;
736     int i;
737     AVFrame *pict = data;
738     int slice_count;
739     const uint8_t *slices_hdr = NULL;
740
741 #ifdef DEBUG
742     av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
743 #endif
744
745     /* no supplementary picture */
746     if (buf_size == 0) {
747         return 0;
748     }
749
750     if(!avctx->slice_count){
751         slice_count = (*buf++) + 1;
752         slices_hdr = buf + 4;
753         buf += 8 * slice_count;
754     }else
755         slice_count = avctx->slice_count;
756
757     for(i=0; i<slice_count; i++){
758         int offset= get_slice_offset(avctx, slices_hdr, i);
759         int size;
760
761         if(i+1 == slice_count)
762             size= buf_size - offset;
763         else
764             size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
765
766         rv10_decode_packet(avctx, buf+offset, size);
767     }
768
769     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
770         ff_er_frame_end(s);
771         MPV_frame_end(s);
772
773         if (s->pict_type == FF_B_TYPE || s->low_delay) {
774             *pict= *(AVFrame*)s->current_picture_ptr;
775         } else if (s->last_picture_ptr != NULL) {
776             *pict= *(AVFrame*)s->last_picture_ptr;
777         }
778
779         if(s->last_picture_ptr || s->low_delay){
780             *data_size = sizeof(AVFrame);
781             ff_print_debug_info(s, pict);
782         }
783         s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
784     }
785
786     return buf_size;
787 }
788
789 AVCodec rv10_decoder = {
790     "rv10",
791     CODEC_TYPE_VIDEO,
792     CODEC_ID_RV10,
793     sizeof(MpegEncContext),
794     rv10_decode_init,
795     NULL,
796     rv10_decode_end,
797     rv10_decode_frame,
798     CODEC_CAP_DR1,
799     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
800     .pix_fmts= ff_pixfmt_list_420,
801 };
802
803 AVCodec rv20_decoder = {
804     "rv20",
805     CODEC_TYPE_VIDEO,
806     CODEC_ID_RV20,
807     sizeof(MpegEncContext),
808     rv10_decode_init,
809     NULL,
810     rv10_decode_end,
811     rv10_decode_frame,
812     CODEC_CAP_DR1 | CODEC_CAP_DELAY,
813     .flush= ff_mpeg_flush,
814     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
815     .pix_fmts= ff_pixfmt_list_420,
816 };
817