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