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