Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 7604246d

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_t 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_t 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_t 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_t 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_t)(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_t)(get_bits(&s->gb, 8) + 1);
191
                else
192
                    code = (int8_t)(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_t)(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
#ifdef CONFIG_ENCODERS
224

    
225
/* write RV 1.0 compatible frame header */
226
void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
227
{
228
    int full_frame= 0;
229

    
230
    align_put_bits(&s->pb);
231
    
232
    put_bits(&s->pb, 1, 1);        /* marker */
233

    
234
    put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
235

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

    
238
    put_bits(&s->pb, 5, s->qscale);
239

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

    
251
    put_bits(&s->pb, 3, 0);        /* ignored */
252
}
253

    
254
static int get_num(GetBitContext *gb)
255
{
256
    int n, n1;
257

    
258
    n = get_bits(gb, 16);
259
    if (n >= 0x4000) {
260
        return n - 0x4000;
261
    } else {
262
        n1 = get_bits(gb, 16);
263
        return (n << 16) | n1;
264
    }
265
}
266

    
267
#endif //CONFIG_ENCODERS
268

    
269
/* read RV 1.0 compatible frame header */
270
static int rv10_decode_picture_header(MpegEncContext *s)
271
{
272
    int mb_count, pb_frame, marker, full_frame, unk;
273
    
274
    full_frame= s->avctx->slice_count==1;
275
//printf("ff:%d\n", full_frame);
276
    marker = get_bits(&s->gb, 1);
277

    
278
    if (get_bits(&s->gb, 1))
279
        s->pict_type = P_TYPE;
280
    else
281
        s->pict_type = I_TYPE;
282
//printf("h:%X ver:%d\n",h,s->rv10_version);
283
    if(!marker) printf("marker missing\n");
284
    pb_frame = get_bits(&s->gb, 1);
285

    
286
#ifdef DEBUG
287
    printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
288
#endif
289
    
290
    if (pb_frame){
291
        fprintf(stderr, "pb frame not supported\n");
292
        return -1;
293
    }
294

    
295
    s->qscale = get_bits(&s->gb, 5);
296
    if(s->qscale==0){
297
        fprintf(stderr, "error, qscale:0\n");
298
        return -1;
299
    }
300

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

    
331
    return mb_count;
332
}
333

    
334
static int rv10_decode_init(AVCodecContext *avctx)
335
{
336
    MpegEncContext *s = avctx->priv_data;
337
    static int done=0;
338

    
339
    s->avctx= avctx;
340
    s->out_format = FMT_H263;
341

    
342
    s->width = avctx->width;
343
    s->height = avctx->height;
344

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

    
365
    if (MPV_common_init(s) < 0)
366
        return -1;
367

    
368
    h263_decode_init_vlc(s);
369

    
370
    s->y_dc_scale_table=
371
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
372
    s->progressive_sequence=1;
373

    
374
    /* init rv vlc */
375
    if (!done) {
376
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
377
                 rv_lum_bits, 1, 1,
378
                 rv_lum_code, 2, 2);
379
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
380
                 rv_chrom_bits, 1, 1,
381
                 rv_chrom_code, 2, 2);
382
        done = 1;
383
    }
384

    
385
    return 0;
386
}
387

    
388
static int rv10_decode_end(AVCodecContext *avctx)
389
{
390
    MpegEncContext *s = avctx->priv_data;
391

    
392
    MPV_common_end(s);
393
    return 0;
394
}
395

    
396
static int rv10_decode_packet(AVCodecContext *avctx, 
397
                             uint8_t *buf, int buf_size)
398
{
399
    MpegEncContext *s = avctx->priv_data;
400
    int i, mb_count, mb_pos, left;
401

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

    
422
    if (s->mb_x == 0 && s->mb_y == 0) {
423
        if(MPV_frame_start(s, avctx) < 0)
424
            return -1;
425
    }
426

    
427
#ifdef DEBUG
428
    printf("qscale=%d\n", s->qscale);
429
#endif
430

    
431
    /* default quantization values */
432
    s->y_dc_scale = 8;
433
    s->c_dc_scale = 8;
434
    s->rv10_first_dc_coded[0] = 0;
435
    s->rv10_first_dc_coded[1] = 0;
436
    s->rv10_first_dc_coded[2] = 0;
437

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

    
470
    return buf_size;
471
}
472

    
473
static int rv10_decode_frame(AVCodecContext *avctx, 
474
                             void *data, int *data_size,
475
                             uint8_t *buf, int buf_size)
476
{
477
    MpegEncContext *s = avctx->priv_data;
478
    int i;
479
    AVFrame *pict = data; 
480

    
481
#ifdef DEBUG
482
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
483
#endif
484

    
485
    /* no supplementary picture */
486
    if (buf_size == 0) {
487
        *data_size = 0;
488
        return 0;
489
    }
490
    
491
    if(avctx->slice_count){
492
        for(i=0; i<avctx->slice_count; i++){
493
            int offset= avctx->slice_offset[i];
494
            int size;
495
            
496
            if(i+1 == avctx->slice_count)
497
                size= buf_size - offset;
498
            else
499
                size= avctx->slice_offset[i+1] - offset;
500

    
501
            if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
502
                return -1;
503
        }
504
    }else{
505
        if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
506
            return -1;
507
    }
508

    
509
    if(s->mb_y>=s->mb_height){
510
        MPV_frame_end(s);
511
        
512
        *pict= *(AVFrame*)&s->current_picture;
513
    
514
        *data_size = sizeof(AVFrame);
515
    }else{
516
        *data_size = 0;
517
    }
518

    
519
    return buf_size;
520
}
521

    
522
AVCodec rv10_decoder = {
523
    "rv10",
524
    CODEC_TYPE_VIDEO,
525
    CODEC_ID_RV10,
526
    sizeof(MpegEncContext),
527
    rv10_decode_init,
528
    NULL,
529
    rv10_decode_end,
530
    rv10_decode_frame,
531
    CODEC_CAP_DR1
532
};