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