Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 1c2a8c7f

History | View | Annotate | Download (15 KB)

1
/*
2
 * RV10 codec
3
 * Copyright (c) 2000,2001 Gerard Lantau.
4
 *
5
 * This program is free software; you can redistribute it and/or modify
6
 * it under the terms of the GNU General Public License as published by
7
 * the Free Software Foundation; either version 2 of the License, or
8
 * (at your option) any later version.
9
 *
10
 * This program 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
13
 * GNU General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU General Public License
16
 * along with this program; if not, write to the Free Software
17
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18
 */
19
#include <stdlib.h>
20
#include <stdio.h>
21
#include <string.h>
22
#include "common.h"
23
#include "dsputil.h"
24
#include "avcodec.h"
25
#include "mpegvideo.h"
26

    
27
//#define DEBUG
28

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

    
65
static const UINT8 rv_lum_bits[256] = 
66
{
67
 14, 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, 12, 12, 12, 12, 12, 12, 12,
74
 12, 12, 12, 12, 12, 12, 12, 12,
75
 12, 10, 10, 10, 10, 10, 10, 10,
76
 10, 10, 10, 10, 10, 10, 10, 10,
77
 10, 10, 10, 10, 10, 10, 10, 10,
78
 10, 10, 10, 10, 10, 10, 10, 10,
79
 10,  8,  8,  8,  8,  8,  8,  8,
80
  8,  8,  8,  8,  8,  8,  8,  8,
81
  8,  7,  7,  7,  7,  7,  7,  7,
82
  7,  6,  6,  6,  6,  5,  5,  4,
83
  2,  4,  5,  5,  6,  6,  6,  6,
84
  7,  7,  7,  7,  7,  7,  7,  7,
85
  8,  8,  8,  8,  8,  8,  8,  8,
86
  8,  8,  8,  8,  8,  8,  8,  8,
87
 10, 10, 10, 10, 10, 10, 10, 10,
88
 10, 10, 10, 10, 10, 10, 10, 10,
89
 10, 10, 10, 10, 10, 10, 10, 10,
90
 10, 10, 10, 10, 10, 10, 10, 10,
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
 12, 12, 12, 12, 12, 12, 12, 12,
98
 12, 12, 12, 12, 12, 12, 12, 12,
99
};
100

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

    
137
static const UINT8 rv_chrom_bits[256] =
138
{
139
 16, 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, 14, 14, 14, 14, 14, 14, 14,
146
 14, 14, 14, 14, 14, 14, 14, 14,
147
 14, 12, 12, 12, 12, 12, 12, 12,
148
 12, 12, 12, 12, 12, 12, 12, 12,
149
 12, 12, 12, 12, 12, 12, 12, 12,
150
 12, 12, 12, 12, 12, 12, 12, 12,
151
 12, 10, 10, 10, 10, 10, 10, 10,
152
 10, 10, 10, 10, 10, 10, 10, 10,
153
 10,  8,  8,  8,  8,  8,  8,  8,
154
  8,  6,  6,  6,  6,  4,  4,  3,
155
  2,  3,  4,  4,  6,  6,  6,  6,
156
  8,  8,  8,  8,  8,  8,  8,  8,
157
 10, 10, 10, 10, 10, 10, 10, 10,
158
 10, 10, 10, 10, 10, 10, 10, 10,
159
 12, 12, 12, 12, 12, 12, 12, 12,
160
 12, 12, 12, 12, 12, 12, 12, 12,
161
 12, 12, 12, 12, 12, 12, 12, 12,
162
 12, 12, 12, 12, 12, 12, 12, 12,
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
 14, 14, 14, 14, 14, 14, 14, 14,
170
 14, 14, 14, 14, 14, 14, 14, 14,
171
};
172

    
173
static VLC rv_dc_lum, rv_dc_chrom;
174

    
175
int rv_decode_dc(MpegEncContext *s, int n)
176
{
177
    int code;
178

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

    
224
/* write RV 1.0 compatible frame header */
225
void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
226
{
227
    align_put_bits(&s->pb);
228

    
229
    put_bits(&s->pb, 1, 1);        /* marker */
230

    
231
    put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
232

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

    
235
    put_bits(&s->pb, 5, s->qscale);
236

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

    
246
    put_bits(&s->pb, 3, 0);        /* ignored */
247
}
248

    
249
static int get_num(GetBitContext *gb)
250
{
251
    int n, n1;
252

    
253
    n = get_bits(gb, 16);
254
    if (n >= 0x4000) {
255
        return n - 0x4000;
256
    } else {
257
        n1 = get_bits(gb, 16);
258
        return (n << 16) | n1;
259
    }
260
}
261

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

    
284
    marker = get_bits(&s->gb, 1);
285

    
286
    if (get_bits(&s->gb, 1))
287
        s->pict_type = P_TYPE;
288
    else
289
        s->pict_type = I_TYPE;
290

    
291
    pb_frame = get_bits(&s->gb, 1);
292

    
293
#ifdef DEBUG
294
    printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
295
#endif
296
    
297
    if (pb_frame)
298
        return -1;
299

    
300
    s->qscale = get_bits(&s->gb, 5);
301

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

    
328
    get_bits(&s->gb, 3);        /* ignored */
329
    s->f_code = 1;
330
    s->unrestricted_mv = 1;
331
#if 0
332
    s->h263_long_vectors = 1;
333
#endif
334
    return mb_count;
335
}
336

    
337
static int rv10_decode_init(AVCodecContext *avctx)
338
{
339
    MpegEncContext *s = avctx->priv_data;
340
    int i;
341
    static int done;
342

    
343
    s->out_format = FMT_H263;
344

    
345
    s->width = avctx->width;
346
    s->height = avctx->height;
347

    
348
    s->h263_rv10 = 1;
349
    s->rv10_version = avctx->sub_id;
350

    
351
    if (MPV_common_init(s) < 0)
352
        return -1;
353

    
354
    /* XXX: suppress this matrix init, only needed because using mpeg1
355
       dequantize in mmx case */
356
    for(i=0;i<64;i++)
357
        s->non_intra_matrix[i] = default_non_intra_matrix[i];
358

    
359
    h263_decode_init_vlc(s);
360

    
361
    /* init rv vlc */
362
    if (!done) {
363
        init_vlc(&rv_dc_lum, 9, 256, 
364
                 rv_lum_bits, 1, 1,
365
                 rv_lum_code, 2, 2);
366
        init_vlc(&rv_dc_chrom, 9, 256, 
367
                 rv_chrom_bits, 1, 1,
368
                 rv_chrom_code, 2, 2);
369
        done = 1;
370
    }
371

    
372
    return 0;
373
}
374

    
375
static int rv10_decode_end(AVCodecContext *avctx)
376
{
377
    MpegEncContext *s = avctx->priv_data;
378

    
379
    MPV_common_end(s);
380
    return 0;
381
}
382

    
383
static int rv10_decode_frame(AVCodecContext *avctx, 
384
                             void *data, int *data_size,
385
                             UINT8 *buf, int buf_size)
386
{
387
    MpegEncContext *s = avctx->priv_data;
388
    int i, mb_count, mb_pos, left;
389
    DCTELEM block[6][64];
390
    AVPicture *pict = data; 
391

    
392
#ifdef DEBUG
393
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
394
#endif
395

    
396
    /* no supplementary picture */
397
    if (buf_size == 0) {
398
        *data_size = 0;
399
        return 0;
400
    }
401

    
402
    init_get_bits(&s->gb, buf, buf_size);
403

    
404
    mb_count = rv10_decode_picture_header(s);
405
    if (mb_count < 0) {
406
#ifdef DEBUG
407
        printf("HEADER ERROR\n");
408
#endif
409
        return -1;
410
    }
411
    
412
    if (s->mb_x >= s->mb_width ||
413
        s->mb_y >= s->mb_height) {
414
#ifdef DEBUG
415
        printf("POS ERROR %d %d\n", s->mb_x, s->mb_y);
416
#endif
417
        return -1;
418
    }
419
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
420
    left = s->mb_width * s->mb_height - mb_pos;
421
    if (mb_count > left) {
422
#ifdef DEBUG
423
        printf("COUNT ERROR\n");
424
#endif
425
        return -1;
426
    }
427

    
428
    if (s->mb_x == 0 && s->mb_y == 0) {
429
        MPV_frame_start(s);
430
    }
431

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

    
436
    /* default quantization values */
437
    s->y_dc_scale = 8;
438
    s->c_dc_scale = 8;
439
    s->rv10_first_dc_coded[0] = 0;
440
    s->rv10_first_dc_coded[1] = 0;
441
    s->rv10_first_dc_coded[2] = 0;
442
    
443
    /* decode each macroblock */
444
    for(i=0;i<mb_count;i++) {
445
#ifdef DEBUG
446
        printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
447
#endif
448
        
449
        memset(block, 0, sizeof(block));
450
        s->mv_dir = MV_DIR_FORWARD;
451
        s->mv_type = MV_TYPE_16X16; 
452
        if (h263_decode_mb(s, block) < 0) {
453
#ifdef DEBUG
454
            printf("ERROR\n");
455
#endif
456
            return -1;
457
        }
458
        MPV_decode_mb(s, block);
459
        if (++s->mb_x == s->mb_width) {
460
            s->mb_x = 0;
461
            s->mb_y++;
462
        }
463
    }
464

    
465
    if (s->mb_x == 0 &&
466
        s->mb_y == s->mb_height) {
467
        MPV_frame_end(s);
468
        
469
        pict->data[0] = s->current_picture[0];
470
        pict->data[1] = s->current_picture[1];
471
        pict->data[2] = s->current_picture[2];
472
        pict->linesize[0] = s->linesize;
473
        pict->linesize[1] = s->linesize / 2;
474
        pict->linesize[2] = s->linesize / 2;
475
        
476
        avctx->quality = s->qscale;
477
        *data_size = sizeof(AVPicture);
478
    } else {
479
        *data_size = 0;
480
    }
481
    return buf_size;
482
}
483

    
484
AVCodec rv10_decoder = {
485
    "rv10",
486
    CODEC_TYPE_VIDEO,
487
    CODEC_ID_RV10,
488
    sizeof(MpegEncContext),
489
    rv10_decode_init,
490
    NULL,
491
    rv10_decode_end,
492
    rv10_decode_frame,
493
};