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