Merge commit '0338c396987c82b41d322630ea9712fe5f9561d6'
[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 "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->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
317         av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
318         return -1;
319     }
320     if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
321         av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
322         return AVERROR_INVALIDDATA;
323     }
324
325     if (get_bits1(&s->gb)) {
326         av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
327         return AVERROR_INVALIDDATA;
328     }
329
330     s->qscale = get_bits(&s->gb, 5);
331     if (s->qscale == 0) {
332         av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
333         return AVERROR_INVALIDDATA;
334     }
335
336     if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
337         s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
338
339     if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
340         seq = get_bits(&s->gb, 8) << 7;
341     else
342         seq = get_bits(&s->gb, 13) << 2;
343
344     rpr_bits = s->avctx->extradata[1] & 7;
345     if (rpr_bits) {
346         int f, new_w, new_h;
347         rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
348
349         f = get_bits(&s->gb, rpr_bits);
350
351         if (f) {
352             if (s->avctx->extradata_size < 8 + 2 * f) {
353                 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
354                 return AVERROR_INVALIDDATA;
355             }
356
357             new_w = 4 * ((uint8_t*)s->avctx->extradata)[6 + 2 * f];
358             new_h = 4 * ((uint8_t*)s->avctx->extradata)[7 + 2 * f];
359         } else {
360             new_w = s->orig_width ;
361             new_h = s->orig_height;
362         }
363         if (new_w != s->width || new_h != s->height) {
364             AVRational old_aspect = s->avctx->sample_aspect_ratio;
365             av_log(s->avctx, AV_LOG_DEBUG,
366                    "attempting to change resolution to %dx%d\n", new_w, new_h);
367             ff_MPV_common_end(s);
368
369             // attempt to keep aspect during typical resolution switches
370             if (!old_aspect.num)
371                 old_aspect = (AVRational){1, 1};
372             if (2 * new_w * s->height == new_h * s->width)
373                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
374             if (new_w * s->height == 2 * new_h * s->width)
375                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
376
377             ret = ff_set_dimensions(s->avctx, new_w, new_h);
378             if (ret < 0)
379                 return ret;
380
381             s->width  = new_w;
382             s->height = new_h;
383             if ((ret = ff_MPV_common_init(s)) < 0)
384                 return ret;
385         }
386
387         if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
388             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
389         }
390     }
391     if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
392         return AVERROR_INVALIDDATA;
393
394     mb_pos = ff_h263_decode_mba(s);
395
396     seq |= s->time & ~0x7FFF;
397     if (seq - s->time >  0x4000)
398         seq -= 0x8000;
399     if (seq - s->time < -0x4000)
400         seq += 0x8000;
401
402     if (seq != s->time) {
403         if (s->pict_type != AV_PICTURE_TYPE_B) {
404             s->time            = seq;
405             s->pp_time         = s->time - s->last_non_b_time;
406             s->last_non_b_time = s->time;
407         } else {
408             s->time    = seq;
409             s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
410         }
411     }
412     if (s->pict_type == AV_PICTURE_TYPE_B) {
413         if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
414             av_log(s->avctx, AV_LOG_DEBUG,
415                    "messed up order, possible from seeking? skipping current b frame\n");
416 #define ERROR_SKIP_FRAME -123
417             return ERROR_SKIP_FRAME;
418         }
419         ff_mpeg4_init_direct_mv(s);
420     }
421
422     s->no_rounding = get_bits1(&s->gb);
423
424     if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
425         skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
426
427     s->f_code          = 1;
428     s->unrestricted_mv = 1;
429     s->h263_aic        = s->pict_type == AV_PICTURE_TYPE_I;
430     s->modified_quant  = 1;
431     if (!s->avctx->lowres)
432         s->loop_filter = 1;
433
434     if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
435         av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
436                seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
437     }
438
439     av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
440
441     return s->mb_width*s->mb_height - mb_pos;
442 }
443
444 static av_cold int rv10_decode_init(AVCodecContext *avctx)
445 {
446     RVDecContext  *rv = avctx->priv_data;
447     MpegEncContext *s = &rv->m;
448     static int done = 0;
449     int major_ver, minor_ver, micro_ver, ret;
450
451     if (avctx->extradata_size < 8) {
452         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
453         return AVERROR_INVALIDDATA;
454     }
455     if ((ret = av_image_check_size(avctx->coded_width,
456                                    avctx->coded_height, 0, avctx)) < 0)
457         return ret;
458
459     ff_MPV_decode_defaults(s);
460
461     s->avctx      = avctx;
462     s->out_format = FMT_H263;
463     s->codec_id   = avctx->codec_id;
464
465     s->orig_width  = s->width  = avctx->coded_width;
466     s->orig_height = 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                ((uint32_t*)avctx->extradata)[0]);
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,
529                               const uint8_t *buf, 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         if (mb_count != ERROR_SKIP_FRAME)
543             av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
544         return AVERROR_INVALIDDATA;
545     }
546
547     if (s->mb_x >= s->mb_width ||
548         s->mb_y >= s->mb_height) {
549         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
550         return AVERROR_INVALIDDATA;
551     }
552     mb_pos = s->mb_y * s->mb_width + s->mb_x;
553     left = s->mb_width * s->mb_height - mb_pos;
554     if (mb_count > left) {
555         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
556         return AVERROR_INVALIDDATA;
557     }
558
559     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
560         if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?
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
576     av_dlog(avctx, "qscale=%d\n", s->qscale);
577
578     /* default quantization values */
579     if (s->codec_id == AV_CODEC_ID_RV10) {
580         if (s->mb_y == 0)
581             s->first_slice_line = 1;
582     } else {
583         s->first_slice_line = 1;
584         s->resync_mb_x      = s->mb_x;
585     }
586     start_mb_x     = s->mb_x;
587     s->resync_mb_y = s->mb_y;
588     if (s->h263_aic) {
589         s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;
590     } else {
591         s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
592     }
593
594     if (s->modified_quant)
595         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
596
597     ff_set_qscale(s, s->qscale);
598
599     s->rv10_first_dc_coded[0] = 0;
600     s->rv10_first_dc_coded[1] = 0;
601     s->rv10_first_dc_coded[2] = 0;
602     s->block_wrap[0] =
603     s->block_wrap[1] =
604     s->block_wrap[2] =
605     s->block_wrap[3] = s->b8_stride;
606     s->block_wrap[4] =
607     s->block_wrap[5] = s->mb_stride;
608     ff_init_block_index(s);
609
610     /* decode each macroblock */
611     for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
612         int ret;
613         ff_update_block_index(s);
614         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
615
616         s->mv_dir  = MV_DIR_FORWARD;
617         s->mv_type = MV_TYPE_16X16;
618         ret = ff_h263_decode_mb(s, s->block);
619
620         // Repeat the slice end check from ff_h263_decode_mb with our active
621         // bitstream size
622         if (ret != SLICE_ERROR) {
623             int v = show_bits(&s->gb, 16);
624
625             if (get_bits_count(&s->gb) + 16 > active_bits_size)
626                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
627
628             if (!v)
629                 ret = SLICE_END;
630         }
631         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
632             8 * buf_size2 >= get_bits_count(&s->gb)) {
633             active_bits_size = buf_size2 * 8;
634             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
635                    8 * buf_size, active_bits_size);
636             ret = SLICE_OK;
637         }
638
639         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
640             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
641             return AVERROR_INVALIDDATA;
642         }
643         if (s->pict_type != AV_PICTURE_TYPE_B)
644             ff_h263_update_motion_val(s);
645         ff_MPV_decode_mb(s, s->block);
646         if (s->loop_filter)
647             ff_h263_loop_filter(s);
648
649         if (++s->mb_x == s->mb_width) {
650             s->mb_x = 0;
651             s->mb_y++;
652             ff_init_block_index(s);
653         }
654         if (s->mb_x == s->resync_mb_x)
655             s->first_slice_line = 0;
656         if (ret == SLICE_END)
657             break;
658     }
659
660     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,
661                     ER_MB_END);
662
663     return active_bits_size;
664 }
665
666 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
667 {
668     if (avctx->slice_count)
669         return avctx->slice_offset[n];
670     else
671         return AV_RL32(buf + n * 8);
672 }
673
674 static int rv10_decode_frame(AVCodecContext *avctx,
675                              void *data, int *got_frame,
676                              AVPacket *avpkt)
677 {
678     const uint8_t *buf = avpkt->data;
679     int buf_size       = avpkt->size;
680     MpegEncContext *s  = avctx->priv_data;
681     AVFrame *pict      = data;
682     int i, ret;
683     int slice_count;
684     const uint8_t *slices_hdr = NULL;
685
686     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
687     s->flags  = avctx->flags;
688     s->flags2 = avctx->flags2;
689
690     /* no supplementary picture */
691     if (buf_size == 0) {
692         return 0;
693     }
694
695     if (!avctx->slice_count) {
696         slice_count = (*buf++) + 1;
697         buf_size--;
698
699         if (!slice_count || buf_size <= 8 * slice_count) {
700             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", 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 (rv10_decode_packet(avctx, buf + offset, size, size2) > 8 * size)
732             i++;
733     }
734
735     if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
736         ff_er_frame_end(&s->er);
737         ff_MPV_frame_end(s);
738
739         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
740             if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
741                 return ret;
742             ff_print_debug_info(s, s->current_picture_ptr, pict);
743             ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
744         } else if (s->last_picture_ptr != NULL) {
745             if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
746                 return ret;
747             ff_print_debug_info(s, s->last_picture_ptr, pict);
748             ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
749         }
750
751         if (s->last_picture_ptr || s->low_delay) {
752             *got_frame = 1;
753         }
754
755         // so we can detect if frame_end was not called (find some nicer solution...)
756         s->current_picture_ptr = NULL;
757     }
758
759     return avpkt->size;
760 }
761
762 AVCodec ff_rv10_decoder = {
763     .name           = "rv10",
764     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
765     .type           = AVMEDIA_TYPE_VIDEO,
766     .id             = AV_CODEC_ID_RV10,
767     .priv_data_size = sizeof(RVDecContext),
768     .init           = rv10_decode_init,
769     .close          = rv10_decode_end,
770     .decode         = rv10_decode_frame,
771     .capabilities   = CODEC_CAP_DR1,
772     .max_lowres     = 3,
773     .pix_fmts       = ff_pixfmt_list_420,
774 };
775
776 AVCodec ff_rv20_decoder = {
777     .name           = "rv20",
778     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
779     .type           = AVMEDIA_TYPE_VIDEO,
780     .id             = AV_CODEC_ID_RV20,
781     .priv_data_size = sizeof(RVDecContext),
782     .init           = rv10_decode_init,
783     .close          = rv10_decode_end,
784     .decode         = rv10_decode_frame,
785     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
786     .flush          = ff_mpeg_flush,
787     .max_lowres     = 3,
788     .pix_fmts       = ff_pixfmt_list_420,
789 };