Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ ea937d01

History | View | Annotate | Download (16.3 KB)

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*8);
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
    AVFrame *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= *(AVFrame*)&s->current_picture;
509
    
510
        *data_size = sizeof(AVFrame);
511
    }else{
512
        *data_size = 0;
513
    }
514

    
515
    return buf_size;
516
}
517

    
518
AVCodec rv10_decoder = {
519
    "rv10",
520
    CODEC_TYPE_VIDEO,
521
    CODEC_ID_RV10,
522
    sizeof(MpegEncContext),
523
    rv10_decode_init,
524
    NULL,
525
    rv10_decode_end,
526
    rv10_decode_frame,
527
    CODEC_CAP_DR1
528
};