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