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