9f2fe77af7ad1eee81e9df0111df8e442d2cefe8
[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 #include "avcodec.h"
30 #include "dsputil.h"
31 #include "mpegvideo.h"
32 #include "mpeg4video.h"
33 #include "h263.h"
34
35 //#define DEBUG
36
37 #define RV_GET_MAJOR_VER(x)  ((x) >> 28)
38 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
39 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
40
41 #define DC_VLC_BITS 14 //FIXME find a better solution
42
43 static const uint16_t rv_lum_code[256] =
44 {
45  0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
46  0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
47  0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
48  0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
49  0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
50  0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
51  0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
52  0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
53  0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
54  0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
55  0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
56  0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
57  0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
58  0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
59  0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
60  0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
61  0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
62  0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
63  0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
64  0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
65  0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
66  0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
67  0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
68  0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
69  0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
70  0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
71  0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
72  0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
73  0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
74  0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
75  0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
76  0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
77 };
78
79 static const uint8_t rv_lum_bits[256] =
80 {
81  14, 12, 12, 12, 12, 12, 12, 12,
82  12, 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, 10, 10, 10, 10, 10, 10, 10,
90  10, 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,  8,  8,  8,  8,  8,  8,  8,
94   8,  8,  8,  8,  8,  8,  8,  8,
95   8,  7,  7,  7,  7,  7,  7,  7,
96   7,  6,  6,  6,  6,  5,  5,  4,
97   2,  4,  5,  5,  6,  6,  6,  6,
98   7,  7,  7,  7,  7,  7,  7,  7,
99   8,  8,  8,  8,  8,  8,  8,  8,
100   8,  8,  8,  8,  8,  8,  8,  8,
101  10, 10, 10, 10, 10, 10, 10, 10,
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  12, 12, 12, 12, 12, 12, 12, 12,
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 };
114
115 static const uint16_t rv_chrom_code[256] =
116 {
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 {
153  16, 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, 14, 14, 14, 14, 14, 14, 14,
161  14, 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, 12, 12, 12, 12, 12, 12, 12,
165  12, 10, 10, 10, 10, 10, 10, 10,
166  10, 10, 10, 10, 10, 10, 10, 10,
167  10,  8,  8,  8,  8,  8,  8,  8,
168   8,  6,  6,  6,  6,  4,  4,  3,
169   2,  3,  4,  4,  6,  6,  6,  6,
170   8,  8,  8,  8,  8,  8,  8,  8,
171  10, 10, 10, 10, 10, 10, 10, 10,
172  10, 10, 10, 10, 10, 10, 10, 10,
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  12, 12, 12, 12, 12, 12, 12, 12,
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  14, 14, 14, 14, 14, 14, 14, 14,
185 };
186
187 static VLC rv_dc_lum, rv_dc_chrom;
188
189 int rv_decode_dc(MpegEncContext *s, int n)
190 {
191     int code;
192
193     if (n < 4) {
194         code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
195         if (code < 0) {
196             /* XXX: I don't understand why they use LONGER codes than
197                necessary. The following code would be completely useless
198                if they had thought about it !!! */
199             code = get_bits(&s->gb, 7);
200             if (code == 0x7c) {
201                 code = (int8_t)(get_bits(&s->gb, 7) + 1);
202             } else if (code == 0x7d) {
203                 code = -128 + get_bits(&s->gb, 7);
204             } else if (code == 0x7e) {
205                 if (get_bits1(&s->gb) == 0)
206                     code = (int8_t)(get_bits(&s->gb, 8) + 1);
207                 else
208                     code = (int8_t)(get_bits(&s->gb, 8));
209             } else if (code == 0x7f) {
210                 skip_bits(&s->gb, 11);
211                 code = 1;
212             }
213         } else {
214             code -= 128;
215         }
216     } else {
217         code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
218         /* same remark */
219         if (code < 0) {
220             code = get_bits(&s->gb, 9);
221             if (code == 0x1fc) {
222                 code = (int8_t)(get_bits(&s->gb, 7) + 1);
223             } else if (code == 0x1fd) {
224                 code = -128 + get_bits(&s->gb, 7);
225             } else if (code == 0x1fe) {
226                 skip_bits(&s->gb, 9);
227                 code = 1;
228             } else {
229                 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
230                 return 0xffff;
231             }
232         } else {
233             code -= 128;
234         }
235     }
236     return -code;
237 }
238
239 /* read RV 1.0 compatible frame header */
240 static int rv10_decode_picture_header(MpegEncContext *s)
241 {
242     int mb_count, pb_frame, marker, mb_xy;
243
244     marker = get_bits1(&s->gb);
245
246     if (get_bits1(&s->gb))
247         s->pict_type = AV_PICTURE_TYPE_P;
248     else
249         s->pict_type = AV_PICTURE_TYPE_I;
250     if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
251     pb_frame = get_bits1(&s->gb);
252
253     av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
254
255     if (pb_frame){
256         av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
257         return -1;
258     }
259
260     s->qscale = get_bits(&s->gb, 5);
261     if(s->qscale==0){
262         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
263         return -1;
264     }
265
266     if (s->pict_type == AV_PICTURE_TYPE_I) {
267         if (s->rv10_version == 3) {
268             /* specific MPEG like DC coding not used */
269             s->last_dc[0] = get_bits(&s->gb, 8);
270             s->last_dc[1] = get_bits(&s->gb, 8);
271             s->last_dc[2] = get_bits(&s->gb, 8);
272             av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
273                     s->last_dc[1], s->last_dc[2]);
274         }
275     }
276     /* if multiple packets per frame are sent, the position at which
277        to display the macroblocks is coded here */
278
279     mb_xy= s->mb_x + s->mb_y*s->mb_width;
280     if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
281         s->mb_x = get_bits(&s->gb, 6); /* mb_x */
282         s->mb_y = get_bits(&s->gb, 6); /* mb_y */
283         mb_count = get_bits(&s->gb, 12);
284     } else {
285         s->mb_x = 0;
286         s->mb_y = 0;
287         mb_count = s->mb_width * s->mb_height;
288     }
289     skip_bits(&s->gb, 3);   /* ignored */
290     s->f_code = 1;
291     s->unrestricted_mv = 1;
292
293     return mb_count;
294 }
295
296 static int rv20_decode_picture_header(MpegEncContext *s)
297 {
298     int seq, mb_pos, i;
299     int rpr_bits;
300
301     i= get_bits(&s->gb, 2);
302     switch(i){
303     case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
304     case 1: s->pict_type= AV_PICTURE_TYPE_I; break; //hmm ...
305     case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
306     case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
307     default:
308         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
309         return -1;
310     }
311
312     if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
313         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
314         return -1;
315     }
316
317     if (get_bits1(&s->gb)){
318         av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
319         return -1;
320     }
321
322     s->qscale = get_bits(&s->gb, 5);
323     if(s->qscale==0){
324         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
325         return -1;
326     }
327
328     if(RV_GET_MINOR_VER(s->avctx->sub_id) >= 2)
329         s->loop_filter = get_bits1(&s->gb);
330
331     if(RV_GET_MINOR_VER(s->avctx->sub_id) <= 1)
332         seq = get_bits(&s->gb, 8) << 7;
333     else
334         seq = get_bits(&s->gb, 13) << 2;
335
336     rpr_bits = s->avctx->extradata[1] & 7;
337     if(rpr_bits){
338         int f, new_w, new_h;
339         rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
340
341         f = get_bits(&s->gb, rpr_bits);
342
343         if(f){
344             new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
345             new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
346         }else{
347             new_w= s->orig_width ;
348             new_h= s->orig_height;
349         }
350         if(new_w != s->width || new_h != s->height){
351             av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
352             if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
353                 return -1;
354             MPV_common_end(s);
355             avcodec_set_dimensions(s->avctx, new_w, new_h);
356             s->width  = new_w;
357             s->height = new_h;
358             if (MPV_common_init(s) < 0)
359                 return -1;
360         }
361
362         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
363             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
364         }
365     }
366
367     mb_pos = ff_h263_decode_mba(s);
368
369 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
370     seq |= s->time &~0x7FFF;
371     if(seq - s->time >  0x4000) seq -= 0x8000;
372     if(seq - s->time < -0x4000) seq += 0x8000;
373     if(seq != s->time){
374         if(s->pict_type!=AV_PICTURE_TYPE_B){
375             s->time= seq;
376             s->pp_time= s->time - s->last_non_b_time;
377             s->last_non_b_time= s->time;
378         }else{
379             s->time= seq;
380             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
381             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
382                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
383                 return FRAME_SKIPPED;
384             }
385             ff_mpeg4_init_direct_mv(s);
386         }
387     }
388 //    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
389 /*for(i=0; i<32; i++){
390     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
391 }
392 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
393     s->no_rounding= get_bits1(&s->gb);
394
395     if(RV_GET_MINOR_VER(s->avctx->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
396         skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
397
398     s->f_code = 1;
399     s->unrestricted_mv = 1;
400     s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
401 //    s->alt_inter_vlc=1;
402 //    s->obmc=1;
403 //    s->umvplus=1;
404     s->modified_quant=1;
405     if(!s->avctx->lowres)
406         s->loop_filter=1;
407
408     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
409             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
410                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
411     }
412
413     assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
414
415     return s->mb_width*s->mb_height - mb_pos;
416 }
417
418 static av_cold int rv10_decode_init(AVCodecContext *avctx)
419 {
420     MpegEncContext *s = avctx->priv_data;
421     static int done=0;
422     int major_ver, minor_ver, micro_ver;
423
424     if (avctx->extradata_size < 8) {
425         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
426         return -1;
427     }
428
429     MPV_decode_defaults(s);
430
431     s->avctx= avctx;
432     s->out_format = FMT_H263;
433     s->codec_id= avctx->codec_id;
434     avctx->flags |= CODEC_FLAG_EMU_EDGE;
435
436     s->orig_width = s->width  = avctx->coded_width;
437     s->orig_height= s->height = avctx->coded_height;
438
439     s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
440     avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
441
442     major_ver = RV_GET_MAJOR_VER(avctx->sub_id);
443     minor_ver = RV_GET_MINOR_VER(avctx->sub_id);
444     micro_ver = RV_GET_MICRO_VER(avctx->sub_id);
445
446     s->low_delay = 1;
447     switch (major_ver) {
448     case 1:
449         s->rv10_version = micro_ver ? 3 : 1;
450         s->obmc = micro_ver == 2;
451         break;
452     case 2:
453         if (minor_ver >= 2) {
454             s->low_delay = 0;
455             s->avctx->has_b_frames = 1;
456         }
457         break;
458     default:
459         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
460         av_log_missing_feature(avctx, "RV1/2 version", 1);
461         return AVERROR_PATCHWELCOME;
462     }
463
464     if(avctx->debug & FF_DEBUG_PICT_INFO){
465         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
466     }
467
468     avctx->pix_fmt = PIX_FMT_YUV420P;
469
470     if (MPV_common_init(s) < 0)
471         return -1;
472
473     h263_decode_init_vlc(s);
474
475     /* init rv vlc */
476     if (!done) {
477         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
478                  rv_lum_bits, 1, 1,
479                  rv_lum_code, 2, 2, 16384);
480         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
481                  rv_chrom_bits, 1, 1,
482                  rv_chrom_code, 2, 2, 16388);
483         done = 1;
484     }
485
486     return 0;
487 }
488
489 static av_cold int rv10_decode_end(AVCodecContext *avctx)
490 {
491     MpegEncContext *s = avctx->priv_data;
492
493     MPV_common_end(s);
494     return 0;
495 }
496
497 static int rv10_decode_packet(AVCodecContext *avctx,
498                              const uint8_t *buf, int buf_size, int buf_size2)
499 {
500     MpegEncContext *s = avctx->priv_data;
501     int mb_count, mb_pos, left, start_mb_x;
502
503     init_get_bits(&s->gb, buf, buf_size*8);
504     if(s->codec_id ==CODEC_ID_RV10)
505         mb_count = rv10_decode_picture_header(s);
506     else
507         mb_count = rv20_decode_picture_header(s);
508     if (mb_count < 0) {
509         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
510         return -1;
511     }
512
513     if (s->mb_x >= s->mb_width ||
514         s->mb_y >= s->mb_height) {
515         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
516         return -1;
517     }
518     mb_pos = s->mb_y * s->mb_width + s->mb_x;
519     left = s->mb_width * s->mb_height - mb_pos;
520     if (mb_count > left) {
521         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
522         return -1;
523     }
524
525     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
526         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
527             ff_er_frame_end(s);
528             MPV_frame_end(s);
529             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
530         }
531         if(MPV_frame_start(s, avctx) < 0)
532             return -1;
533         ff_er_frame_start(s);
534     } else {
535         if (s->current_picture_ptr->f.pict_type != s->pict_type) {
536             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
537             return -1;
538         }
539     }
540
541     av_dlog(avctx, "qscale=%d\n", s->qscale);
542
543     /* default quantization values */
544     if(s->codec_id== CODEC_ID_RV10){
545         if(s->mb_y==0) s->first_slice_line=1;
546     }else{
547         s->first_slice_line=1;
548         s->resync_mb_x= s->mb_x;
549     }
550     start_mb_x= s->mb_x;
551     s->resync_mb_y= s->mb_y;
552     if(s->h263_aic){
553         s->y_dc_scale_table=
554         s->c_dc_scale_table= ff_aic_dc_scale_table;
555     }else{
556         s->y_dc_scale_table=
557         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
558     }
559
560     if(s->modified_quant)
561         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
562
563     ff_set_qscale(s, s->qscale);
564
565     s->rv10_first_dc_coded[0] = 0;
566     s->rv10_first_dc_coded[1] = 0;
567     s->rv10_first_dc_coded[2] = 0;
568     s->block_wrap[0]=
569     s->block_wrap[1]=
570     s->block_wrap[2]=
571     s->block_wrap[3]= s->b8_stride;
572     s->block_wrap[4]=
573     s->block_wrap[5]= s->mb_stride;
574     ff_init_block_index(s);
575     /* decode each macroblock */
576
577     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
578         int ret;
579         ff_update_block_index(s);
580         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
581
582         s->mv_dir = MV_DIR_FORWARD;
583         s->mv_type = MV_TYPE_16X16;
584         ret=ff_h263_decode_mb(s, s->block);
585
586         if (ret != SLICE_ERROR && s->gb.size_in_bits < get_bits_count(&s->gb) && 8*buf_size2 >= get_bits_count(&s->gb)){
587             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n", s->gb.size_in_bits, 8*buf_size2);
588             s->gb.size_in_bits= 8*buf_size2;
589             ret= SLICE_OK;
590         }
591
592         if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
593             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
594             return -1;
595         }
596         if(s->pict_type != AV_PICTURE_TYPE_B)
597             ff_h263_update_motion_val(s);
598         MPV_decode_mb(s, s->block);
599         if(s->loop_filter)
600             ff_h263_loop_filter(s);
601
602         if (++s->mb_x == s->mb_width) {
603             s->mb_x = 0;
604             s->mb_y++;
605             ff_init_block_index(s);
606         }
607         if(s->mb_x == s->resync_mb_x)
608             s->first_slice_line=0;
609         if(ret == SLICE_END) break;
610     }
611
612     ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
613
614     return s->gb.size_in_bits;
615 }
616
617 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
618 {
619     if(avctx->slice_count) return avctx->slice_offset[n];
620     else                   return AV_RL32(buf + n*8);
621 }
622
623 static int rv10_decode_frame(AVCodecContext *avctx,
624                              void *data, int *data_size,
625                              AVPacket *avpkt)
626 {
627     const uint8_t *buf = avpkt->data;
628     int buf_size = avpkt->size;
629     MpegEncContext *s = avctx->priv_data;
630     int i;
631     AVFrame *pict = data;
632     int slice_count;
633     const uint8_t *slices_hdr = NULL;
634
635     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
636
637     /* no supplementary picture */
638     if (buf_size == 0) {
639         return 0;
640     }
641
642     if(!avctx->slice_count){
643         slice_count = (*buf++) + 1;
644         slices_hdr = buf + 4;
645         buf += 8 * slice_count;
646     }else
647         slice_count = avctx->slice_count;
648
649     for(i=0; i<slice_count; i++){
650         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
651         int size, size2;
652
653         if (offset >= buf_size)
654             return AVERROR_INVALIDDATA;
655
656         if(i+1 == slice_count)
657             size= buf_size - offset;
658         else
659             size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
660
661         if(i+2 >= slice_count)
662             size2= buf_size - offset;
663         else
664             size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
665
666         if (size <= 0 || size2 <= 0 ||
667             offset + FFMAX(size, size2) > buf_size)
668             return AVERROR_INVALIDDATA;
669
670         if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
671             i++;
672     }
673
674     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
675         ff_er_frame_end(s);
676         MPV_frame_end(s);
677
678         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
679             *pict= *(AVFrame*)s->current_picture_ptr;
680         } else if (s->last_picture_ptr != NULL) {
681             *pict= *(AVFrame*)s->last_picture_ptr;
682         }
683
684         if(s->last_picture_ptr || s->low_delay){
685             *data_size = sizeof(AVFrame);
686             ff_print_debug_info(s, pict);
687         }
688         s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
689     }
690
691     return buf_size;
692 }
693
694 AVCodec ff_rv10_decoder = {
695     .name           = "rv10",
696     .type           = AVMEDIA_TYPE_VIDEO,
697     .id             = CODEC_ID_RV10,
698     .priv_data_size = sizeof(MpegEncContext),
699     .init           = rv10_decode_init,
700     .close          = rv10_decode_end,
701     .decode         = rv10_decode_frame,
702     .capabilities   = CODEC_CAP_DR1,
703     .max_lowres = 3,
704     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
705     .pix_fmts= ff_pixfmt_list_420,
706 };
707
708 AVCodec ff_rv20_decoder = {
709     .name           = "rv20",
710     .type           = AVMEDIA_TYPE_VIDEO,
711     .id             = CODEC_ID_RV20,
712     .priv_data_size = sizeof(MpegEncContext),
713     .init           = rv10_decode_init,
714     .close          = rv10_decode_end,
715     .decode         = rv10_decode_frame,
716     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
717     .flush= ff_mpeg_flush,
718     .max_lowres = 3,
719     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
720     .pix_fmts= ff_pixfmt_list_420,
721 };