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