mpeg: Split error resilience bits off into a separate file
[ffmpeg.git] / libavcodec / rv10.c
1 /*
2  * RV10/RV20 decoder
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer
5  *
6  * This file is part of Libav.
7  *
8  * Libav is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * Libav is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * RV10/RV20 decoder
26  */
27
28 #include <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_bits;
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->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
329         av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
330         return AVERROR_INVALIDDATA;
331     }
332
333     if (get_bits1(&s->gb)) {
334         av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
335         return AVERROR_INVALIDDATA;
336     }
337
338     s->qscale = get_bits(&s->gb, 5);
339     if (s->qscale == 0) {
340         av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
341         return AVERROR_INVALIDDATA;
342     }
343
344     if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
345         s->loop_filter = get_bits1(&s->gb);
346
347     if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
348         seq = get_bits(&s->gb, 8) << 7;
349     else
350         seq = get_bits(&s->gb, 13) << 2;
351
352     rpr_bits = s->avctx->extradata[1] & 7;
353     if (rpr_bits) {
354         int f, new_w, new_h;
355         rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
356
357         f = get_bits(&s->gb, rpr_bits);
358
359         if (f) {
360             if (s->avctx->extradata_size < 8 + 2 * f) {
361                 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
362                 return AVERROR_INVALIDDATA;
363             }
364
365             new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];
366             new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];
367         } else {
368             new_w = s->orig_width;
369             new_h = s->orig_height;
370         }
371         if (new_w != s->width || new_h != s->height) {
372             av_log(s->avctx, AV_LOG_DEBUG,
373                    "attempting to change resolution to %dx%d\n", new_w, new_h);
374             ff_MPV_common_end(s);
375
376             ret = ff_set_dimensions(s->avctx, new_w, new_h);
377             if (ret < 0)
378                 return ret;
379
380             s->width  = new_w;
381             s->height = new_h;
382             if ((ret = ff_MPV_common_init(s)) < 0)
383                 return ret;
384         }
385
386         if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
387             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
388         }
389     } else if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
390         return AVERROR_INVALIDDATA;
391
392     mb_pos = ff_h263_decode_mba(s);
393
394     seq |= s->time & ~0x7FFF;
395     if (seq - s->time >  0x4000)
396         seq -= 0x8000;
397     if (seq - s->time < -0x4000)
398         seq += 0x8000;
399
400     if (seq != s->time) {
401         if (s->pict_type != AV_PICTURE_TYPE_B) {
402             s->time            = seq;
403             s->pp_time         = s->time - s->last_non_b_time;
404             s->last_non_b_time = s->time;
405         } else {
406             s->time    = seq;
407             s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
408             if (s->pp_time <= s->pb_time ||
409                 s->pp_time <= s->pp_time - s->pb_time || s->pp_time <= 0) {
410                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible "
411                        "from seeking? skipping current b frame\n");
412                 return FRAME_SKIPPED;
413             }
414             ff_mpeg4_init_direct_mv(s);
415         }
416     }
417
418     s->no_rounding = get_bits1(&s->gb);
419
420     if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
421         // binary decoder reads 3+2 bits here but they don't seem to be used
422         skip_bits(&s->gb, 5);
423
424     s->f_code          = 1;
425     s->unrestricted_mv = 1;
426     s->h263_aic        = s->pict_type == AV_PICTURE_TYPE_I;
427     s->modified_quant  = 1;
428     s->loop_filter     = 1;
429
430     if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
431         av_log(s->avctx, AV_LOG_INFO,
432                "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
433                seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,
434                s->no_rounding);
435     }
436
437     assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
438
439     return s->mb_width * s->mb_height - mb_pos;
440 }
441
442 static av_cold int rv10_decode_init(AVCodecContext *avctx)
443 {
444     RVDecContext *rv = avctx->priv_data;
445     MpegEncContext *s = &rv->m;
446     static int done = 0;
447     int major_ver, minor_ver, micro_ver, ret;
448
449     if (avctx->extradata_size < 8) {
450         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
451         return AVERROR_INVALIDDATA;
452     }
453     if ((ret = av_image_check_size(avctx->coded_width,
454                                    avctx->coded_height, 0, avctx)) < 0)
455         return ret;
456
457     ff_MPV_decode_defaults(s);
458
459     s->avctx       = avctx;
460     s->out_format  = FMT_H263;
461     s->codec_id    = avctx->codec_id;
462
463     s->orig_width  =
464     s->width       = avctx->coded_width;
465     s->orig_height =
466     s->height      = avctx->coded_height;
467
468     s->h263_long_vectors = ((uint8_t *) avctx->extradata)[3] & 1;
469     rv->sub_id           = AV_RB32((uint8_t *) avctx->extradata + 4);
470
471     major_ver = RV_GET_MAJOR_VER(rv->sub_id);
472     minor_ver = RV_GET_MINOR_VER(rv->sub_id);
473     micro_ver = RV_GET_MICRO_VER(rv->sub_id);
474
475     s->low_delay = 1;
476     switch (major_ver) {
477     case 1:
478         s->rv10_version = micro_ver ? 3 : 1;
479         s->obmc         = micro_ver == 2;
480         break;
481     case 2:
482         if (minor_ver >= 2) {
483             s->low_delay           = 0;
484             s->avctx->has_b_frames = 1;
485         }
486         break;
487     default:
488         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
489         avpriv_request_sample(avctx, "RV1/2 version");
490         return AVERROR_PATCHWELCOME;
491     }
492
493     if (avctx->debug & FF_DEBUG_PICT_INFO) {
494         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
495                avctx->extradata_size >= 4 ? ((int *) avctx->extradata)[0] : -1);
496     }
497
498     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
499
500     if ((ret = ff_MPV_common_init(s)) < 0)
501         return ret;
502
503     ff_h263dsp_init(&s->h263dsp);
504     ff_h263_decode_init_vlc();
505
506     /* init rv vlc */
507     if (!done) {
508         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
509                         rv_lum_bits, 1, 1,
510                         rv_lum_code, 2, 2, 16384);
511         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
512                         rv_chrom_bits, 1, 1,
513                         rv_chrom_code, 2, 2, 16388);
514         done = 1;
515     }
516
517     return 0;
518 }
519
520 static av_cold int rv10_decode_end(AVCodecContext *avctx)
521 {
522     MpegEncContext *s = avctx->priv_data;
523
524     ff_MPV_common_end(s);
525     return 0;
526 }
527
528 static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
529                               int buf_size, int buf_size2)
530 {
531     RVDecContext *rv = avctx->priv_data;
532     MpegEncContext *s = &rv->m;
533     int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
534
535     active_bits_size = buf_size * 8;
536     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
537     if (s->codec_id == AV_CODEC_ID_RV10)
538         mb_count = rv10_decode_picture_header(s);
539     else
540         mb_count = rv20_decode_picture_header(rv);
541     if (mb_count < 0) {
542         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
543         return AVERROR_INVALIDDATA;
544     }
545
546     if (s->mb_x >= s->mb_width ||
547         s->mb_y >= s->mb_height) {
548         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
549         return AVERROR_INVALIDDATA;
550     }
551     mb_pos = s->mb_y * s->mb_width + s->mb_x;
552     left   = s->mb_width * s->mb_height - mb_pos;
553     if (mb_count > left) {
554         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
555         return AVERROR_INVALIDDATA;
556     }
557
558     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
559         // FIXME write parser so we always have complete frames?
560         if (s->current_picture_ptr) {
561             ff_er_frame_end(&s->er);
562             ff_MPV_frame_end(s);
563             s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
564         }
565         if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
566             return ret;
567         ff_mpeg_er_frame_start(s);
568     } else {
569         if (s->current_picture_ptr->f->pict_type != s->pict_type) {
570             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
571             return AVERROR_INVALIDDATA;
572         }
573     }
574
575     av_dlog(avctx, "qscale=%d\n", s->qscale);
576
577     /* default quantization values */
578     if (s->codec_id == AV_CODEC_ID_RV10) {
579         if (s->mb_y == 0)
580             s->first_slice_line = 1;
581     } else {
582         s->first_slice_line = 1;
583         s->resync_mb_x      = s->mb_x;
584     }
585     start_mb_x     = s->mb_x;
586     s->resync_mb_y = s->mb_y;
587     if (s->h263_aic) {
588         s->y_dc_scale_table =
589         s->c_dc_scale_table = ff_aic_dc_scale_table;
590     } else {
591         s->y_dc_scale_table =
592         s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
593     }
594
595     if (s->modified_quant)
596         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
597
598     ff_set_qscale(s, s->qscale);
599
600     s->rv10_first_dc_coded[0] = 0;
601     s->rv10_first_dc_coded[1] = 0;
602     s->rv10_first_dc_coded[2] = 0;
603     s->block_wrap[0] =
604     s->block_wrap[1] =
605     s->block_wrap[2] =
606     s->block_wrap[3] = s->b8_stride;
607     s->block_wrap[4] =
608     s->block_wrap[5] = s->mb_stride;
609     ff_init_block_index(s);
610
611     /* decode each macroblock */
612     for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
613         int ret;
614         ff_update_block_index(s);
615         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
616
617         s->mv_dir  = MV_DIR_FORWARD;
618         s->mv_type = MV_TYPE_16X16;
619         ret = ff_h263_decode_mb(s, s->block);
620
621         // Repeat the slice end check from ff_h263_decode_mb with our active
622         // bitstream size
623         if (ret != SLICE_ERROR) {
624             int v = show_bits(&s->gb, 16);
625
626             if (get_bits_count(&s->gb) + 16 > active_bits_size)
627                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
628
629             if (!v)
630                 ret = SLICE_END;
631         }
632         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
633             8 * buf_size2 >= get_bits_count(&s->gb)) {
634             active_bits_size = buf_size2 * 8;
635             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
636                    8 * buf_size, active_bits_size);
637             ret = SLICE_OK;
638         }
639
640         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
641             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
642                    s->mb_y);
643             return AVERROR_INVALIDDATA;
644         }
645         if (s->pict_type != AV_PICTURE_TYPE_B)
646             ff_h263_update_motion_val(s);
647         ff_MPV_decode_mb(s, s->block);
648         if (s->loop_filter)
649             ff_h263_loop_filter(s);
650
651         if (++s->mb_x == s->mb_width) {
652             s->mb_x = 0;
653             s->mb_y++;
654             ff_init_block_index(s);
655         }
656         if (s->mb_x == s->resync_mb_x)
657             s->first_slice_line = 0;
658         if (ret == SLICE_END)
659             break;
660     }
661
662     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
663                     ER_MB_END);
664
665     return active_bits_size;
666 }
667
668 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
669 {
670     if (avctx->slice_count)
671         return avctx->slice_offset[n];
672     else
673         return AV_RL32(buf + n * 8);
674 }
675
676 static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
677                              AVPacket *avpkt)
678 {
679     const uint8_t *buf = avpkt->data;
680     int buf_size       = avpkt->size;
681     MpegEncContext *s = avctx->priv_data;
682     AVFrame *pict = data;
683     int i, ret;
684     int slice_count;
685     const uint8_t *slices_hdr = NULL;
686
687     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
688
689     /* no supplementary picture */
690     if (buf_size == 0) {
691         return 0;
692     }
693
694     if (!avctx->slice_count) {
695         slice_count = (*buf++) + 1;
696         buf_size--;
697
698         if (!slice_count || buf_size <= 8 * slice_count) {
699             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",
700                    slice_count);
701             return AVERROR_INVALIDDATA;
702         }
703
704         slices_hdr = buf + 4;
705         buf       += 8 * slice_count;
706         buf_size  -= 8 * slice_count;
707     } else
708         slice_count = avctx->slice_count;
709
710     for (i = 0; i < slice_count; i++) {
711         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
712         int size, size2;
713
714         if (offset >= buf_size)
715             return AVERROR_INVALIDDATA;
716
717         if (i + 1 == slice_count)
718             size = buf_size - offset;
719         else
720             size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
721
722         if (i + 2 >= slice_count)
723             size2 = buf_size - offset;
724         else
725             size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
726
727         if (size <= 0 || size2 <= 0 ||
728             offset + FFMAX(size, size2) > buf_size)
729             return AVERROR_INVALIDDATA;
730
731         if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2)) < 0)
732             return ret;
733
734         if (ret > 8 * size)
735             i++;
736     }
737
738     if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
739         ff_er_frame_end(&s->er);
740         ff_MPV_frame_end(s);
741
742         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
743             if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
744                 return ret;
745             ff_print_debug_info(s, s->current_picture_ptr);
746         } else if (s->last_picture_ptr != NULL) {
747             if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
748                 return ret;
749             ff_print_debug_info(s, s->last_picture_ptr);
750         }
751
752         if (s->last_picture_ptr || s->low_delay) {
753             *got_frame = 1;
754         }
755
756         // so we can detect if frame_end was not called (find some nicer solution...)
757         s->current_picture_ptr = NULL;
758     }
759
760     return avpkt->size;
761 }
762
763 AVCodec ff_rv10_decoder = {
764     .name           = "rv10",
765     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
766     .type           = AVMEDIA_TYPE_VIDEO,
767     .id             = AV_CODEC_ID_RV10,
768     .priv_data_size = sizeof(RVDecContext),
769     .init           = rv10_decode_init,
770     .close          = rv10_decode_end,
771     .decode         = rv10_decode_frame,
772     .capabilities   = CODEC_CAP_DR1,
773     .pix_fmts       = (const enum AVPixelFormat[]) {
774         AV_PIX_FMT_YUV420P,
775         AV_PIX_FMT_NONE
776     },
777 };
778
779 AVCodec ff_rv20_decoder = {
780     .name           = "rv20",
781     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
782     .type           = AVMEDIA_TYPE_VIDEO,
783     .id             = AV_CODEC_ID_RV20,
784     .priv_data_size = sizeof(RVDecContext),
785     .init           = rv10_decode_init,
786     .close          = rv10_decode_end,
787     .decode         = rv10_decode_frame,
788     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
789     .flush          = ff_mpeg_flush,
790     .pix_fmts       = (const enum AVPixelFormat[]) {
791         AV_PIX_FMT_YUV420P,
792         AV_PIX_FMT_NONE
793     },
794 };