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