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