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