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