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