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