Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 186447f8

History | View | Annotate | Download (16.5 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
    avctx->pix_fmt = PIX_FMT_YUV420P;
392

    
393
    return 0;
394
}
395

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

    
400
    MPV_common_end(s);
401
    return 0;
402
}
403

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

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

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

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

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

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

    
479
    return buf_size;
480
}
481

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

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

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

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

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

    
528
    return buf_size;
529
}
530

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