]> git.sesse.net Git - ffmpeg/blob - libavcodec/rv10.c
vc1dec: make sure next_use_ic is set correctly
[ffmpeg] / 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 "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->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
318         av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
319         return -1;
320     }
321     if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
322         av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
323         return AVERROR_INVALIDDATA;
324     }
325
326     if (get_bits1(&s->gb)) {
327         av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
328         return AVERROR_INVALIDDATA;
329     }
330
331     s->qscale = get_bits(&s->gb, 5);
332     if (s->qscale == 0) {
333         av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
334         return AVERROR_INVALIDDATA;
335     }
336
337     if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
338         s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
339
340     if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
341         seq = get_bits(&s->gb, 8) << 7;
342     else
343         seq = get_bits(&s->gb, 13) << 2;
344
345     rpr_bits = s->avctx->extradata[1] & 7;
346     if (rpr_bits) {
347         int f, new_w, new_h;
348         rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
349
350         f = get_bits(&s->gb, rpr_bits);
351
352         if (f) {
353             if (s->avctx->extradata_size < 8 + 2 * f) {
354                 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
355                 return AVERROR_INVALIDDATA;
356             }
357
358             new_w = 4 * ((uint8_t*)s->avctx->extradata)[6 + 2 * f];
359             new_h = 4 * ((uint8_t*)s->avctx->extradata)[7 + 2 * f];
360         } else {
361             new_w = s->orig_width ;
362             new_h = s->orig_height;
363         }
364         if (new_w != s->width || new_h != s->height) {
365             AVRational old_aspect = s->avctx->sample_aspect_ratio;
366             av_log(s->avctx, AV_LOG_DEBUG,
367                    "attempting to change resolution to %dx%d\n", new_w, new_h);
368             if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
369                 return AVERROR_INVALIDDATA;
370             ff_MPV_common_end(s);
371
372             // attempt to keep aspect during typical resolution switches
373             if (!old_aspect.num)
374                 old_aspect = (AVRational){1, 1};
375             if (2 * new_w * s->height == new_h * s->width)
376                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
377             if (new_w * s->height == 2 * new_h * s->width)
378                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
379             avcodec_set_dimensions(s->avctx, new_w, new_h);
380             s->width  = new_w;
381             s->height = new_h;
382             if ((ret = ff_MPV_common_init(s)) < 0)
383                 return ret;
384         }
385
386         if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
387             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
388         }
389     }
390     if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
391         return AVERROR_INVALIDDATA;
392
393     mb_pos = ff_h263_decode_mba(s);
394
395     seq |= s->time & ~0x7FFF;
396     if (seq - s->time >  0x4000)
397         seq -= 0x8000;
398     if (seq - s->time < -0x4000)
399         seq += 0x8000;
400
401     if (seq != s->time) {
402         if (s->pict_type != AV_PICTURE_TYPE_B) {
403             s->time            = seq;
404             s->pp_time         = s->time - s->last_non_b_time;
405             s->last_non_b_time = s->time;
406         } else {
407             s->time    = seq;
408             s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
409         }
410     }
411     if (s->pict_type == AV_PICTURE_TYPE_B) {
412         if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
413             av_log(s->avctx, AV_LOG_DEBUG,
414                    "messed up order, possible from seeking? skipping current b frame\n");
415 #define ERROR_SKIP_FRAME -123
416             return ERROR_SKIP_FRAME;
417         }
418         ff_mpeg4_init_direct_mv(s);
419     }
420
421     s->no_rounding = get_bits1(&s->gb);
422
423     if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
424         skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
425
426     s->f_code          = 1;
427     s->unrestricted_mv = 1;
428     s->h263_aic        = s->pict_type == AV_PICTURE_TYPE_I;
429     s->modified_quant  = 1;
430     if (!s->avctx->lowres)
431         s->loop_filter = 1;
432
433     if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
434         av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
435                seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
436     }
437
438     av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
439
440     return s->mb_width*s->mb_height - mb_pos;
441 }
442
443 static av_cold int rv10_decode_init(AVCodecContext *avctx)
444 {
445     RVDecContext  *rv = avctx->priv_data;
446     MpegEncContext *s = &rv->m;
447     static int done = 0;
448     int major_ver, minor_ver, micro_ver, ret;
449
450     if (avctx->extradata_size < 8) {
451         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
452         return AVERROR_INVALIDDATA;
453     }
454
455     ff_MPV_decode_defaults(s);
456
457     s->avctx      = avctx;
458     s->out_format = FMT_H263;
459     s->codec_id   = avctx->codec_id;
460
461     s->orig_width  = s->width  = avctx->coded_width;
462     s->orig_height = s->height = avctx->coded_height;
463
464     s->h263_long_vectors = ((uint8_t*)avctx->extradata)[3] & 1;
465     rv->sub_id           = AV_RB32((uint8_t*)avctx->extradata + 4);
466
467     major_ver = RV_GET_MAJOR_VER(rv->sub_id);
468     minor_ver = RV_GET_MINOR_VER(rv->sub_id);
469     micro_ver = RV_GET_MICRO_VER(rv->sub_id);
470
471     s->low_delay = 1;
472     switch (major_ver) {
473     case 1:
474         s->rv10_version = micro_ver ? 3 : 1;
475         s->obmc         = micro_ver == 2;
476         break;
477     case 2:
478         if (minor_ver >= 2) {
479             s->low_delay           = 0;
480             s->avctx->has_b_frames = 1;
481         }
482         break;
483     default:
484         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
485         avpriv_request_sample(avctx, "RV1/2 version");
486         return AVERROR_PATCHWELCOME;
487     }
488
489     if (avctx->debug & FF_DEBUG_PICT_INFO) {
490         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
491                ((uint32_t*)avctx->extradata)[0]);
492     }
493
494     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
495
496     if ((ret = ff_MPV_common_init(s)) < 0)
497         return ret;
498
499     ff_h263_decode_init_vlc();
500
501     /* init rv vlc */
502     if (!done) {
503         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
504                         rv_lum_bits, 1, 1,
505                         rv_lum_code, 2, 2, 16384);
506         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
507                         rv_chrom_bits, 1, 1,
508                         rv_chrom_code, 2, 2, 16388);
509         done = 1;
510     }
511
512     return 0;
513 }
514
515 static av_cold int rv10_decode_end(AVCodecContext *avctx)
516 {
517     MpegEncContext *s = avctx->priv_data;
518
519     ff_MPV_common_end(s);
520     return 0;
521 }
522
523 static int rv10_decode_packet(AVCodecContext *avctx,
524                               const uint8_t *buf, int buf_size, int buf_size2)
525 {
526     RVDecContext  *rv = avctx->priv_data;
527     MpegEncContext *s = &rv->m;
528     int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
529
530     active_bits_size = buf_size * 8;
531     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
532     if (s->codec_id == AV_CODEC_ID_RV10)
533         mb_count = rv10_decode_picture_header(s);
534     else
535         mb_count = rv20_decode_picture_header(rv);
536     if (mb_count < 0) {
537         if (mb_count != ERROR_SKIP_FRAME)
538             av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
539         return AVERROR_INVALIDDATA;
540     }
541
542     if (s->mb_x >= s->mb_width ||
543         s->mb_y >= s->mb_height) {
544         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
545         return AVERROR_INVALIDDATA;
546     }
547     mb_pos = s->mb_y * s->mb_width + s->mb_x;
548     left = s->mb_width * s->mb_height - mb_pos;
549     if (mb_count > left) {
550         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
551         return AVERROR_INVALIDDATA;
552     }
553
554     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
555         if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?
556             ff_er_frame_end(&s->er);
557             ff_MPV_frame_end(s);
558             s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
559         }
560         if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
561             return ret;
562         ff_mpeg_er_frame_start(s);
563     } else {
564         if (s->current_picture_ptr->f.pict_type != s->pict_type) {
565             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
566             return AVERROR_INVALIDDATA;
567         }
568     }
569
570
571     av_dlog(avctx, "qscale=%d\n", s->qscale);
572
573     /* default quantization values */
574     if (s->codec_id == AV_CODEC_ID_RV10) {
575         if (s->mb_y == 0)
576             s->first_slice_line = 1;
577     } else {
578         s->first_slice_line = 1;
579         s->resync_mb_x      = s->mb_x;
580     }
581     start_mb_x     = s->mb_x;
582     s->resync_mb_y = s->mb_y;
583     if (s->h263_aic) {
584         s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;
585     } else {
586         s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
587     }
588
589     if (s->modified_quant)
590         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
591
592     ff_set_qscale(s, s->qscale);
593
594     s->rv10_first_dc_coded[0] = 0;
595     s->rv10_first_dc_coded[1] = 0;
596     s->rv10_first_dc_coded[2] = 0;
597     s->block_wrap[0] =
598     s->block_wrap[1] =
599     s->block_wrap[2] =
600     s->block_wrap[3] = s->b8_stride;
601     s->block_wrap[4] =
602     s->block_wrap[5] = s->mb_stride;
603     ff_init_block_index(s);
604
605     /* decode each macroblock */
606     for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
607         int ret;
608         ff_update_block_index(s);
609         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
610
611         s->mv_dir  = MV_DIR_FORWARD;
612         s->mv_type = MV_TYPE_16X16;
613         ret = ff_h263_decode_mb(s, s->block);
614
615         // Repeat the slice end check from ff_h263_decode_mb with our active
616         // bitstream size
617         if (ret != SLICE_ERROR) {
618             int v = show_bits(&s->gb, 16);
619
620             if (get_bits_count(&s->gb) + 16 > active_bits_size)
621                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
622
623             if (!v)
624                 ret = SLICE_END;
625         }
626         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
627             8 * buf_size2 >= get_bits_count(&s->gb)) {
628             active_bits_size = buf_size2 * 8;
629             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
630                    8 * buf_size, active_bits_size);
631             ret = SLICE_OK;
632         }
633
634         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
635             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
636             return AVERROR_INVALIDDATA;
637         }
638         if (s->pict_type != AV_PICTURE_TYPE_B)
639             ff_h263_update_motion_val(s);
640         ff_MPV_decode_mb(s, s->block);
641         if (s->loop_filter)
642             ff_h263_loop_filter(s);
643
644         if (++s->mb_x == s->mb_width) {
645             s->mb_x = 0;
646             s->mb_y++;
647             ff_init_block_index(s);
648         }
649         if (s->mb_x == s->resync_mb_x)
650             s->first_slice_line = 0;
651         if (ret == SLICE_END)
652             break;
653     }
654
655     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,
656                     ER_MB_END);
657
658     return active_bits_size;
659 }
660
661 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
662 {
663     if (avctx->slice_count)
664         return avctx->slice_offset[n];
665     else
666         return AV_RL32(buf + n * 8);
667 }
668
669 static int rv10_decode_frame(AVCodecContext *avctx,
670                              void *data, int *got_frame,
671                              AVPacket *avpkt)
672 {
673     const uint8_t *buf = avpkt->data;
674     int buf_size       = avpkt->size;
675     MpegEncContext *s  = avctx->priv_data;
676     AVFrame *pict      = data;
677     int i, ret;
678     int slice_count;
679     const uint8_t *slices_hdr = NULL;
680
681     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
682     s->flags  = avctx->flags;
683     s->flags2 = avctx->flags2;
684
685     /* no supplementary picture */
686     if (buf_size == 0) {
687         return 0;
688     }
689
690     if (!avctx->slice_count) {
691         slice_count = (*buf++) + 1;
692         buf_size--;
693
694         if (!slice_count || buf_size <= 8 * slice_count) {
695             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
696             return AVERROR_INVALIDDATA;
697         }
698
699         slices_hdr = buf + 4;
700         buf       += 8 * slice_count;
701         buf_size  -= 8 * slice_count;
702     } else
703         slice_count = avctx->slice_count;
704
705     for (i = 0; i < slice_count; i++) {
706         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
707         int size, size2;
708
709         if (offset >= buf_size)
710             return AVERROR_INVALIDDATA;
711
712         if (i + 1 == slice_count)
713             size = buf_size - offset;
714         else
715             size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
716
717         if (i + 2 >= slice_count)
718             size2 = buf_size - offset;
719         else
720             size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
721
722         if (size <= 0 || size2 <= 0 ||
723             offset + FFMAX(size, size2) > buf_size)
724             return AVERROR_INVALIDDATA;
725
726         if (rv10_decode_packet(avctx, buf + offset, size, size2) > 8 * size)
727             i++;
728     }
729
730     if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
731         ff_er_frame_end(&s->er);
732         ff_MPV_frame_end(s);
733
734         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
735             if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
736                 return ret;
737             ff_print_debug_info(s, s->current_picture_ptr, pict);
738             ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
739         } else if (s->last_picture_ptr != NULL) {
740             if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
741                 return ret;
742             ff_print_debug_info(s, s->last_picture_ptr, pict);
743             ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
744         }
745
746         if (s->last_picture_ptr || s->low_delay) {
747             *got_frame = 1;
748         }
749
750         // so we can detect if frame_end was not called (find some nicer solution...)
751         s->current_picture_ptr = NULL;
752     }
753
754     return avpkt->size;
755 }
756
757 AVCodec ff_rv10_decoder = {
758     .name           = "rv10",
759     .type           = AVMEDIA_TYPE_VIDEO,
760     .id             = AV_CODEC_ID_RV10,
761     .priv_data_size = sizeof(RVDecContext),
762     .init           = rv10_decode_init,
763     .close          = rv10_decode_end,
764     .decode         = rv10_decode_frame,
765     .capabilities   = CODEC_CAP_DR1,
766     .max_lowres     = 3,
767     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
768     .pix_fmts       = ff_pixfmt_list_420,
769 };
770
771 AVCodec ff_rv20_decoder = {
772     .name           = "rv20",
773     .type           = AVMEDIA_TYPE_VIDEO,
774     .id             = AV_CODEC_ID_RV20,
775     .priv_data_size = sizeof(RVDecContext),
776     .init           = rv10_decode_init,
777     .close          = rv10_decode_end,
778     .decode         = rv10_decode_frame,
779     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
780     .flush          = ff_mpeg_flush,
781     .max_lowres     = 3,
782     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
783     .pix_fmts       = ff_pixfmt_list_420,
784 };