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