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