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