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