svq3: use hpeldsp instead of dsputil for half-pel functions.
[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 "error_resilience.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 #define ERROR_SKIP_FRAME -123
424             return ERROR_SKIP_FRAME;
425         }
426         ff_mpeg4_init_direct_mv(s);
427     }
428
429     s->no_rounding= get_bits1(&s->gb);
430
431     if(RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
432         skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
433
434     s->f_code = 1;
435     s->unrestricted_mv = 1;
436     s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
437 //    s->alt_inter_vlc=1;
438 //    s->obmc=1;
439 //    s->umvplus=1;
440     s->modified_quant=1;
441     if(!s->avctx->lowres)
442         s->loop_filter=1;
443
444     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
445             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
446                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
447     }
448
449     av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
450
451     return s->mb_width*s->mb_height - mb_pos;
452 }
453
454 static av_cold int rv10_decode_init(AVCodecContext *avctx)
455 {
456     RVDecContext  *rv = avctx->priv_data;
457     MpegEncContext *s = &rv->m;
458     static int done=0;
459     int major_ver, minor_ver, micro_ver;
460
461     if (avctx->extradata_size < 8) {
462         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
463         return -1;
464     }
465
466     ff_MPV_decode_defaults(s);
467
468     s->avctx= avctx;
469     s->out_format = FMT_H263;
470     s->codec_id= avctx->codec_id;
471
472     s->orig_width = s->width  = avctx->coded_width;
473     s->orig_height= s->height = avctx->coded_height;
474
475     s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
476     rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
477
478     major_ver = RV_GET_MAJOR_VER(rv->sub_id);
479     minor_ver = RV_GET_MINOR_VER(rv->sub_id);
480     micro_ver = RV_GET_MICRO_VER(rv->sub_id);
481
482     s->low_delay = 1;
483     switch (major_ver) {
484     case 1:
485         s->rv10_version = micro_ver ? 3 : 1;
486         s->obmc = micro_ver == 2;
487         break;
488     case 2:
489         if (minor_ver >= 2) {
490             s->low_delay = 0;
491             s->avctx->has_b_frames = 1;
492         }
493         break;
494     default:
495         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
496         av_log_missing_feature(avctx, "RV1/2 version", 1);
497         return AVERROR_PATCHWELCOME;
498     }
499
500     if(avctx->debug & FF_DEBUG_PICT_INFO){
501         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id, ((uint32_t*)avctx->extradata)[0]);
502     }
503
504     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
505
506     if (ff_MPV_common_init(s) < 0)
507         return -1;
508
509     ff_h263_decode_init_vlc();
510
511     /* init rv vlc */
512     if (!done) {
513         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
514                  rv_lum_bits, 1, 1,
515                  rv_lum_code, 2, 2, 16384);
516         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
517                  rv_chrom_bits, 1, 1,
518                  rv_chrom_code, 2, 2, 16388);
519         done = 1;
520     }
521
522     return 0;
523 }
524
525 static av_cold int rv10_decode_end(AVCodecContext *avctx)
526 {
527     MpegEncContext *s = avctx->priv_data;
528
529     ff_MPV_common_end(s);
530     return 0;
531 }
532
533 static int rv10_decode_packet(AVCodecContext *avctx,
534                              const uint8_t *buf, int buf_size, int buf_size2)
535 {
536     RVDecContext  *rv = avctx->priv_data;
537     MpegEncContext *s = &rv->m;
538     int mb_count, mb_pos, left, start_mb_x, active_bits_size;
539
540     active_bits_size = buf_size * 8;
541     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
542     if(s->codec_id ==AV_CODEC_ID_RV10)
543         mb_count = rv10_decode_picture_header(s);
544     else
545         mb_count = rv20_decode_picture_header(rv);
546     if (mb_count < 0) {
547         if (mb_count != ERROR_SKIP_FRAME)
548             av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
549         return -1;
550     }
551
552     if (s->mb_x >= s->mb_width ||
553         s->mb_y >= s->mb_height) {
554         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
555         return -1;
556     }
557     mb_pos = s->mb_y * s->mb_width + s->mb_x;
558     left = s->mb_width * s->mb_height - mb_pos;
559     if (mb_count > left) {
560         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
561         return -1;
562     }
563
564     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
565         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
566             ff_er_frame_end(&s->er);
567             ff_MPV_frame_end(s);
568             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
569         }
570         if(ff_MPV_frame_start(s, avctx) < 0)
571             return -1;
572         ff_mpeg_er_frame_start(s);
573     } else {
574         if (s->current_picture_ptr->f.pict_type != s->pict_type) {
575             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
576             return -1;
577         }
578     }
579
580
581     av_dlog(avctx, "qscale=%d\n", s->qscale);
582
583     /* default quantization values */
584     if(s->codec_id== AV_CODEC_ID_RV10){
585         if(s->mb_y==0) s->first_slice_line=1;
586     }else{
587         s->first_slice_line=1;
588         s->resync_mb_x= s->mb_x;
589     }
590     start_mb_x= s->mb_x;
591     s->resync_mb_y= s->mb_y;
592     if(s->h263_aic){
593         s->y_dc_scale_table=
594         s->c_dc_scale_table= ff_aic_dc_scale_table;
595     }else{
596         s->y_dc_scale_table=
597         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
598     }
599
600     if(s->modified_quant)
601         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
602
603     ff_set_qscale(s, s->qscale);
604
605     s->rv10_first_dc_coded[0] = 0;
606     s->rv10_first_dc_coded[1] = 0;
607     s->rv10_first_dc_coded[2] = 0;
608     s->block_wrap[0]=
609     s->block_wrap[1]=
610     s->block_wrap[2]=
611     s->block_wrap[3]= s->b8_stride;
612     s->block_wrap[4]=
613     s->block_wrap[5]= s->mb_stride;
614     ff_init_block_index(s);
615     /* decode each macroblock */
616
617     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
618         int ret;
619         ff_update_block_index(s);
620         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
621
622         s->mv_dir = MV_DIR_FORWARD;
623         s->mv_type = MV_TYPE_16X16;
624         ret=ff_h263_decode_mb(s, s->block);
625
626         // Repeat the slice end check from ff_h263_decode_mb with our active
627         // bitstream size
628         if (ret != SLICE_ERROR) {
629             int v = show_bits(&s->gb, 16);
630
631             if (get_bits_count(&s->gb) + 16 > active_bits_size)
632                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
633
634             if (!v)
635                 ret = SLICE_END;
636         }
637         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
638             8 * buf_size2 >= get_bits_count(&s->gb)) {
639             active_bits_size = buf_size2 * 8;
640             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
641                    8 * buf_size, active_bits_size);
642             ret= SLICE_OK;
643         }
644
645         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
646             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
647             return -1;
648         }
649         if(s->pict_type != AV_PICTURE_TYPE_B)
650             ff_h263_update_motion_val(s);
651         ff_MPV_decode_mb(s, s->block);
652         if(s->loop_filter)
653             ff_h263_loop_filter(s);
654
655         if (++s->mb_x == s->mb_width) {
656             s->mb_x = 0;
657             s->mb_y++;
658             ff_init_block_index(s);
659         }
660         if(s->mb_x == s->resync_mb_x)
661             s->first_slice_line=0;
662         if(ret == SLICE_END) break;
663     }
664
665     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
666
667     return active_bits_size;
668 }
669
670 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
671 {
672     if(avctx->slice_count) return avctx->slice_offset[n];
673     else                   return AV_RL32(buf + n*8);
674 }
675
676 static int rv10_decode_frame(AVCodecContext *avctx,
677                              void *data, int *got_frame,
678                              AVPacket *avpkt)
679 {
680     const uint8_t *buf = avpkt->data;
681     int buf_size = avpkt->size;
682     MpegEncContext *s = avctx->priv_data;
683     int i, ret;
684     AVFrame *pict = data;
685     int slice_count;
686     const uint8_t *slices_hdr = NULL;
687
688     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
689     s->flags  = avctx->flags;
690     s->flags2 = avctx->flags2;
691
692     /* no supplementary picture */
693     if (buf_size == 0) {
694         return 0;
695     }
696
697     if(!avctx->slice_count){
698         slice_count = (*buf++) + 1;
699         buf_size--;
700
701         if (!slice_count || buf_size <= 8 * slice_count) {
702             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
703             return AVERROR_INVALIDDATA;
704         }
705
706         slices_hdr = buf + 4;
707         buf += 8 * slice_count;
708         buf_size -= 8 * slice_count;
709     }else
710         slice_count = avctx->slice_count;
711
712     for(i=0; i<slice_count; i++){
713         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
714         int size, size2;
715
716         if (offset >= buf_size)
717             return AVERROR_INVALIDDATA;
718
719         if(i+1 == slice_count)
720             size= buf_size - offset;
721         else
722             size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
723
724         if(i+2 >= slice_count)
725             size2= buf_size - offset;
726         else
727             size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
728
729         if (size <= 0 || size2 <= 0 ||
730             offset + FFMAX(size, size2) > buf_size)
731             return AVERROR_INVALIDDATA;
732
733         if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
734             i++;
735     }
736
737     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
738         ff_er_frame_end(&s->er);
739         ff_MPV_frame_end(s);
740
741         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
742             if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
743                 return ret;
744             ff_print_debug_info(s, s->current_picture_ptr, pict);
745         } else if (s->last_picture_ptr != NULL) {
746             if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
747                 return ret;
748             ff_print_debug_info(s, s->last_picture_ptr, pict);
749         }
750
751         if(s->last_picture_ptr || s->low_delay){
752             *got_frame = 1;
753         }
754         s->current_picture_ptr= NULL; // so we can detect if frame_end was not called (find some nicer solution...)
755     }
756
757     return avpkt->size;
758 }
759
760 AVCodec ff_rv10_decoder = {
761     .name           = "rv10",
762     .type           = AVMEDIA_TYPE_VIDEO,
763     .id             = AV_CODEC_ID_RV10,
764     .priv_data_size = sizeof(RVDecContext),
765     .init           = rv10_decode_init,
766     .close          = rv10_decode_end,
767     .decode         = rv10_decode_frame,
768     .capabilities   = CODEC_CAP_DR1,
769     .max_lowres     = 3,
770     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
771     .pix_fmts       = ff_pixfmt_list_420,
772 };
773
774 AVCodec ff_rv20_decoder = {
775     .name           = "rv20",
776     .type           = AVMEDIA_TYPE_VIDEO,
777     .id             = AV_CODEC_ID_RV20,
778     .priv_data_size = sizeof(RVDecContext),
779     .init           = rv10_decode_init,
780     .close          = rv10_decode_end,
781     .decode         = rv10_decode_frame,
782     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
783     .flush          = ff_mpeg_flush,
784     .max_lowres     = 3,
785     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
786     .pix_fmts       = ff_pixfmt_list_420,
787 };