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