fixing rv10, this isnt the cleanest solution (parsing the packet header in the codec...
[libav.git] / libavcodec / rv10.c
1 /*
2 * RV10 codec
3 * Copyright (c) 2000,2001 Fabrice Bellard.
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19 #include "avcodec.h"
20 #include "dsputil.h"
21 #include "mpegvideo.h"
22
23 //#define DEBUG
24
25 #define DC_VLC_BITS 14 //FIXME find a better solution
26
27 static const UINT16 rv_lum_code[256] =
28 {
29 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
30 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
31 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
32 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
33 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
34 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
35 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
36 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
37 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
38 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
39 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
40 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
41 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
42 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
43 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
44 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
45 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
46 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
47 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
48 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
49 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
50 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
51 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
52 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
53 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
54 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
55 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
56 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
57 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
58 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
59 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
60 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
61 };
62
63 static const UINT8 rv_lum_bits[256] =
64 {
65 14, 12, 12, 12, 12, 12, 12, 12,
66 12, 12, 12, 12, 12, 12, 12, 12,
67 12, 12, 12, 12, 12, 12, 12, 12,
68 12, 12, 12, 12, 12, 12, 12, 12,
69 12, 12, 12, 12, 12, 12, 12, 12,
70 12, 12, 12, 12, 12, 12, 12, 12,
71 12, 12, 12, 12, 12, 12, 12, 12,
72 12, 12, 12, 12, 12, 12, 12, 12,
73 12, 10, 10, 10, 10, 10, 10, 10,
74 10, 10, 10, 10, 10, 10, 10, 10,
75 10, 10, 10, 10, 10, 10, 10, 10,
76 10, 10, 10, 10, 10, 10, 10, 10,
77 10, 8, 8, 8, 8, 8, 8, 8,
78 8, 8, 8, 8, 8, 8, 8, 8,
79 8, 7, 7, 7, 7, 7, 7, 7,
80 7, 6, 6, 6, 6, 5, 5, 4,
81 2, 4, 5, 5, 6, 6, 6, 6,
82 7, 7, 7, 7, 7, 7, 7, 7,
83 8, 8, 8, 8, 8, 8, 8, 8,
84 8, 8, 8, 8, 8, 8, 8, 8,
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, 10, 10, 10, 10, 10, 10, 10,
89 12, 12, 12, 12, 12, 12, 12, 12,
90 12, 12, 12, 12, 12, 12, 12, 12,
91 12, 12, 12, 12, 12, 12, 12, 12,
92 12, 12, 12, 12, 12, 12, 12, 12,
93 12, 12, 12, 12, 12, 12, 12, 12,
94 12, 12, 12, 12, 12, 12, 12, 12,
95 12, 12, 12, 12, 12, 12, 12, 12,
96 12, 12, 12, 12, 12, 12, 12, 12,
97 };
98
99 static const UINT16 rv_chrom_code[256] =
100 {
101 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
102 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
103 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
104 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
105 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
106 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
107 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
108 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
109 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
110 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
111 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
112 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
113 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
114 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
115 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
116 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
117 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
118 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
119 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
120 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
121 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
122 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
123 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
124 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
125 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
126 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
127 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
128 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
129 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
130 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
131 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
132 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
133 };
134
135 static const UINT8 rv_chrom_bits[256] =
136 {
137 16, 14, 14, 14, 14, 14, 14, 14,
138 14, 14, 14, 14, 14, 14, 14, 14,
139 14, 14, 14, 14, 14, 14, 14, 14,
140 14, 14, 14, 14, 14, 14, 14, 14,
141 14, 14, 14, 14, 14, 14, 14, 14,
142 14, 14, 14, 14, 14, 14, 14, 14,
143 14, 14, 14, 14, 14, 14, 14, 14,
144 14, 14, 14, 14, 14, 14, 14, 14,
145 14, 12, 12, 12, 12, 12, 12, 12,
146 12, 12, 12, 12, 12, 12, 12, 12,
147 12, 12, 12, 12, 12, 12, 12, 12,
148 12, 12, 12, 12, 12, 12, 12, 12,
149 12, 10, 10, 10, 10, 10, 10, 10,
150 10, 10, 10, 10, 10, 10, 10, 10,
151 10, 8, 8, 8, 8, 8, 8, 8,
152 8, 6, 6, 6, 6, 4, 4, 3,
153 2, 3, 4, 4, 6, 6, 6, 6,
154 8, 8, 8, 8, 8, 8, 8, 8,
155 10, 10, 10, 10, 10, 10, 10, 10,
156 10, 10, 10, 10, 10, 10, 10, 10,
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, 12, 12, 12, 12, 12, 12, 12,
161 14, 14, 14, 14, 14, 14, 14, 14,
162 14, 14, 14, 14, 14, 14, 14, 14,
163 14, 14, 14, 14, 14, 14, 14, 14,
164 14, 14, 14, 14, 14, 14, 14, 14,
165 14, 14, 14, 14, 14, 14, 14, 14,
166 14, 14, 14, 14, 14, 14, 14, 14,
167 14, 14, 14, 14, 14, 14, 14, 14,
168 14, 14, 14, 14, 14, 14, 14, 14,
169 };
170
171 static VLC rv_dc_lum, rv_dc_chrom;
172
173 int rv_decode_dc(MpegEncContext *s, int n)
174 {
175 int code;
176
177 if (n < 4) {
178 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
179 if (code < 0) {
180 /* XXX: I don't understand why they use LONGER codes than
181 necessary. The following code would be completely useless
182 if they had thought about it !!! */
183 code = get_bits(&s->gb, 7);
184 if (code == 0x7c) {
185 code = (INT8)(get_bits(&s->gb, 7) + 1);
186 } else if (code == 0x7d) {
187 code = -128 + get_bits(&s->gb, 7);
188 } else if (code == 0x7e) {
189 if (get_bits(&s->gb, 1) == 0)
190 code = (INT8)(get_bits(&s->gb, 8) + 1);
191 else
192 code = (INT8)(get_bits(&s->gb, 8));
193 } else if (code == 0x7f) {
194 get_bits(&s->gb, 11);
195 code = 1;
196 }
197 } else {
198 code -= 128;
199 }
200 } else {
201 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
202 /* same remark */
203 if (code < 0) {
204 code = get_bits(&s->gb, 9);
205 if (code == 0x1fc) {
206 code = (INT8)(get_bits(&s->gb, 7) + 1);
207 } else if (code == 0x1fd) {
208 code = -128 + get_bits(&s->gb, 7);
209 } else if (code == 0x1fe) {
210 get_bits(&s->gb, 9);
211 code = 1;
212 } else {
213 fprintf(stderr, "chroma dc error\n");
214 return 0xffff;
215 }
216 } else {
217 code -= 128;
218 }
219 }
220 return -code;
221 }
222
223 /* write RV 1.0 compatible frame header */
224 void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
225 {
226 int full_frame= 0;
227
228 align_put_bits(&s->pb);
229
230 put_bits(&s->pb, 1, 1); /* marker */
231
232 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
233
234 put_bits(&s->pb, 1, 0); /* not PB frame */
235
236 put_bits(&s->pb, 5, s->qscale);
237
238 if (s->pict_type == I_TYPE) {
239 /* specific MPEG like DC coding not used */
240 }
241 /* if multiple packets per frame are sent, the position at which
242 to display the macro blocks is coded here */
243 if(!full_frame){
244 put_bits(&s->pb, 6, 0); /* mb_x */
245 put_bits(&s->pb, 6, 0); /* mb_y */
246 put_bits(&s->pb, 12, s->mb_width * s->mb_height);
247 }
248
249 put_bits(&s->pb, 3, 0); /* ignored */
250 }
251
252 static int get_num(GetBitContext *gb)
253 {
254 int n, n1;
255
256 n = get_bits(gb, 16);
257 if (n >= 0x4000) {
258 return n - 0x4000;
259 } else {
260 n1 = get_bits(gb, 16);
261 return (n << 16) | n1;
262 }
263 }
264
265 /* read RV 1.0 compatible frame header */
266 static int rv10_decode_picture_header(MpegEncContext *s)
267 {
268 int mb_count, pb_frame, marker, h, full_frame;
269 int pic_num, unk;
270
271 //XXX/FIXME this should be done in the demuxer not here
272 /* skip packet header */
273 h = get_bits(&s->gb, 8);
274 if ((h & 0xc0) == 0xc0) {
275 int len, pos;
276 full_frame = 1;
277 len = get_num(&s->gb);
278 pos = get_num(&s->gb);
279 //printf("pos:%d\n",len);
280 } else {
281 int seq, frame_size, pos;
282 full_frame = 0;
283 seq = get_bits(&s->gb, 8);
284 frame_size = get_num(&s->gb);
285 pos = get_num(&s->gb);
286 //printf("seq:%d, size:%d, pos:%d\n",seq,frame_size,pos);
287 }
288 /* picture number */
289 pic_num= get_bits(&s->gb, 8);
290
291 marker = get_bits(&s->gb, 1);
292
293 if (get_bits(&s->gb, 1))
294 s->pict_type = P_TYPE;
295 else
296 s->pict_type = I_TYPE;
297 //printf("h:%d ver:%d\n",h,s->rv10_version);
298 if(!marker) printf("marker missing\n");
299 pb_frame = get_bits(&s->gb, 1);
300
301 #ifdef DEBUG
302 printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
303 #endif
304
305 if (pb_frame){
306 fprintf(stderr, "pb frame not supported\n");
307 return -1;
308 }
309
310 s->qscale = get_bits(&s->gb, 5);
311 if(s->qscale==0){
312 fprintf(stderr, "error, qscale:0\n");
313 return -1;
314 }
315
316 if (s->pict_type == I_TYPE) {
317 if (s->rv10_version == 3) {
318 /* specific MPEG like DC coding not used */
319 s->last_dc[0] = get_bits(&s->gb, 8);
320 s->last_dc[1] = get_bits(&s->gb, 8);
321 s->last_dc[2] = get_bits(&s->gb, 8);
322 #ifdef DEBUG
323 printf("DC:%d %d %d\n",
324 s->last_dc[0],
325 s->last_dc[1],
326 s->last_dc[2]);
327 #endif
328 }
329 }
330 /* if multiple packets per frame are sent, the position at which
331 to display the macro blocks is coded here */
332 if (!full_frame) {
333 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
334 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
335 mb_count = get_bits(&s->gb, 12);
336 } else {
337 s->mb_x = 0;
338 s->mb_y = 0;
339 mb_count = s->mb_width * s->mb_height;
340 }
341 unk= get_bits(&s->gb, 3); /* ignored */
342 //printf("%d\n", unk);
343 s->f_code = 1;
344 s->unrestricted_mv = 1;
345
346 return mb_count;
347 }
348
349 static int rv10_decode_init(AVCodecContext *avctx)
350 {
351 MpegEncContext *s = avctx->priv_data;
352 static int done;
353
354 s->avctx= avctx;
355 s->out_format = FMT_H263;
356
357 s->width = avctx->width;
358 s->height = avctx->height;
359
360 s->h263_rv10 = 1;
361 if(avctx->extradata_size >= 8){
362 switch(((uint32_t*)avctx->extradata)[1]){
363 case 0x10000000:
364 s->rv10_version= 0;
365 s->h263_long_vectors=0;
366 break;
367 case 0x10003000:
368 s->rv10_version= 3;
369 s->h263_long_vectors=1;
370 break;
371 case 0x10003001:
372 s->rv10_version= 3;
373 s->h263_long_vectors=0;
374 break;
375 default:
376 fprintf(stderr, "unknown header %X\n", ((uint32_t*)avctx->extradata)[1]);
377 }
378 }else{
379 // for backward compatibility
380 s->rv10_version= avctx->sub_id;
381 }
382
383 s->flags= avctx->flags;
384
385 if (MPV_common_init(s) < 0)
386 return -1;
387
388 h263_decode_init_vlc(s);
389
390 s->y_dc_scale_table=
391 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
392
393 /* init rv vlc */
394 if (!done) {
395 init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
396 rv_lum_bits, 1, 1,
397 rv_lum_code, 2, 2);
398 init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
399 rv_chrom_bits, 1, 1,
400 rv_chrom_code, 2, 2);
401 done = 1;
402 }
403
404 return 0;
405 }
406
407 static int rv10_decode_end(AVCodecContext *avctx)
408 {
409 MpegEncContext *s = avctx->priv_data;
410
411 MPV_common_end(s);
412 return 0;
413 }
414
415 static int rv10_decode_frame(AVCodecContext *avctx,
416 void *data, int *data_size,
417 UINT8 *buf, int buf_size)
418 {
419 MpegEncContext *s = avctx->priv_data;
420 int i, mb_count, mb_pos, left;
421 DCTELEM block[6][64];
422 AVPicture *pict = data;
423
424 #ifdef DEBUG
425 printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
426 #endif
427
428 /* no supplementary picture */
429 if (buf_size == 0) {
430 *data_size = 0;
431 return 0;
432 }
433
434 init_get_bits(&s->gb, buf, buf_size);
435
436 mb_count = rv10_decode_picture_header(s);
437 if (mb_count < 0) {
438 fprintf(stderr, "HEADER ERROR\n");
439 return -1;
440 }
441
442 if (s->mb_x >= s->mb_width ||
443 s->mb_y >= s->mb_height) {
444 fprintf(stderr, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
445 return -1;
446 }
447 mb_pos = s->mb_y * s->mb_width + s->mb_x;
448 left = s->mb_width * s->mb_height - mb_pos;
449 if (mb_count > left) {
450 fprintf(stderr, "COUNT ERROR\n");
451 return -1;
452 }
453
454 if (s->mb_x == 0 && s->mb_y == 0) {
455 MPV_frame_start(s, avctx);
456 }
457
458 #ifdef DEBUG
459 printf("qscale=%d\n", s->qscale);
460 #endif
461
462 /* default quantization values */
463 s->y_dc_scale = 8;
464 s->c_dc_scale = 8;
465 s->rv10_first_dc_coded[0] = 0;
466 s->rv10_first_dc_coded[1] = 0;
467 s->rv10_first_dc_coded[2] = 0;
468
469 s->block_wrap[0]=
470 s->block_wrap[1]=
471 s->block_wrap[2]=
472 s->block_wrap[3]= s->mb_width*2 + 2;
473 s->block_wrap[4]=
474 s->block_wrap[5]= s->mb_width + 2;
475 s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
476 s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1) + s->mb_x*2;
477 s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
478 s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2) + s->mb_x*2;
479 s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
480 s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
481 /* decode each macroblock */
482 for(i=0;i<mb_count;i++) {
483 s->block_index[0]+=2;
484 s->block_index[1]+=2;
485 s->block_index[2]+=2;
486 s->block_index[3]+=2;
487 s->block_index[4]++;
488 s->block_index[5]++;
489 #ifdef DEBUG
490 printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
491 #endif
492
493 memset(block, 0, sizeof(block));
494 s->mv_dir = MV_DIR_FORWARD;
495 s->mv_type = MV_TYPE_16X16;
496 if (h263_decode_mb(s, block) < 0) {
497 fprintf(stderr, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
498 return -1;
499 }
500 MPV_decode_mb(s, block);
501 if (++s->mb_x == s->mb_width) {
502 s->mb_x = 0;
503 s->mb_y++;
504 s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1;
505 s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1);
506 s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1;
507 s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2);
508 s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2);
509 s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
510 }
511 }
512
513 if (s->mb_x == 0 &&
514 s->mb_y == s->mb_height) {
515 MPV_frame_end(s);
516
517 pict->data[0] = s->current_picture[0];
518 pict->data[1] = s->current_picture[1];
519 pict->data[2] = s->current_picture[2];
520 pict->linesize[0] = s->linesize;
521 pict->linesize[1] = s->uvlinesize;
522 pict->linesize[2] = s->uvlinesize;
523
524 avctx->quality = s->qscale;
525 *data_size = sizeof(AVPicture);
526 } else {
527 *data_size = 0;
528 }
529 return buf_size;
530 }
531
532 AVCodec rv10_decoder = {
533 "rv10",
534 CODEC_TYPE_VIDEO,
535 CODEC_ID_RV10,
536 sizeof(MpegEncContext),
537 rv10_decode_init,
538 NULL,
539 rv10_decode_end,
540 rv10_decode_frame,
541 CODEC_CAP_DR1
542 };