Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 0d21a846

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

    
61
static const UINT8 rv_lum_bits[256] = 
62
{
63
 14, 12, 12, 12, 12, 12, 12, 12,
64
 12, 12, 12, 12, 12, 12, 12, 12,
65
 12, 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, 10, 10, 10, 10, 10, 10, 10,
72
 10, 10, 10, 10, 10, 10, 10, 10,
73
 10, 10, 10, 10, 10, 10, 10, 10,
74
 10, 10, 10, 10, 10, 10, 10, 10,
75
 10,  8,  8,  8,  8,  8,  8,  8,
76
  8,  8,  8,  8,  8,  8,  8,  8,
77
  8,  7,  7,  7,  7,  7,  7,  7,
78
  7,  6,  6,  6,  6,  5,  5,  4,
79
  2,  4,  5,  5,  6,  6,  6,  6,
80
  7,  7,  7,  7,  7,  7,  7,  7,
81
  8,  8,  8,  8,  8,  8,  8,  8,
82
  8,  8,  8,  8,  8,  8,  8,  8,
83
 10, 10, 10, 10, 10, 10, 10, 10,
84
 10, 10, 10, 10, 10, 10, 10, 10,
85
 10, 10, 10, 10, 10, 10, 10, 10,
86
 10, 10, 10, 10, 10, 10, 10, 10,
87
 12, 12, 12, 12, 12, 12, 12, 12,
88
 12, 12, 12, 12, 12, 12, 12, 12,
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
};
96

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

    
133
static const UINT8 rv_chrom_bits[256] =
134
{
135
 16, 14, 14, 14, 14, 14, 14, 14,
136
 14, 14, 14, 14, 14, 14, 14, 14,
137
 14, 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, 12, 12, 12, 12, 12, 12, 12,
144
 12, 12, 12, 12, 12, 12, 12, 12,
145
 12, 12, 12, 12, 12, 12, 12, 12,
146
 12, 12, 12, 12, 12, 12, 12, 12,
147
 12, 10, 10, 10, 10, 10, 10, 10,
148
 10, 10, 10, 10, 10, 10, 10, 10,
149
 10,  8,  8,  8,  8,  8,  8,  8,
150
  8,  6,  6,  6,  6,  4,  4,  3,
151
  2,  3,  4,  4,  6,  6,  6,  6,
152
  8,  8,  8,  8,  8,  8,  8,  8,
153
 10, 10, 10, 10, 10, 10, 10, 10,
154
 10, 10, 10, 10, 10, 10, 10, 10,
155
 12, 12, 12, 12, 12, 12, 12, 12,
156
 12, 12, 12, 12, 12, 12, 12, 12,
157
 12, 12, 12, 12, 12, 12, 12, 12,
158
 12, 12, 12, 12, 12, 12, 12, 12,
159
 14, 14, 14, 14, 14, 14, 14, 14,
160
 14, 14, 14, 14, 14, 14, 14, 14,
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
};
168

    
169
static VLC rv_dc_lum, rv_dc_chrom;
170

    
171
int rv_decode_dc(MpegEncContext *s, int n)
172
{
173
    int code;
174

    
175
    if (n < 4) {
176
        code = get_vlc(&s->gb, &rv_dc_lum);
177
        if (code < 0) {
178
            /* XXX: I don't understand why they use LONGER codes than
179
               necessary. The following code would be completely useless
180
               if they had thought about it !!! */
181
            code = get_bits(&s->gb, 7);
182
            if (code == 0x7c) {
183
                code = (INT8)(get_bits(&s->gb, 7) + 1);
184
            } else if (code == 0x7d) {
185
                code = -128 + get_bits(&s->gb, 7);
186
            } else if (code == 0x7e) {
187
                if (get_bits(&s->gb, 1) == 0)
188
                    code = (INT8)(get_bits(&s->gb, 8) + 1);
189
                else
190
                    code = (INT8)(get_bits(&s->gb, 8));
191
            } else if (code == 0x7f) {
192
                get_bits(&s->gb, 11);
193
                code = 1;
194
            }
195
        } else {
196
            code -= 128;
197
        }
198
    } else {
199
        code = get_vlc(&s->gb, &rv_dc_chrom);
200
        /* same remark */
201
        if (code < 0) {
202
            code = get_bits(&s->gb, 9);
203
            if (code == 0x1fc) {
204
                code = (INT8)(get_bits(&s->gb, 7) + 1);
205
            } else if (code == 0x1fd) {
206
                code = -128 + get_bits(&s->gb, 7);
207
            } else if (code == 0x1fe) {
208
                get_bits(&s->gb, 9);
209
                code = 1;
210
            } else {
211
                return 0xffff;
212
            }
213
        } else {
214
            code -= 128;
215
        }
216
    }
217
    return -code;
218
}
219

    
220
/* write RV 1.0 compatible frame header */
221
void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
222
{
223
    align_put_bits(&s->pb);
224

    
225
    put_bits(&s->pb, 1, 1);        /* marker */
226

    
227
    put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
228

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

    
231
    put_bits(&s->pb, 5, s->qscale);
232

    
233
    if (s->pict_type == I_TYPE) {
234
        /* specific MPEG like DC coding not used */
235
    }
236
    /* if multiple packets per frame are sent, the position at which
237
       to display the macro blocks is coded here */
238
    put_bits(&s->pb, 6, 0);        /* mb_x */
239
    put_bits(&s->pb, 6, 0);        /* mb_y */
240
    put_bits(&s->pb, 12, s->mb_width * s->mb_height);
241

    
242
    put_bits(&s->pb, 3, 0);        /* ignored */
243
}
244

    
245
static int get_num(GetBitContext *gb)
246
{
247
    int n, n1;
248

    
249
    n = get_bits(gb, 16);
250
    if (n >= 0x4000) {
251
        return n - 0x4000;
252
    } else {
253
        n1 = get_bits(gb, 16);
254
        return (n << 16) | n1;
255
    }
256
}
257

    
258
/* read RV 1.0 compatible frame header */
259
static int rv10_decode_picture_header(MpegEncContext *s)
260
{
261
    int mb_count, pb_frame, marker, h, full_frame;
262
    
263
    /* skip packet header */
264
    h = get_bits(&s->gb, 8);
265
    if ((h & 0xc0) == 0xc0) {
266
        int len, pos;
267
        full_frame = 1;
268
        len = get_num(&s->gb);
269
        pos = get_num(&s->gb);
270
    } else {
271
        int seq, frame_size, pos;
272
        full_frame = 0;
273
        seq = get_bits(&s->gb, 8);
274
        frame_size = get_num(&s->gb);
275
        pos = get_num(&s->gb);
276
    }
277
    /* picture number */
278
    get_bits(&s->gb, 8);
279

    
280
    marker = get_bits(&s->gb, 1);
281

    
282
    if (get_bits(&s->gb, 1))
283
        s->pict_type = P_TYPE;
284
    else
285
        s->pict_type = I_TYPE;
286

    
287
    pb_frame = get_bits(&s->gb, 1);
288

    
289
#ifdef DEBUG
290
    printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
291
#endif
292
    
293
    if (pb_frame)
294
        return -1;
295

    
296
    s->qscale = get_bits(&s->gb, 5);
297

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

    
324
    get_bits(&s->gb, 3);        /* ignored */
325
    s->f_code = 1;
326
    s->unrestricted_mv = 1;
327
#if 0
328
    s->h263_long_vectors = 1;
329
#endif
330
    return mb_count;
331
}
332

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

    
338
//    s->avctx= avctx;
339
    s->out_format = FMT_H263;
340

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

    
344
    s->h263_rv10 = 1;
345
    s->rv10_version = avctx->sub_id;
346

    
347
    if (MPV_common_init(s) < 0)
348
        return -1;
349

    
350
    h263_decode_init_vlc(s);
351

    
352
    /* init rv vlc */
353
    if (!done) {
354
        init_vlc(&rv_dc_lum, 9, 256, 
355
                 rv_lum_bits, 1, 1,
356
                 rv_lum_code, 2, 2);
357
        init_vlc(&rv_dc_chrom, 9, 256, 
358
                 rv_chrom_bits, 1, 1,
359
                 rv_chrom_code, 2, 2);
360
        done = 1;
361
    }
362

    
363
    return 0;
364
}
365

    
366
static int rv10_decode_end(AVCodecContext *avctx)
367
{
368
    MpegEncContext *s = avctx->priv_data;
369

    
370
    MPV_common_end(s);
371
    return 0;
372
}
373

    
374
static int rv10_decode_frame(AVCodecContext *avctx, 
375
                             void *data, int *data_size,
376
                             UINT8 *buf, int buf_size)
377
{
378
    MpegEncContext *s = avctx->priv_data;
379
    int i, mb_count, mb_pos, left;
380
    DCTELEM block[6][64];
381
    AVPicture *pict = data; 
382

    
383
#ifdef DEBUG
384
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
385
#endif
386

    
387
    /* no supplementary picture */
388
    if (buf_size == 0) {
389
        *data_size = 0;
390
        return 0;
391
    }
392

    
393
    init_get_bits(&s->gb, buf, buf_size);
394

    
395
    mb_count = rv10_decode_picture_header(s);
396
    if (mb_count < 0) {
397
#ifdef DEBUG
398
        printf("HEADER ERROR\n");
399
#endif
400
        return -1;
401
    }
402
    
403
    if (s->mb_x >= s->mb_width ||
404
        s->mb_y >= s->mb_height) {
405
#ifdef DEBUG
406
        printf("POS ERROR %d %d\n", s->mb_x, s->mb_y);
407
#endif
408
        return -1;
409
    }
410
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
411
    left = s->mb_width * s->mb_height - mb_pos;
412
    if (mb_count > left) {
413
#ifdef DEBUG
414
        printf("COUNT ERROR\n");
415
#endif
416
        return -1;
417
    }
418

    
419
    if (s->mb_x == 0 && s->mb_y == 0) {
420
        MPV_frame_start(s);
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
    s->block_wrap[0]=
435
    s->block_wrap[1]=
436
    s->block_wrap[2]=
437
    s->block_wrap[3]= s->mb_width*2 + 2;
438
    s->block_wrap[4]=
439
    s->block_wrap[5]= s->mb_width + 2;
440
    s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
441
    s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
442
    s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
443
    s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
444
    s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
445
    s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
446
    /* decode each macroblock */
447
    for(i=0;i<mb_count;i++) {
448
        s->block_index[0]+=2;
449
        s->block_index[1]+=2;
450
        s->block_index[2]+=2;
451
        s->block_index[3]+=2;
452
        s->block_index[4]++;
453
        s->block_index[5]++;
454
#ifdef DEBUG
455
        printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
456
#endif
457
        
458
        memset(block, 0, sizeof(block));
459
        s->mv_dir = MV_DIR_FORWARD;
460
        s->mv_type = MV_TYPE_16X16; 
461
        if (h263_decode_mb(s, block) < 0) {
462
#ifdef DEBUG
463
            printf("ERROR\n");
464
#endif
465
            return -1;
466
        }
467
        MPV_decode_mb(s, block);
468
        if (++s->mb_x == s->mb_width) {
469
            s->mb_x = 0;
470
            s->mb_y++;
471
            s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1;
472
            s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1);
473
            s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1;
474
            s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2);
475
            s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
476
            s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
477
        }
478
    }
479

    
480
    if (s->mb_x == 0 &&
481
        s->mb_y == s->mb_height) {
482
        MPV_frame_end(s);
483
        
484
        pict->data[0] = s->current_picture[0];
485
        pict->data[1] = s->current_picture[1];
486
        pict->data[2] = s->current_picture[2];
487
        pict->linesize[0] = s->linesize;
488
        pict->linesize[1] = s->linesize / 2;
489
        pict->linesize[2] = s->linesize / 2;
490
        
491
        avctx->quality = s->qscale;
492
        *data_size = sizeof(AVPicture);
493
    } else {
494
        *data_size = 0;
495
    }
496
    return buf_size;
497
}
498

    
499
AVCodec rv10_decoder = {
500
    "rv10",
501
    CODEC_TYPE_VIDEO,
502
    CODEC_ID_RV10,
503
    sizeof(MpegEncContext),
504
    rv10_decode_init,
505
    NULL,
506
    rv10_decode_end,
507
    rv10_decode_frame,
508
};