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