6050d5e9f233c88ee16a17ef5dfbbea769883fe7
[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 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
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 #if 0
308     GetBitContext gb= s->gb;
309     for(i=0; i<64; i++){
310         av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
311         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
312     }
313     av_log(s->avctx, AV_LOG_DEBUG, "\n");
314 #endif
315 #if 0
316     av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
317     for(i=0; i<s->avctx->extradata_size; i++){
318         av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
319         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
320     }
321     av_log(s->avctx, AV_LOG_DEBUG, "\n");
322 #endif
323
324     i= get_bits(&s->gb, 2);
325     switch(i){
326     case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
327     case 1: s->pict_type= AV_PICTURE_TYPE_I; break; //hmm ...
328     case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
329     case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
330     default:
331         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
332         return -1;
333     }
334
335     if(s->low_delay && s->pict_type==AV_PICTURE_TYPE_B){
336         av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
337         return -1;
338     }
339     if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
340         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
341         return -1;
342     }
343
344     if (get_bits1(&s->gb)){
345         av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
346         return -1;
347     }
348
349     s->qscale = get_bits(&s->gb, 5);
350     if(s->qscale==0){
351         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
352         return -1;
353     }
354
355     if(RV_GET_MINOR_VER(rv->sub_id) >= 2)
356         s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
357
358     if(RV_GET_MINOR_VER(rv->sub_id) <= 1)
359         seq = get_bits(&s->gb, 8) << 7;
360     else
361         seq = get_bits(&s->gb, 13) << 2;
362
363     rpr_bits = s->avctx->extradata[1] & 7;
364     if(rpr_bits){
365         int f, new_w, new_h;
366         rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
367
368         f = get_bits(&s->gb, rpr_bits);
369
370         if(f){
371             new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
372             new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
373         }else{
374             new_w= s->orig_width ;
375             new_h= s->orig_height;
376         }
377         if(new_w != s->width || new_h != s->height){
378             AVRational old_aspect = s->avctx->sample_aspect_ratio;
379             av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
380             if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
381                 return -1;
382             ff_MPV_common_end(s);
383
384             // attempt to keep aspect during typical resolution switches
385             if (!old_aspect.num)
386                 old_aspect = (AVRational){1, 1};
387             if (2 * new_w * s->height == new_h * s->width)
388                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
389             if (new_w * s->height == 2 * new_h * s->width)
390                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
391             avcodec_set_dimensions(s->avctx, new_w, new_h);
392             s->width  = new_w;
393             s->height = new_h;
394             if (ff_MPV_common_init(s) < 0)
395                 return -1;
396         }
397
398         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
399             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
400         }
401     }
402     if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
403         return AVERROR_INVALIDDATA;
404
405     mb_pos = ff_h263_decode_mba(s);
406
407     seq |= s->time &~0x7FFF;
408     if(seq - s->time >  0x4000) seq -= 0x8000;
409     if(seq - s->time < -0x4000) seq += 0x8000;
410     if(seq != s->time){
411         if(s->pict_type!=AV_PICTURE_TYPE_B){
412             s->time= seq;
413             s->pp_time= s->time - s->last_non_b_time;
414             s->last_non_b_time= s->time;
415         }else{
416             s->time= seq;
417             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
418         }
419     }
420     if (s->pict_type==AV_PICTURE_TYPE_B) {
421         if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
422             av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
423             return FRAME_SKIPPED;
424         }
425         ff_mpeg4_init_direct_mv(s);
426     }
427
428     s->no_rounding= get_bits1(&s->gb);
429
430     if(RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
431         skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
432
433     s->f_code = 1;
434     s->unrestricted_mv = 1;
435     s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
436 //    s->alt_inter_vlc=1;
437 //    s->obmc=1;
438 //    s->umvplus=1;
439     s->modified_quant=1;
440     if(!s->avctx->lowres)
441         s->loop_filter=1;
442
443     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
444             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
445                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
446     }
447
448     av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
449
450     return s->mb_width*s->mb_height - mb_pos;
451 }
452
453 static av_cold int rv10_decode_init(AVCodecContext *avctx)
454 {
455     RVDecContext  *rv = avctx->priv_data;
456     MpegEncContext *s = &rv->m;
457     static int done=0;
458     int major_ver, minor_ver, micro_ver;
459
460     if (avctx->extradata_size < 8) {
461         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
462         return -1;
463     }
464
465     ff_MPV_decode_defaults(s);
466
467     s->avctx= avctx;
468     s->out_format = FMT_H263;
469     s->codec_id= avctx->codec_id;
470
471     s->orig_width = s->width  = avctx->coded_width;
472     s->orig_height= s->height = avctx->coded_height;
473
474     s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
475     rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
476
477     major_ver = RV_GET_MAJOR_VER(rv->sub_id);
478     minor_ver = RV_GET_MINOR_VER(rv->sub_id);
479     micro_ver = RV_GET_MICRO_VER(rv->sub_id);
480
481     s->low_delay = 1;
482     switch (major_ver) {
483     case 1:
484         s->rv10_version = micro_ver ? 3 : 1;
485         s->obmc = micro_ver == 2;
486         break;
487     case 2:
488         if (minor_ver >= 2) {
489             s->low_delay = 0;
490             s->avctx->has_b_frames = 1;
491         }
492         break;
493     default:
494         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
495         av_log_missing_feature(avctx, "RV1/2 version", 1);
496         return AVERROR_PATCHWELCOME;
497     }
498
499     if(avctx->debug & FF_DEBUG_PICT_INFO){
500         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id, ((uint32_t*)avctx->extradata)[0]);
501     }
502
503     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
504
505     if (ff_MPV_common_init(s) < 0)
506         return -1;
507
508     ff_h263_decode_init_vlc();
509
510     /* init rv vlc */
511     if (!done) {
512         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
513                  rv_lum_bits, 1, 1,
514                  rv_lum_code, 2, 2, 16384);
515         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
516                  rv_chrom_bits, 1, 1,
517                  rv_chrom_code, 2, 2, 16388);
518         done = 1;
519     }
520
521     return 0;
522 }
523
524 static av_cold int rv10_decode_end(AVCodecContext *avctx)
525 {
526     MpegEncContext *s = avctx->priv_data;
527
528     ff_MPV_common_end(s);
529     return 0;
530 }
531
532 static int rv10_decode_packet(AVCodecContext *avctx,
533                              const uint8_t *buf, int buf_size, int buf_size2)
534 {
535     RVDecContext  *rv = avctx->priv_data;
536     MpegEncContext *s = &rv->m;
537     int mb_count, mb_pos, left, start_mb_x, active_bits_size;
538
539     active_bits_size = buf_size * 8;
540     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
541     if(s->codec_id ==AV_CODEC_ID_RV10)
542         mb_count = rv10_decode_picture_header(s);
543     else
544         mb_count = rv20_decode_picture_header(rv);
545     if (mb_count < 0) {
546         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
547         return -1;
548     }
549
550     if (s->mb_x >= s->mb_width ||
551         s->mb_y >= s->mb_height) {
552         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
553         return -1;
554     }
555     mb_pos = s->mb_y * s->mb_width + s->mb_x;
556     left = s->mb_width * s->mb_height - mb_pos;
557     if (mb_count > left) {
558         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
559         return -1;
560     }
561
562     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
563         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
564             ff_er_frame_end(s);
565             ff_MPV_frame_end(s);
566             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
567         }
568         if(ff_MPV_frame_start(s, avctx) < 0)
569             return -1;
570         ff_er_frame_start(s);
571     } else {
572         if (s->current_picture_ptr->f.pict_type != s->pict_type) {
573             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
574             return -1;
575         }
576     }
577
578
579     av_dlog(avctx, "qscale=%d\n", s->qscale);
580
581     /* default quantization values */
582     if(s->codec_id== AV_CODEC_ID_RV10){
583         if(s->mb_y==0) s->first_slice_line=1;
584     }else{
585         s->first_slice_line=1;
586         s->resync_mb_x= s->mb_x;
587     }
588     start_mb_x= s->mb_x;
589     s->resync_mb_y= s->mb_y;
590     if(s->h263_aic){
591         s->y_dc_scale_table=
592         s->c_dc_scale_table= ff_aic_dc_scale_table;
593     }else{
594         s->y_dc_scale_table=
595         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
596     }
597
598     if(s->modified_quant)
599         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
600
601     ff_set_qscale(s, s->qscale);
602
603     s->rv10_first_dc_coded[0] = 0;
604     s->rv10_first_dc_coded[1] = 0;
605     s->rv10_first_dc_coded[2] = 0;
606     s->block_wrap[0]=
607     s->block_wrap[1]=
608     s->block_wrap[2]=
609     s->block_wrap[3]= s->b8_stride;
610     s->block_wrap[4]=
611     s->block_wrap[5]= s->mb_stride;
612     ff_init_block_index(s);
613     /* decode each macroblock */
614
615     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
616         int ret;
617         ff_update_block_index(s);
618         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
619
620         s->mv_dir = MV_DIR_FORWARD;
621         s->mv_type = MV_TYPE_16X16;
622         ret=ff_h263_decode_mb(s, s->block);
623
624         // Repeat the slice end check from ff_h263_decode_mb with our active
625         // bitstream size
626         if (ret != SLICE_ERROR) {
627             int v = show_bits(&s->gb, 16);
628
629             if (get_bits_count(&s->gb) + 16 > active_bits_size)
630                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
631
632             if (!v)
633                 ret = SLICE_END;
634         }
635         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
636             8 * buf_size2 >= get_bits_count(&s->gb)) {
637             active_bits_size = buf_size2 * 8;
638             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
639                    8 * buf_size, active_bits_size);
640             ret= SLICE_OK;
641         }
642
643         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
644             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
645             return -1;
646         }
647         if(s->pict_type != AV_PICTURE_TYPE_B)
648             ff_h263_update_motion_val(s);
649         ff_MPV_decode_mb(s, s->block);
650         if(s->loop_filter)
651             ff_h263_loop_filter(s);
652
653         if (++s->mb_x == s->mb_width) {
654             s->mb_x = 0;
655             s->mb_y++;
656             ff_init_block_index(s);
657         }
658         if(s->mb_x == s->resync_mb_x)
659             s->first_slice_line=0;
660         if(ret == SLICE_END) break;
661     }
662
663     ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
664
665     return active_bits_size;
666 }
667
668 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
669 {
670     if(avctx->slice_count) return avctx->slice_offset[n];
671     else                   return AV_RL32(buf + n*8);
672 }
673
674 static int rv10_decode_frame(AVCodecContext *avctx,
675                              void *data, int *got_frame,
676                              AVPacket *avpkt)
677 {
678     const uint8_t *buf = avpkt->data;
679     int buf_size = avpkt->size;
680     MpegEncContext *s = avctx->priv_data;
681     int i;
682     AVFrame *pict = data;
683     int slice_count;
684     const uint8_t *slices_hdr = NULL;
685
686     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
687     s->flags  = avctx->flags;
688     s->flags2 = avctx->flags2;
689
690     /* no supplementary picture */
691     if (buf_size == 0) {
692         return 0;
693     }
694
695     if(!avctx->slice_count){
696         slice_count = (*buf++) + 1;
697         buf_size--;
698
699         if (!slice_count || buf_size <= 8 * slice_count) {
700             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
701             return AVERROR_INVALIDDATA;
702         }
703
704         slices_hdr = buf + 4;
705         buf += 8 * slice_count;
706         buf_size -= 8 * slice_count;
707     }else
708         slice_count = avctx->slice_count;
709
710     for(i=0; i<slice_count; i++){
711         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
712         int size, size2;
713
714         if (offset >= buf_size)
715             return AVERROR_INVALIDDATA;
716
717         if(i+1 == slice_count)
718             size= buf_size - offset;
719         else
720             size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
721
722         if(i+2 >= slice_count)
723             size2= buf_size - offset;
724         else
725             size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
726
727         if (size <= 0 || size2 <= 0 ||
728             offset + FFMAX(size, size2) > buf_size)
729             return AVERROR_INVALIDDATA;
730
731         if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
732             i++;
733     }
734
735     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
736         ff_er_frame_end(s);
737         ff_MPV_frame_end(s);
738
739         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
740             *pict = s->current_picture_ptr->f;
741         } else if (s->last_picture_ptr != NULL) {
742             *pict = s->last_picture_ptr->f;
743         }
744
745         if(s->last_picture_ptr || s->low_delay){
746             *got_frame = 1;
747             ff_print_debug_info(s, pict);
748         }
749         s->current_picture_ptr= NULL; // so we can detect if frame_end was not called (find some nicer solution...)
750     }
751
752     return avpkt->size;
753 }
754
755 AVCodec ff_rv10_decoder = {
756     .name           = "rv10",
757     .type           = AVMEDIA_TYPE_VIDEO,
758     .id             = AV_CODEC_ID_RV10,
759     .priv_data_size = sizeof(RVDecContext),
760     .init           = rv10_decode_init,
761     .close          = rv10_decode_end,
762     .decode         = rv10_decode_frame,
763     .capabilities   = CODEC_CAP_DR1,
764     .max_lowres     = 3,
765     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
766     .pix_fmts       = ff_pixfmt_list_420,
767 };
768
769 AVCodec ff_rv20_decoder = {
770     .name           = "rv20",
771     .type           = AVMEDIA_TYPE_VIDEO,
772     .id             = AV_CODEC_ID_RV20,
773     .priv_data_size = sizeof(RVDecContext),
774     .init           = rv10_decode_init,
775     .close          = rv10_decode_end,
776     .decode         = rv10_decode_frame,
777     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
778     .flush          = ff_mpeg_flush,
779     .max_lowres     = 3,
780     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
781     .pix_fmts       = ff_pixfmt_list_420,
782 };