* using DSPContext - so each codec could use its local (sub)set of CPU extension
[ffmpeg.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, full_frame, unk;
269     
270     full_frame= s->avctx->slice_count==1;
271 //printf("ff:%d\n", full_frame);
272     marker = get_bits(&s->gb, 1);
273
274     if (get_bits(&s->gb, 1))
275         s->pict_type = P_TYPE;
276     else
277         s->pict_type = I_TYPE;
278 //printf("h:%X ver:%d\n",h,s->rv10_version);
279     if(!marker) printf("marker missing\n");
280     pb_frame = get_bits(&s->gb, 1);
281
282 #ifdef DEBUG
283     printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
284 #endif
285     
286     if (pb_frame){
287         fprintf(stderr, "pb frame not supported\n");
288         return -1;
289     }
290
291     s->qscale = get_bits(&s->gb, 5);
292     if(s->qscale==0){
293         fprintf(stderr, "error, qscale:0\n");
294         return -1;
295     }
296
297     if (s->pict_type == I_TYPE) {
298         if (s->rv10_version == 3) {
299             /* specific MPEG like DC coding not used */
300             s->last_dc[0] = get_bits(&s->gb, 8);
301             s->last_dc[1] = get_bits(&s->gb, 8);
302             s->last_dc[2] = get_bits(&s->gb, 8);
303 #ifdef DEBUG
304             printf("DC:%d %d %d\n",
305                    s->last_dc[0],
306                    s->last_dc[1],
307                    s->last_dc[2]);
308 #endif
309         }
310     }
311     /* if multiple packets per frame are sent, the position at which
312        to display the macro blocks is coded here */
313     if ((!full_frame) || show_bits(&s->gb, 12)==0) {
314         s->mb_x = get_bits(&s->gb, 6);  /* mb_x */
315         s->mb_y = get_bits(&s->gb, 6);  /* mb_y */
316         mb_count = get_bits(&s->gb, 12);
317     } else {
318         s->mb_x = 0;
319         s->mb_y = 0;
320         mb_count = s->mb_width * s->mb_height;
321     }
322     unk= get_bits(&s->gb, 3);   /* ignored */
323 //printf("%d\n", unk);
324     s->f_code = 1;
325     s->unrestricted_mv = 1;
326
327     return mb_count;
328 }
329
330 static int rv10_decode_init(AVCodecContext *avctx)
331 {
332     MpegEncContext *s = avctx->priv_data;
333     static int done;
334
335     s->avctx= avctx;
336     s->out_format = FMT_H263;
337
338     s->width = avctx->width;
339     s->height = avctx->height;
340
341     s->h263_rv10 = 1;
342     switch(avctx->sub_id){
343     case 0x10000000:
344         s->rv10_version= 0;
345         s->h263_long_vectors=0;
346         break;
347     case 0x10003000:
348         s->rv10_version= 3;
349         s->h263_long_vectors=1;
350         break;
351     case 0x10003001:
352         s->rv10_version= 3;
353         s->h263_long_vectors=0;
354         break;
355     default:
356         fprintf(stderr, "unknown header %X\n", avctx->sub_id);
357     }
358 //printf("ver:%X\n", avctx->sub_id);
359     s->flags= avctx->flags;
360
361     if (MPV_common_init(s) < 0)
362         return -1;
363
364     h263_decode_init_vlc(s);
365
366     s->y_dc_scale_table=
367     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
368     s->progressive_sequence=1;
369
370     /* init rv vlc */
371     if (!done) {
372         init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
373                  rv_lum_bits, 1, 1,
374                  rv_lum_code, 2, 2);
375         init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
376                  rv_chrom_bits, 1, 1,
377                  rv_chrom_code, 2, 2);
378         done = 1;
379     }
380
381     return 0;
382 }
383
384 static int rv10_decode_end(AVCodecContext *avctx)
385 {
386     MpegEncContext *s = avctx->priv_data;
387
388     MPV_common_end(s);
389     return 0;
390 }
391
392 static int rv10_decode_packet(AVCodecContext *avctx, 
393                              UINT8 *buf, int buf_size)
394 {
395     MpegEncContext *s = avctx->priv_data;
396     int i, mb_count, mb_pos, left;
397
398     init_get_bits(&s->gb, buf, buf_size);
399     
400     mb_count = rv10_decode_picture_header(s);
401     if (mb_count < 0) {
402         fprintf(stderr, "HEADER ERROR\n");
403         return -1;
404     }
405     
406     if (s->mb_x >= s->mb_width ||
407         s->mb_y >= s->mb_height) {
408         fprintf(stderr, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
409         return -1;
410     }
411     mb_pos = s->mb_y * s->mb_width + s->mb_x;
412     left = s->mb_width * s->mb_height - mb_pos;
413     if (mb_count > left) {
414         fprintf(stderr, "COUNT ERROR\n");
415         return -1;
416     }
417
418     if (s->mb_x == 0 && s->mb_y == 0) {
419         if(MPV_frame_start(s, avctx) < 0)
420             return -1;
421     }
422
423 #ifdef DEBUG
424     printf("qscale=%d\n", s->qscale);
425 #endif
426
427     /* default quantization values */
428     s->y_dc_scale = 8;
429     s->c_dc_scale = 8;
430     s->rv10_first_dc_coded[0] = 0;
431     s->rv10_first_dc_coded[1] = 0;
432     s->rv10_first_dc_coded[2] = 0;
433
434     if(s->mb_y==0) s->first_slice_line=1;
435     
436     s->block_wrap[0]=
437     s->block_wrap[1]=
438     s->block_wrap[2]=
439     s->block_wrap[3]= s->mb_width*2 + 2;
440     s->block_wrap[4]=
441     s->block_wrap[5]= s->mb_width + 2;
442     ff_init_block_index(s);
443     /* decode each macroblock */
444     for(i=0;i<mb_count;i++) {
445         ff_update_block_index(s);
446 #ifdef DEBUG
447         printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
448 #endif
449         
450         s->dsp.clear_blocks(s->block[0]);
451         s->mv_dir = MV_DIR_FORWARD;
452         s->mv_type = MV_TYPE_16X16; 
453         if (ff_h263_decode_mb(s, s->block) == SLICE_ERROR) {
454             fprintf(stderr, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
455             return -1;
456         }
457         MPV_decode_mb(s, s->block);
458         if (++s->mb_x == s->mb_width) {
459             s->mb_x = 0;
460             s->mb_y++;
461             ff_init_block_index(s);
462             s->first_slice_line=0;
463         }
464     }
465
466     return buf_size;
467 }
468
469 static int rv10_decode_frame(AVCodecContext *avctx, 
470                              void *data, int *data_size,
471                              UINT8 *buf, int buf_size)
472 {
473     MpegEncContext *s = avctx->priv_data;
474     int i;
475     AVPicture *pict = data; 
476
477 #ifdef DEBUG
478     printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
479 #endif
480
481     /* no supplementary picture */
482     if (buf_size == 0) {
483         *data_size = 0;
484         return 0;
485     }
486     
487     if(avctx->slice_count){
488         for(i=0; i<avctx->slice_count; i++){
489             int offset= avctx->slice_offset[i];
490             int size;
491             
492             if(i+1 == avctx->slice_count)
493                 size= buf_size - offset;
494             else
495                 size= avctx->slice_offset[i+1] - offset;
496
497             if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
498                 return -1;
499         }
500     }else{
501         if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
502             return -1;
503     }
504
505     if(s->mb_y>=s->mb_height){
506         MPV_frame_end(s);
507         
508         pict->data[0] = s->current_picture[0];
509         pict->data[1] = s->current_picture[1];
510         pict->data[2] = s->current_picture[2];
511         pict->linesize[0] = s->linesize;
512         pict->linesize[1] = s->uvlinesize;
513         pict->linesize[2] = s->uvlinesize;
514     
515         avctx->quality = s->qscale;
516         *data_size = sizeof(AVPicture);
517     }else{
518         *data_size = 0;
519     }
520
521     return buf_size;
522 }
523
524 AVCodec rv10_decoder = {
525     "rv10",
526     CODEC_TYPE_VIDEO,
527     CODEC_ID_RV10,
528     sizeof(MpegEncContext),
529     rv10_decode_init,
530     NULL,
531     rv10_decode_end,
532     rv10_decode_frame,
533     CODEC_CAP_DR1
534 };