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