Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 0d21a846

History | View | Annotate | Download (16.2 KB)

1 de6d9b64 Fabrice Bellard
/*
2
 * RV10 codec
3 ff4ec49e Fabrice Bellard
 * Copyright (c) 2000,2001 Fabrice Bellard.
4 de6d9b64 Fabrice Bellard
 *
5 ff4ec49e Fabrice Bellard
 * 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 de6d9b64 Fabrice Bellard
 *
10 ff4ec49e Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
11 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ff4ec49e Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14 de6d9b64 Fabrice Bellard
 *
15 ff4ec49e Fabrice Bellard
 * 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 de6d9b64 Fabrice Bellard
 */
19
#include "avcodec.h"
20 6000abfa Fabrice Bellard
#include "dsputil.h"
21 de6d9b64 Fabrice Bellard
#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 d7e9533a Michael Niedermayer
//    s->avctx= avctx;
339 de6d9b64 Fabrice Bellard
    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 ab00685a Michael Niedermayer
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 de6d9b64 Fabrice Bellard
    /* decode each macroblock */
447
    for(i=0;i<mb_count;i++) {
448 ab00685a Michael Niedermayer
        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 de6d9b64 Fabrice Bellard
#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 ab00685a Michael Niedermayer
            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 de6d9b64 Fabrice Bellard
        }
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
};