f790c1fa9e5c320da456eb2b4d62b01076006820
[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     if ((ret = av_image_check_size(avctx->coded_width,
436                                    avctx->coded_height, 0, avctx)) < 0)
437         return ret;
438
439     ff_MPV_decode_defaults(s);
440
441     s->avctx      = avctx;
442     s->out_format = FMT_H263;
443     s->codec_id   = avctx->codec_id;
444     avctx->flags |= CODEC_FLAG_EMU_EDGE;
445
446     s->orig_width  = s->width  = avctx->coded_width;
447     s->orig_height = s->height = avctx->coded_height;
448
449     s->h263_long_vectors = ((uint8_t*)avctx->extradata)[3] & 1;
450     rv->sub_id           = AV_RB32((uint8_t*)avctx->extradata + 4);
451
452     major_ver = RV_GET_MAJOR_VER(rv->sub_id);
453     minor_ver = RV_GET_MINOR_VER(rv->sub_id);
454     micro_ver = RV_GET_MICRO_VER(rv->sub_id);
455
456     s->low_delay = 1;
457     switch (major_ver) {
458     case 1:
459         s->rv10_version = micro_ver ? 3 : 1;
460         s->obmc         = micro_ver == 2;
461         break;
462     case 2:
463         if (minor_ver >= 2) {
464             s->low_delay           = 0;
465             s->avctx->has_b_frames = 1;
466         }
467         break;
468     default:
469         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
470         avpriv_request_sample(avctx, "RV1/2 version");
471         return AVERROR_PATCHWELCOME;
472     }
473
474     if (avctx->debug & FF_DEBUG_PICT_INFO) {
475         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
476                avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
477     }
478
479     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
480
481     if ((ret = ff_MPV_common_init(s)) < 0)
482         return ret;
483
484     ff_h263_decode_init_vlc();
485
486     /* init rv vlc */
487     if (!done) {
488         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
489                         rv_lum_bits, 1, 1,
490                         rv_lum_code, 2, 2, 16384);
491         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
492                         rv_chrom_bits, 1, 1,
493                         rv_chrom_code, 2, 2, 16388);
494         done = 1;
495     }
496
497     return 0;
498 }
499
500 static av_cold int rv10_decode_end(AVCodecContext *avctx)
501 {
502     MpegEncContext *s = avctx->priv_data;
503
504     ff_MPV_common_end(s);
505     return 0;
506 }
507
508 static int rv10_decode_packet(AVCodecContext *avctx,
509                               const uint8_t *buf, int buf_size, int buf_size2)
510 {
511     RVDecContext  *rv = avctx->priv_data;
512     MpegEncContext *s = &rv->m;
513     int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
514
515     active_bits_size = buf_size * 8;
516     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
517     if (s->codec_id == AV_CODEC_ID_RV10)
518         mb_count = rv10_decode_picture_header(s);
519     else
520         mb_count = rv20_decode_picture_header(rv);
521     if (mb_count < 0) {
522         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
523         return AVERROR_INVALIDDATA;
524     }
525
526     if (s->mb_x >= s->mb_width ||
527         s->mb_y >= s->mb_height) {
528         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
529         return AVERROR_INVALIDDATA;
530     }
531     mb_pos = s->mb_y * s->mb_width + s->mb_x;
532     left = s->mb_width * s->mb_height - mb_pos;
533     if (mb_count > left) {
534         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
535         return AVERROR_INVALIDDATA;
536     }
537
538     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
539         if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?
540             ff_er_frame_end(&s->er);
541             ff_MPV_frame_end(s);
542             s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
543         }
544         if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
545             return ret;
546         ff_mpeg_er_frame_start(s);
547     } else {
548         if (s->current_picture_ptr->f.pict_type != s->pict_type) {
549             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
550             return AVERROR_INVALIDDATA;
551         }
552     }
553
554     av_dlog(avctx, "qscale=%d\n", s->qscale);
555
556     /* default quantization values */
557     if (s->codec_id == AV_CODEC_ID_RV10) {
558         if (s->mb_y == 0)
559             s->first_slice_line = 1;
560     } else {
561         s->first_slice_line = 1;
562         s->resync_mb_x      = s->mb_x;
563     }
564     start_mb_x     = s->mb_x;
565     s->resync_mb_y = s->mb_y;
566     if (s->h263_aic) {
567         s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;
568     } else {
569         s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
570     }
571
572     if (s->modified_quant)
573         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
574
575     ff_set_qscale(s, s->qscale);
576
577     s->rv10_first_dc_coded[0] = 0;
578     s->rv10_first_dc_coded[1] = 0;
579     s->rv10_first_dc_coded[2] = 0;
580     s->block_wrap[0] =
581     s->block_wrap[1] =
582     s->block_wrap[2] =
583     s->block_wrap[3] = s->b8_stride;
584     s->block_wrap[4] =
585     s->block_wrap[5] = s->mb_stride;
586     ff_init_block_index(s);
587
588     /* decode each macroblock */
589     for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
590         int ret;
591         ff_update_block_index(s);
592         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
593
594         s->mv_dir  = MV_DIR_FORWARD;
595         s->mv_type = MV_TYPE_16X16;
596         ret = ff_h263_decode_mb(s, s->block);
597
598         // Repeat the slice end check from ff_h263_decode_mb with our active
599         // bitstream size
600         if (ret != SLICE_ERROR) {
601             int v = show_bits(&s->gb, 16);
602
603             if (get_bits_count(&s->gb) + 16 > active_bits_size)
604                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
605
606             if (!v)
607                 ret = SLICE_END;
608         }
609         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
610             8 * buf_size2 >= get_bits_count(&s->gb)) {
611             active_bits_size = buf_size2 * 8;
612             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
613                    8 * buf_size, active_bits_size);
614             ret = SLICE_OK;
615         }
616
617         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
618             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
619             return AVERROR_INVALIDDATA;
620         }
621         if (s->pict_type != AV_PICTURE_TYPE_B)
622             ff_h263_update_motion_val(s);
623         ff_MPV_decode_mb(s, s->block);
624         if (s->loop_filter)
625             ff_h263_loop_filter(s);
626
627         if (++s->mb_x == s->mb_width) {
628             s->mb_x = 0;
629             s->mb_y++;
630             ff_init_block_index(s);
631         }
632         if (s->mb_x == s->resync_mb_x)
633             s->first_slice_line = 0;
634         if (ret == SLICE_END)
635             break;
636     }
637
638     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,
639                     ER_MB_END);
640
641     return active_bits_size;
642 }
643
644 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
645 {
646     if (avctx->slice_count)
647         return avctx->slice_offset[n];
648     else
649         return AV_RL32(buf + n * 8);
650 }
651
652 static int rv10_decode_frame(AVCodecContext *avctx,
653                              void *data, int *got_frame,
654                              AVPacket *avpkt)
655 {
656     const uint8_t *buf = avpkt->data;
657     int buf_size       = avpkt->size;
658     MpegEncContext *s  = avctx->priv_data;
659     AVFrame *pict      = data;
660     int i, ret;
661     int slice_count;
662     const uint8_t *slices_hdr = NULL;
663
664     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
665
666     /* no supplementary picture */
667     if (buf_size == 0) {
668         return 0;
669     }
670
671     if (!avctx->slice_count) {
672         slice_count = (*buf++) + 1;
673         buf_size--;
674
675         if (!slice_count || buf_size <= 8 * slice_count) {
676             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
677             return AVERROR_INVALIDDATA;
678         }
679
680         slices_hdr = buf + 4;
681         buf       += 8 * slice_count;
682         buf_size  -= 8 * slice_count;
683     } else
684         slice_count = avctx->slice_count;
685
686     for (i = 0; i < slice_count; i++) {
687         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
688         int size, size2;
689
690         if (offset >= buf_size)
691             return AVERROR_INVALIDDATA;
692
693         if (i + 1 == slice_count)
694             size = buf_size - offset;
695         else
696             size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
697
698         if (i + 2 >= slice_count)
699             size2 = buf_size - offset;
700         else
701             size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
702
703         if (size <= 0 || size2 <= 0 ||
704             offset + FFMAX(size, size2) > buf_size)
705             return AVERROR_INVALIDDATA;
706
707         if (rv10_decode_packet(avctx, buf + offset, size, size2) > 8 * size)
708             i++;
709     }
710
711     if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
712         ff_er_frame_end(&s->er);
713         ff_MPV_frame_end(s);
714
715         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
716             if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
717                 return ret;
718             ff_print_debug_info(s, s->current_picture_ptr);
719         } else if (s->last_picture_ptr != NULL) {
720             if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
721                 return ret;
722             ff_print_debug_info(s, s->last_picture_ptr);
723         }
724
725         if (s->last_picture_ptr || s->low_delay) {
726             *got_frame = 1;
727         }
728
729         // so we can detect if frame_end was not called (find some nicer solution...)
730         s->current_picture_ptr = NULL;
731     }
732
733     return avpkt->size;
734 }
735
736 AVCodec ff_rv10_decoder = {
737     .name           = "rv10",
738     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
739     .type           = AVMEDIA_TYPE_VIDEO,
740     .id             = AV_CODEC_ID_RV10,
741     .priv_data_size = sizeof(RVDecContext),
742     .init           = rv10_decode_init,
743     .close          = rv10_decode_end,
744     .decode         = rv10_decode_frame,
745     .capabilities   = CODEC_CAP_DR1,
746     .pix_fmts       = ff_pixfmt_list_420,
747 };
748
749 AVCodec ff_rv20_decoder = {
750     .name           = "rv20",
751     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
752     .type           = AVMEDIA_TYPE_VIDEO,
753     .id             = AV_CODEC_ID_RV20,
754     .priv_data_size = sizeof(RVDecContext),
755     .init           = rv10_decode_init,
756     .close          = rv10_decode_end,
757     .decode         = rv10_decode_frame,
758     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
759     .flush          = ff_mpeg_flush,
760     .pix_fmts       = ff_pixfmt_list_420,
761 };