Merge commit '3c650efb81aaa3b395ba4606ee68a47ee4efb57b'
[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 } RVDecContext;
50
51 static const uint16_t rv_lum_code[256] = {
52     0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
53     0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
54     0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
55     0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
56     0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
57     0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
58     0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
59     0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
60     0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
61     0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
62     0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
63     0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
64     0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
65     0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
66     0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
67     0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
68     0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
69     0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
70     0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
71     0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
72     0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
73     0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
74     0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
75     0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
76     0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
77     0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
78     0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
79     0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
80     0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
81     0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
82     0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
83     0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
84 };
85
86 static const uint8_t rv_lum_bits[256] = {
87     14, 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, 12, 12, 12, 12, 12, 12, 12,
95     12, 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, 10, 10, 10, 10, 10, 10, 10,
99     10,  8,  8,  8,  8,  8,  8,  8,
100      8,  8,  8,  8,  8,  8,  8,  8,
101      8,  7,  7,  7,  7,  7,  7,  7,
102      7,  6,  6,  6,  6,  5,  5,  4,
103      2,  4,  5,  5,  6,  6,  6,  6,
104      7,  7,  7,  7,  7,  7,  7,  7,
105      8,  8,  8,  8,  8,  8,  8,  8,
106      8,  8,  8,  8,  8,  8,  8,  8,
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     10, 10, 10, 10, 10, 10, 10, 10,
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     12, 12, 12, 12, 12, 12, 12, 12,
119 };
120
121 static const uint16_t rv_chrom_code[256] = {
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     16, 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, 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, 12, 12, 12, 12, 12, 12, 12,
166     12, 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, 10, 10, 10, 10, 10, 10, 10,
170     10, 10, 10, 10, 10, 10, 10, 10,
171     10,  8,  8,  8,  8,  8,  8,  8,
172      8,  6,  6,  6,  6,  4,  4,  3,
173      2,  3,  4,  4,  6,  6,  6,  6,
174      8,  8,  8,  8,  8,  8,  8,  8,
175     10, 10, 10, 10, 10, 10, 10, 10,
176     10, 10, 10, 10, 10, 10, 10, 10,
177     12, 12, 12, 12, 12, 12, 12, 12,
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     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     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 };
190
191 static VLC rv_dc_lum, rv_dc_chrom;
192
193 int ff_rv_decode_dc(MpegEncContext *s, int n)
194 {
195     int code;
196
197     if (n < 4) {
198         code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
199         if (code < 0) {
200             /* XXX: I don't understand why they use LONGER codes than
201              * necessary. The following code would be completely useless
202              * if they had thought about it !!! */
203             code = get_bits(&s->gb, 7);
204             if (code == 0x7c) {
205                 code = (int8_t) (get_bits(&s->gb, 7) + 1);
206             } else if (code == 0x7d) {
207                 code = -128 + get_bits(&s->gb, 7);
208             } else if (code == 0x7e) {
209                 if (get_bits1(&s->gb) == 0)
210                     code = (int8_t) (get_bits(&s->gb, 8) + 1);
211                 else
212                     code = (int8_t) (get_bits(&s->gb, 8));
213             } else if (code == 0x7f) {
214                 skip_bits(&s->gb, 11);
215                 code = 1;
216             }
217         } else {
218             code -= 128;
219         }
220     } else {
221         code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
222         /* same remark */
223         if (code < 0) {
224             code = get_bits(&s->gb, 9);
225             if (code == 0x1fc) {
226                 code = (int8_t) (get_bits(&s->gb, 7) + 1);
227             } else if (code == 0x1fd) {
228                 code = -128 + get_bits(&s->gb, 7);
229             } else if (code == 0x1fe) {
230                 skip_bits(&s->gb, 9);
231                 code = 1;
232             } else {
233                 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
234                 return 0xffff;
235             }
236         } else {
237             code -= 128;
238         }
239     }
240     return -code;
241 }
242
243 /* read RV 1.0 compatible frame header */
244 static int rv10_decode_picture_header(MpegEncContext *s)
245 {
246     int mb_count, pb_frame, marker, mb_xy;
247
248     marker = get_bits1(&s->gb);
249
250     if (get_bits1(&s->gb))
251         s->pict_type = AV_PICTURE_TYPE_P;
252     else
253         s->pict_type = AV_PICTURE_TYPE_I;
254
255     if (!marker)
256         av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
257
258     pb_frame = get_bits1(&s->gb);
259
260     av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
261
262     if (pb_frame) {
263         avpriv_request_sample(s->avctx, "pb frame");
264         return AVERROR_PATCHWELCOME;
265     }
266
267     s->qscale = get_bits(&s->gb, 5);
268     if (s->qscale == 0) {
269         av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
270         return AVERROR_INVALIDDATA;
271     }
272
273     if (s->pict_type == AV_PICTURE_TYPE_I) {
274         if (s->rv10_version == 3) {
275             /* specific MPEG like DC coding not used */
276             s->last_dc[0] = get_bits(&s->gb, 8);
277             s->last_dc[1] = get_bits(&s->gb, 8);
278             s->last_dc[2] = get_bits(&s->gb, 8);
279             av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
280                     s->last_dc[1], s->last_dc[2]);
281         }
282     }
283     /* if multiple packets per frame are sent, the position at which
284      * to display the macroblocks is coded here */
285
286     mb_xy = s->mb_x + s->mb_y * s->mb_width;
287     if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
288         s->mb_x  = get_bits(&s->gb, 6); /* mb_x */
289         s->mb_y  = get_bits(&s->gb, 6); /* mb_y */
290         mb_count = get_bits(&s->gb, 12);
291     } else {
292         s->mb_x  = 0;
293         s->mb_y  = 0;
294         mb_count = s->mb_width * s->mb_height;
295     }
296     skip_bits(&s->gb, 3);   /* ignored */
297     s->f_code          = 1;
298     s->unrestricted_mv = 1;
299
300     return mb_count;
301 }
302
303 static int rv20_decode_picture_header(RVDecContext *rv)
304 {
305     MpegEncContext *s = &rv->m;
306     int seq, mb_pos, i, ret;
307     int rpr_max;
308
309     i = get_bits(&s->gb, 2);
310     switch (i) {
311     case 0:
312         s->pict_type = AV_PICTURE_TYPE_I;
313         break;
314     case 1:
315         s->pict_type = AV_PICTURE_TYPE_I;
316         break;                                  // hmm ...
317     case 2:
318         s->pict_type = AV_PICTURE_TYPE_P;
319         break;
320     case 3:
321         s->pict_type = AV_PICTURE_TYPE_B;
322         break;
323     default:
324         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
325         return AVERROR_INVALIDDATA;
326     }
327
328     if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
329         av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
330         return -1;
331     }
332     if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
333         av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
334         return AVERROR_INVALIDDATA;
335     }
336
337     if (get_bits1(&s->gb)) {
338         av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
339         return AVERROR_INVALIDDATA;
340     }
341
342     s->qscale = get_bits(&s->gb, 5);
343     if (s->qscale == 0) {
344         av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
345         return AVERROR_INVALIDDATA;
346     }
347
348     if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
349         s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
350
351     if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
352         seq = get_bits(&s->gb, 8) << 7;
353     else
354         seq = get_bits(&s->gb, 13) << 2;
355
356     rpr_max = s->avctx->extradata[1] & 7;
357     if (rpr_max) {
358         int f, new_w, new_h;
359         int rpr_bits = av_log2(rpr_max) + 1;
360
361         f = get_bits(&s->gb, rpr_bits);
362
363         if (f) {
364             if (s->avctx->extradata_size < 8 + 2 * f) {
365                 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
366                 return AVERROR_INVALIDDATA;
367             }
368
369             new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];
370             new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];
371         } else {
372             new_w = s->orig_width;
373             new_h = s->orig_height;
374         }
375         if (new_w != s->width || new_h != s->height) {
376             AVRational old_aspect = s->avctx->sample_aspect_ratio;
377             av_log(s->avctx, AV_LOG_DEBUG,
378                    "attempting to change resolution to %dx%d\n", new_w, new_h);
379             if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
380                 return AVERROR_INVALIDDATA;
381             ff_MPV_common_end(s);
382
383             // attempt to keep aspect during typical resolution switches
384             if (!old_aspect.num)
385                 old_aspect = (AVRational){1, 1};
386             if (2 * new_w * s->height == new_h * s->width)
387                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
388             if (new_w * s->height == 2 * new_h * s->width)
389                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
390
391             ret = ff_set_dimensions(s->avctx, new_w, new_h);
392             if (ret < 0)
393                 return ret;
394
395             s->width  = new_w;
396             s->height = new_h;
397             if ((ret = ff_MPV_common_init(s)) < 0)
398                 return ret;
399         }
400
401         if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
402             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max);
403         }
404     }
405     if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
406         return AVERROR_INVALIDDATA;
407
408     mb_pos = ff_h263_decode_mba(s);
409
410     seq |= s->time & ~0x7FFF;
411     if (seq - s->time >  0x4000)
412         seq -= 0x8000;
413     if (seq - s->time < -0x4000)
414         seq += 0x8000;
415
416     if (seq != s->time) {
417         if (s->pict_type != AV_PICTURE_TYPE_B) {
418             s->time            = seq;
419             s->pp_time         = s->time - s->last_non_b_time;
420             s->last_non_b_time = s->time;
421         } else {
422             s->time    = seq;
423             s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
424         }
425     }
426     if (s->pict_type == AV_PICTURE_TYPE_B) {
427         if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
428             av_log(s->avctx, AV_LOG_DEBUG,
429                    "messed up order, possible from seeking? skipping current b frame\n");
430 #define ERROR_SKIP_FRAME -123
431             return ERROR_SKIP_FRAME;
432         }
433         ff_mpeg4_init_direct_mv(s);
434     }
435
436     s->no_rounding = get_bits1(&s->gb);
437
438     if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
439         // binary decoder reads 3+2 bits here but they don't seem to be used
440         skip_bits(&s->gb, 5);
441
442     s->f_code          = 1;
443     s->unrestricted_mv = 1;
444     s->h263_aic        = s->pict_type == AV_PICTURE_TYPE_I;
445     s->modified_quant  = 1;
446     if (!s->avctx->lowres)
447         s->loop_filter = 1;
448
449     if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
450         av_log(s->avctx, AV_LOG_INFO,
451                "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
452                seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,
453                s->no_rounding);
454     }
455
456     av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
457
458     return s->mb_width * s->mb_height - mb_pos;
459 }
460
461 static av_cold int rv10_decode_init(AVCodecContext *avctx)
462 {
463     RVDecContext *rv = avctx->priv_data;
464     MpegEncContext *s = &rv->m;
465     static int done = 0;
466     int major_ver, minor_ver, micro_ver, ret;
467
468     if (avctx->extradata_size < 8) {
469         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
470         return AVERROR_INVALIDDATA;
471     }
472     if ((ret = av_image_check_size(avctx->coded_width,
473                                    avctx->coded_height, 0, avctx)) < 0)
474         return ret;
475
476     ff_MPV_decode_defaults(s);
477
478     s->avctx       = avctx;
479     s->out_format  = FMT_H263;
480     s->codec_id    = avctx->codec_id;
481
482     s->orig_width  =
483     s->width       = avctx->coded_width;
484     s->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     if ((ret = ff_MPV_common_init(s)) < 0)
520         return ret;
521
522     ff_h263dsp_init(&s->h263dsp);
523     ff_h263_decode_init_vlc();
524
525     /* init rv vlc */
526     if (!done) {
527         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
528                         rv_lum_bits, 1, 1,
529                         rv_lum_code, 2, 2, 16384);
530         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
531                         rv_chrom_bits, 1, 1,
532                         rv_chrom_code, 2, 2, 16388);
533         done = 1;
534     }
535
536     return 0;
537 }
538
539 static av_cold int rv10_decode_end(AVCodecContext *avctx)
540 {
541     MpegEncContext *s = avctx->priv_data;
542
543     ff_MPV_common_end(s);
544     return 0;
545 }
546
547 static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
548                               int buf_size, int buf_size2)
549 {
550     RVDecContext *rv = avctx->priv_data;
551     MpegEncContext *s = &rv->m;
552     int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
553
554     active_bits_size = buf_size * 8;
555     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
556     if (s->codec_id == AV_CODEC_ID_RV10)
557         mb_count = rv10_decode_picture_header(s);
558     else
559         mb_count = rv20_decode_picture_header(rv);
560     if (mb_count < 0) {
561         if (mb_count != ERROR_SKIP_FRAME)
562             av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
563         return AVERROR_INVALIDDATA;
564     }
565
566     if (s->mb_x >= s->mb_width ||
567         s->mb_y >= s->mb_height) {
568         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
569         return AVERROR_INVALIDDATA;
570     }
571     mb_pos = s->mb_y * s->mb_width + s->mb_x;
572     left   = s->mb_width * s->mb_height - mb_pos;
573     if (mb_count > left) {
574         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
575         return AVERROR_INVALIDDATA;
576     }
577
578     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
579         // FIXME write parser so we always have complete frames?
580         if (s->current_picture_ptr) {
581             ff_er_frame_end(&s->er);
582             ff_MPV_frame_end(s);
583             s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
584         }
585         if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
586             return ret;
587         ff_mpeg_er_frame_start(s);
588     } else {
589         if (s->current_picture_ptr->f->pict_type != s->pict_type) {
590             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
591             return AVERROR_INVALIDDATA;
592         }
593     }
594
595
596     av_dlog(avctx, "qscale=%d\n", s->qscale);
597
598     /* default quantization values */
599     if (s->codec_id == AV_CODEC_ID_RV10) {
600         if (s->mb_y == 0)
601             s->first_slice_line = 1;
602     } else {
603         s->first_slice_line = 1;
604         s->resync_mb_x      = s->mb_x;
605     }
606     start_mb_x     = s->mb_x;
607     s->resync_mb_y = s->mb_y;
608     if (s->h263_aic) {
609         s->y_dc_scale_table =
610         s->c_dc_scale_table = ff_aic_dc_scale_table;
611     } else {
612         s->y_dc_scale_table =
613         s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
614     }
615
616     if (s->modified_quant)
617         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
618
619     ff_set_qscale(s, s->qscale);
620
621     s->rv10_first_dc_coded[0] = 0;
622     s->rv10_first_dc_coded[1] = 0;
623     s->rv10_first_dc_coded[2] = 0;
624     s->block_wrap[0] =
625     s->block_wrap[1] =
626     s->block_wrap[2] =
627     s->block_wrap[3] = s->b8_stride;
628     s->block_wrap[4] =
629     s->block_wrap[5] = s->mb_stride;
630     ff_init_block_index(s);
631
632     /* decode each macroblock */
633     for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
634         int ret;
635         ff_update_block_index(s);
636         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
637
638         s->mv_dir  = MV_DIR_FORWARD;
639         s->mv_type = MV_TYPE_16X16;
640         ret = ff_h263_decode_mb(s, s->block);
641
642         // Repeat the slice end check from ff_h263_decode_mb with our active
643         // bitstream size
644         if (ret != SLICE_ERROR) {
645             int v = show_bits(&s->gb, 16);
646
647             if (get_bits_count(&s->gb) + 16 > active_bits_size)
648                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
649
650             if (!v)
651                 ret = SLICE_END;
652         }
653         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
654             8 * buf_size2 >= get_bits_count(&s->gb)) {
655             active_bits_size = buf_size2 * 8;
656             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
657                    8 * buf_size, active_bits_size);
658             ret = SLICE_OK;
659         }
660
661         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
662             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
663                    s->mb_y);
664             return AVERROR_INVALIDDATA;
665         }
666         if (s->pict_type != AV_PICTURE_TYPE_B)
667             ff_h263_update_motion_val(s);
668         ff_MPV_decode_mb(s, s->block);
669         if (s->loop_filter)
670             ff_h263_loop_filter(s);
671
672         if (++s->mb_x == s->mb_width) {
673             s->mb_x = 0;
674             s->mb_y++;
675             ff_init_block_index(s);
676         }
677         if (s->mb_x == s->resync_mb_x)
678             s->first_slice_line = 0;
679         if (ret == SLICE_END)
680             break;
681     }
682
683     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
684                     ER_MB_END);
685
686     return active_bits_size;
687 }
688
689 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
690 {
691     if (avctx->slice_count)
692         return avctx->slice_offset[n];
693     else
694         return AV_RL32(buf + n * 8);
695 }
696
697 static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
698                              AVPacket *avpkt)
699 {
700     const uint8_t *buf = avpkt->data;
701     int buf_size       = avpkt->size;
702     MpegEncContext *s = avctx->priv_data;
703     AVFrame *pict = data;
704     int i, ret;
705     int slice_count;
706     const uint8_t *slices_hdr = NULL;
707
708     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
709     s->flags  = avctx->flags;
710     s->flags2 = avctx->flags2;
711
712     /* no supplementary picture */
713     if (buf_size == 0) {
714         return 0;
715     }
716
717     if (!avctx->slice_count) {
718         slice_count = (*buf++) + 1;
719         buf_size--;
720
721         if (!slice_count || buf_size <= 8 * slice_count) {
722             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",
723                    slice_count);
724             return AVERROR_INVALIDDATA;
725         }
726
727         slices_hdr = buf + 4;
728         buf       += 8 * slice_count;
729         buf_size  -= 8 * slice_count;
730     } else
731         slice_count = avctx->slice_count;
732
733     for (i = 0; i < slice_count; i++) {
734         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
735         int size, size2;
736
737         if (offset >= buf_size)
738             return AVERROR_INVALIDDATA;
739
740         if (i + 1 == slice_count)
741             size = buf_size - offset;
742         else
743             size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
744
745         if (i + 2 >= slice_count)
746             size2 = buf_size - offset;
747         else
748             size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
749
750         if (size <= 0 || size2 <= 0 ||
751             offset + FFMAX(size, size2) > buf_size)
752             return AVERROR_INVALIDDATA;
753
754         if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2)) < 0)
755             return ret;
756
757         if (ret > 8 * size)
758             i++;
759     }
760
761     if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
762         ff_er_frame_end(&s->er);
763         ff_MPV_frame_end(s);
764
765         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
766             if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
767                 return ret;
768             ff_print_debug_info(s, s->current_picture_ptr, pict);
769             ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
770         } else if (s->last_picture_ptr != NULL) {
771             if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
772                 return ret;
773             ff_print_debug_info(s, s->last_picture_ptr, pict);
774             ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
775         }
776
777         if (s->last_picture_ptr || s->low_delay) {
778             *got_frame = 1;
779         }
780
781         // so we can detect if frame_end was not called (find some nicer solution...)
782         s->current_picture_ptr = NULL;
783     }
784
785     return avpkt->size;
786 }
787
788 AVCodec ff_rv10_decoder = {
789     .name           = "rv10",
790     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
791     .type           = AVMEDIA_TYPE_VIDEO,
792     .id             = AV_CODEC_ID_RV10,
793     .priv_data_size = sizeof(RVDecContext),
794     .init           = rv10_decode_init,
795     .close          = rv10_decode_end,
796     .decode         = rv10_decode_frame,
797     .capabilities   = CODEC_CAP_DR1,
798     .max_lowres     = 3,
799     .pix_fmts       = (const enum AVPixelFormat[]) {
800         AV_PIX_FMT_YUV420P,
801         AV_PIX_FMT_NONE
802     },
803 };
804
805 AVCodec ff_rv20_decoder = {
806     .name           = "rv20",
807     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
808     .type           = AVMEDIA_TYPE_VIDEO,
809     .id             = AV_CODEC_ID_RV20,
810     .priv_data_size = sizeof(RVDecContext),
811     .init           = rv10_decode_init,
812     .close          = rv10_decode_end,
813     .decode         = rv10_decode_frame,
814     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
815     .flush          = ff_mpeg_flush,
816     .max_lowres     = 3,
817     .pix_fmts       = (const enum AVPixelFormat[]) {
818         AV_PIX_FMT_YUV420P,
819         AV_PIX_FMT_NONE
820     },
821 };