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