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