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