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