Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 983e3246

History | View | Annotate | Download (16.4 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

    
20
/**
21
 * @file rv10.c
22
 * RV10 codec.
23
 */
24
 
25
#include "avcodec.h"
26
#include "dsputil.h"
27
#include "mpegvideo.h"
28

    
29
//#define DEBUG
30

    
31
#define DC_VLC_BITS 14 //FIXME find a better solution
32

    
33
static const uint16_t rv_lum_code[256] =
34
{
35
 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
36
 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
37
 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
38
 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
39
 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
40
 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
41
 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
42
 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
43
 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
44
 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
45
 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
46
 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
47
 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
48
 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
49
 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
50
 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
51
 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
52
 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
53
 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
54
 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
55
 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
56
 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
57
 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
58
 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
59
 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
60
 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
61
 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
62
 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
63
 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
64
 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
65
 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
66
 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
67
};
68

    
69
static const uint8_t rv_lum_bits[256] = 
70
{
71
 14, 12, 12, 12, 12, 12, 12, 12,
72
 12, 12, 12, 12, 12, 12, 12, 12,
73
 12, 12, 12, 12, 12, 12, 12, 12,
74
 12, 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, 10, 10, 10, 10, 10, 10, 10,
80
 10, 10, 10, 10, 10, 10, 10, 10,
81
 10, 10, 10, 10, 10, 10, 10, 10,
82
 10, 10, 10, 10, 10, 10, 10, 10,
83
 10,  8,  8,  8,  8,  8,  8,  8,
84
  8,  8,  8,  8,  8,  8,  8,  8,
85
  8,  7,  7,  7,  7,  7,  7,  7,
86
  7,  6,  6,  6,  6,  5,  5,  4,
87
  2,  4,  5,  5,  6,  6,  6,  6,
88
  7,  7,  7,  7,  7,  7,  7,  7,
89
  8,  8,  8,  8,  8,  8,  8,  8,
90
  8,  8,  8,  8,  8,  8,  8,  8,
91
 10, 10, 10, 10, 10, 10, 10, 10,
92
 10, 10, 10, 10, 10, 10, 10, 10,
93
 10, 10, 10, 10, 10, 10, 10, 10,
94
 10, 10, 10, 10, 10, 10, 10, 10,
95
 12, 12, 12, 12, 12, 12, 12, 12,
96
 12, 12, 12, 12, 12, 12, 12, 12,
97
 12, 12, 12, 12, 12, 12, 12, 12,
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
};
104

    
105
static const uint16_t rv_chrom_code[256] =
106
{
107
 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
108
 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
109
 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
110
 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
111
 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
112
 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
113
 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
114
 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
115
 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
116
 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
117
 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
118
 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
119
 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
120
 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
121
 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
122
 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
123
 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
124
 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
125
 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
126
 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
127
 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
128
 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
129
 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
130
 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
131
 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
132
 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
133
 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
134
 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
135
 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
136
 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
137
 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
138
 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
139
};
140

    
141
static const uint8_t rv_chrom_bits[256] =
142
{
143
 16, 14, 14, 14, 14, 14, 14, 14,
144
 14, 14, 14, 14, 14, 14, 14, 14,
145
 14, 14, 14, 14, 14, 14, 14, 14,
146
 14, 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, 12, 12, 12, 12, 12, 12, 12,
152
 12, 12, 12, 12, 12, 12, 12, 12,
153
 12, 12, 12, 12, 12, 12, 12, 12,
154
 12, 12, 12, 12, 12, 12, 12, 12,
155
 12, 10, 10, 10, 10, 10, 10, 10,
156
 10, 10, 10, 10, 10, 10, 10, 10,
157
 10,  8,  8,  8,  8,  8,  8,  8,
158
  8,  6,  6,  6,  6,  4,  4,  3,
159
  2,  3,  4,  4,  6,  6,  6,  6,
160
  8,  8,  8,  8,  8,  8,  8,  8,
161
 10, 10, 10, 10, 10, 10, 10, 10,
162
 10, 10, 10, 10, 10, 10, 10, 10,
163
 12, 12, 12, 12, 12, 12, 12, 12,
164
 12, 12, 12, 12, 12, 12, 12, 12,
165
 12, 12, 12, 12, 12, 12, 12, 12,
166
 12, 12, 12, 12, 12, 12, 12, 12,
167
 14, 14, 14, 14, 14, 14, 14, 14,
168
 14, 14, 14, 14, 14, 14, 14, 14,
169
 14, 14, 14, 14, 14, 14, 14, 14,
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
};
176

    
177
static VLC rv_dc_lum, rv_dc_chrom;
178

    
179
int rv_decode_dc(MpegEncContext *s, int n)
180
{
181
    int code;
182

    
183
    if (n < 4) {
184
        code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
185
        if (code < 0) {
186
            /* XXX: I don't understand why they use LONGER codes than
187
               necessary. The following code would be completely useless
188
               if they had thought about it !!! */
189
            code = get_bits(&s->gb, 7);
190
            if (code == 0x7c) {
191
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
192
            } else if (code == 0x7d) {
193
                code = -128 + get_bits(&s->gb, 7);
194
            } else if (code == 0x7e) {
195
                if (get_bits(&s->gb, 1) == 0)
196
                    code = (int8_t)(get_bits(&s->gb, 8) + 1);
197
                else
198
                    code = (int8_t)(get_bits(&s->gb, 8));
199
            } else if (code == 0x7f) {
200
                get_bits(&s->gb, 11);
201
                code = 1;
202
            }
203
        } else {
204
            code -= 128;
205
        }
206
    } else {
207
        code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
208
        /* same remark */
209
        if (code < 0) {
210
            code = get_bits(&s->gb, 9);
211
            if (code == 0x1fc) {
212
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
213
            } else if (code == 0x1fd) {
214
                code = -128 + get_bits(&s->gb, 7);
215
            } else if (code == 0x1fe) {
216
                get_bits(&s->gb, 9);
217
                code = 1;
218
            } else {
219
                fprintf(stderr, "chroma dc error\n");
220
                return 0xffff;
221
            }
222
        } else {
223
            code -= 128;
224
        }
225
    }
226
    return -code;
227
}
228

    
229
#ifdef CONFIG_ENCODERS
230

    
231
/* write RV 1.0 compatible frame header */
232
void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
233
{
234
    int full_frame= 0;
235

    
236
    align_put_bits(&s->pb);
237
    
238
    put_bits(&s->pb, 1, 1);        /* marker */
239

    
240
    put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
241

    
242
    put_bits(&s->pb, 1, 0);        /* not PB frame */
243

    
244
    put_bits(&s->pb, 5, s->qscale);
245

    
246
    if (s->pict_type == I_TYPE) {
247
        /* specific MPEG like DC coding not used */
248
    }
249
    /* if multiple packets per frame are sent, the position at which
250
       to display the macro blocks is coded here */
251
    if(!full_frame){
252
        put_bits(&s->pb, 6, 0);        /* mb_x */
253
        put_bits(&s->pb, 6, 0);        /* mb_y */
254
        put_bits(&s->pb, 12, s->mb_width * s->mb_height);
255
    }
256

    
257
    put_bits(&s->pb, 3, 0);        /* ignored */
258
}
259

    
260
static int get_num(GetBitContext *gb)
261
{
262
    int n, n1;
263

    
264
    n = get_bits(gb, 16);
265
    if (n >= 0x4000) {
266
        return n - 0x4000;
267
    } else {
268
        n1 = get_bits(gb, 16);
269
        return (n << 16) | n1;
270
    }
271
}
272

    
273
#endif //CONFIG_ENCODERS
274

    
275
/* read RV 1.0 compatible frame header */
276
static int rv10_decode_picture_header(MpegEncContext *s)
277
{
278
    int mb_count, pb_frame, marker, full_frame, unk;
279
    
280
    full_frame= s->avctx->slice_count==1;
281
//printf("ff:%d\n", full_frame);
282
    marker = get_bits(&s->gb, 1);
283

    
284
    if (get_bits(&s->gb, 1))
285
        s->pict_type = P_TYPE;
286
    else
287
        s->pict_type = I_TYPE;
288
//printf("h:%X ver:%d\n",h,s->rv10_version);
289
    if(!marker) printf("marker missing\n");
290
    pb_frame = get_bits(&s->gb, 1);
291

    
292
#ifdef DEBUG
293
    printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
294
#endif
295
    
296
    if (pb_frame){
297
        fprintf(stderr, "pb frame not supported\n");
298
        return -1;
299
    }
300

    
301
    s->qscale = get_bits(&s->gb, 5);
302
    if(s->qscale==0){
303
        fprintf(stderr, "error, qscale:0\n");
304
        return -1;
305
    }
306

    
307
    if (s->pict_type == I_TYPE) {
308
        if (s->rv10_version == 3) {
309
            /* specific MPEG like DC coding not used */
310
            s->last_dc[0] = get_bits(&s->gb, 8);
311
            s->last_dc[1] = get_bits(&s->gb, 8);
312
            s->last_dc[2] = get_bits(&s->gb, 8);
313
#ifdef DEBUG
314
            printf("DC:%d %d %d\n",
315
                   s->last_dc[0],
316
                   s->last_dc[1],
317
                   s->last_dc[2]);
318
#endif
319
        }
320
    }
321
    /* if multiple packets per frame are sent, the position at which
322
       to display the macro blocks is coded here */
323
    if ((!full_frame) || show_bits(&s->gb, 12)==0) {
324
        s->mb_x = get_bits(&s->gb, 6);        /* mb_x */
325
        s->mb_y = get_bits(&s->gb, 6);        /* mb_y */
326
        mb_count = get_bits(&s->gb, 12);
327
    } else {
328
        s->mb_x = 0;
329
        s->mb_y = 0;
330
        mb_count = s->mb_width * s->mb_height;
331
    }
332
    unk= get_bits(&s->gb, 3);        /* ignored */
333
//printf("%d\n", unk);
334
    s->f_code = 1;
335
    s->unrestricted_mv = 1;
336

    
337
    return mb_count;
338
}
339

    
340
static int rv10_decode_init(AVCodecContext *avctx)
341
{
342
    MpegEncContext *s = avctx->priv_data;
343
    static int done=0;
344

    
345
    s->avctx= avctx;
346
    s->out_format = FMT_H263;
347

    
348
    s->width = avctx->width;
349
    s->height = avctx->height;
350

    
351
    s->h263_rv10 = 1;
352
    switch(avctx->sub_id){
353
    case 0x10000000:
354
        s->rv10_version= 0;
355
        s->h263_long_vectors=0;
356
        break;
357
    case 0x10003000:
358
        s->rv10_version= 3;
359
        s->h263_long_vectors=1;
360
        break;
361
    case 0x10003001:
362
        s->rv10_version= 3;
363
        s->h263_long_vectors=0;
364
        break;
365
    default:
366
        fprintf(stderr, "unknown header %X\n", avctx->sub_id);
367
    }
368
//printf("ver:%X\n", avctx->sub_id);
369
    s->flags= avctx->flags;
370

    
371
    if (MPV_common_init(s) < 0)
372
        return -1;
373

    
374
    h263_decode_init_vlc(s);
375

    
376
    s->y_dc_scale_table=
377
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
378
    s->progressive_sequence=1;
379

    
380
    /* init rv vlc */
381
    if (!done) {
382
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
383
                 rv_lum_bits, 1, 1,
384
                 rv_lum_code, 2, 2);
385
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
386
                 rv_chrom_bits, 1, 1,
387
                 rv_chrom_code, 2, 2);
388
        done = 1;
389
    }
390

    
391
    return 0;
392
}
393

    
394
static int rv10_decode_end(AVCodecContext *avctx)
395
{
396
    MpegEncContext *s = avctx->priv_data;
397

    
398
    MPV_common_end(s);
399
    return 0;
400
}
401

    
402
static int rv10_decode_packet(AVCodecContext *avctx, 
403
                             uint8_t *buf, int buf_size)
404
{
405
    MpegEncContext *s = avctx->priv_data;
406
    int i, mb_count, mb_pos, left;
407

    
408
    init_get_bits(&s->gb, buf, buf_size*8);
409
    
410
    mb_count = rv10_decode_picture_header(s);
411
    if (mb_count < 0) {
412
        fprintf(stderr, "HEADER ERROR\n");
413
        return -1;
414
    }
415
    
416
    if (s->mb_x >= s->mb_width ||
417
        s->mb_y >= s->mb_height) {
418
        fprintf(stderr, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
419
        return -1;
420
    }
421
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
422
    left = s->mb_width * s->mb_height - mb_pos;
423
    if (mb_count > left) {
424
        fprintf(stderr, "COUNT ERROR\n");
425
        return -1;
426
    }
427

    
428
    if (s->mb_x == 0 && s->mb_y == 0) {
429
        if(MPV_frame_start(s, avctx) < 0)
430
            return -1;
431
    }
432

    
433
#ifdef DEBUG
434
    printf("qscale=%d\n", s->qscale);
435
#endif
436

    
437
    /* default quantization values */
438
    s->y_dc_scale = 8;
439
    s->c_dc_scale = 8;
440
    s->rv10_first_dc_coded[0] = 0;
441
    s->rv10_first_dc_coded[1] = 0;
442
    s->rv10_first_dc_coded[2] = 0;
443

    
444
    if(s->mb_y==0) s->first_slice_line=1;
445
    
446
    s->block_wrap[0]=
447
    s->block_wrap[1]=
448
    s->block_wrap[2]=
449
    s->block_wrap[3]= s->mb_width*2 + 2;
450
    s->block_wrap[4]=
451
    s->block_wrap[5]= s->mb_width + 2;
452
    ff_init_block_index(s);
453
    /* decode each macroblock */
454
    for(i=0;i<mb_count;i++) {
455
        ff_update_block_index(s);
456
#ifdef DEBUG
457
        printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
458
#endif
459
        
460
        s->dsp.clear_blocks(s->block[0]);
461
        s->mv_dir = MV_DIR_FORWARD;
462
        s->mv_type = MV_TYPE_16X16; 
463
        if (ff_h263_decode_mb(s, s->block) == SLICE_ERROR) {
464
            fprintf(stderr, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
465
            return -1;
466
        }
467
        MPV_decode_mb(s, s->block);
468
        if (++s->mb_x == s->mb_width) {
469
            s->mb_x = 0;
470
            s->mb_y++;
471
            ff_init_block_index(s);
472
            s->first_slice_line=0;
473
        }
474
    }
475

    
476
    return buf_size;
477
}
478

    
479
static int rv10_decode_frame(AVCodecContext *avctx, 
480
                             void *data, int *data_size,
481
                             uint8_t *buf, int buf_size)
482
{
483
    MpegEncContext *s = avctx->priv_data;
484
    int i;
485
    AVFrame *pict = data; 
486

    
487
#ifdef DEBUG
488
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
489
#endif
490

    
491
    /* no supplementary picture */
492
    if (buf_size == 0) {
493
        *data_size = 0;
494
        return 0;
495
    }
496
    
497
    if(avctx->slice_count){
498
        for(i=0; i<avctx->slice_count; i++){
499
            int offset= avctx->slice_offset[i];
500
            int size;
501
            
502
            if(i+1 == avctx->slice_count)
503
                size= buf_size - offset;
504
            else
505
                size= avctx->slice_offset[i+1] - offset;
506

    
507
            if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
508
                return -1;
509
        }
510
    }else{
511
        if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
512
            return -1;
513
    }
514

    
515
    if(s->mb_y>=s->mb_height){
516
        MPV_frame_end(s);
517
        
518
        *pict= *(AVFrame*)&s->current_picture;
519
    
520
        *data_size = sizeof(AVFrame);
521
    }else{
522
        *data_size = 0;
523
    }
524

    
525
    return buf_size;
526
}
527

    
528
AVCodec rv10_decoder = {
529
    "rv10",
530
    CODEC_TYPE_VIDEO,
531
    CODEC_ID_RV10,
532
    sizeof(MpegEncContext),
533
    rv10_decode_init,
534
    NULL,
535
    rv10_decode_end,
536
    rv10_decode_frame,
537
    CODEC_CAP_DR1
538
};