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