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