Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ bb71e317

History | View | Annotate | Download (14.9 KB)

1 de6d9b64 Fabrice Bellard
/*
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 519c2b6d Fabrice Bellard
    int i;
341 de6d9b64 Fabrice Bellard
    static int done;
342
343 d7e9533a Michael Niedermayer
//    s->avctx= avctx;
344 de6d9b64 Fabrice Bellard
    s->out_format = FMT_H263;
345
346
    s->width = avctx->width;
347
    s->height = avctx->height;
348
349
    s->h263_rv10 = 1;
350
    s->rv10_version = avctx->sub_id;
351
352
    if (MPV_common_init(s) < 0)
353
        return -1;
354
355
    h263_decode_init_vlc(s);
356
357
    /* init rv vlc */
358
    if (!done) {
359
        init_vlc(&rv_dc_lum, 9, 256, 
360
                 rv_lum_bits, 1, 1,
361
                 rv_lum_code, 2, 2);
362
        init_vlc(&rv_dc_chrom, 9, 256, 
363
                 rv_chrom_bits, 1, 1,
364
                 rv_chrom_code, 2, 2);
365
        done = 1;
366
    }
367
368
    return 0;
369
}
370
371
static int rv10_decode_end(AVCodecContext *avctx)
372
{
373
    MpegEncContext *s = avctx->priv_data;
374
375
    MPV_common_end(s);
376
    return 0;
377
}
378
379
static int rv10_decode_frame(AVCodecContext *avctx, 
380
                             void *data, int *data_size,
381
                             UINT8 *buf, int buf_size)
382
{
383
    MpegEncContext *s = avctx->priv_data;
384
    int i, mb_count, mb_pos, left;
385
    DCTELEM block[6][64];
386
    AVPicture *pict = data; 
387
388
#ifdef DEBUG
389
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
390
#endif
391
392
    /* no supplementary picture */
393
    if (buf_size == 0) {
394
        *data_size = 0;
395
        return 0;
396
    }
397
398
    init_get_bits(&s->gb, buf, buf_size);
399
400
    mb_count = rv10_decode_picture_header(s);
401
    if (mb_count < 0) {
402
#ifdef DEBUG
403
        printf("HEADER ERROR\n");
404
#endif
405
        return -1;
406
    }
407
    
408
    if (s->mb_x >= s->mb_width ||
409
        s->mb_y >= s->mb_height) {
410
#ifdef DEBUG
411
        printf("POS ERROR %d %d\n", s->mb_x, s->mb_y);
412
#endif
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
#ifdef DEBUG
419
        printf("COUNT ERROR\n");
420
#endif
421
        return -1;
422
    }
423
424
    if (s->mb_x == 0 && s->mb_y == 0) {
425
        MPV_frame_start(s);
426
    }
427
428
#ifdef DEBUG
429
    printf("qscale=%d\n", s->qscale);
430
#endif
431
432
    /* default quantization values */
433
    s->y_dc_scale = 8;
434
    s->c_dc_scale = 8;
435
    s->rv10_first_dc_coded[0] = 0;
436
    s->rv10_first_dc_coded[1] = 0;
437
    s->rv10_first_dc_coded[2] = 0;
438
    
439
    /* decode each macroblock */
440
    for(i=0;i<mb_count;i++) {
441
#ifdef DEBUG
442
        printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
443
#endif
444
        
445
        memset(block, 0, sizeof(block));
446
        s->mv_dir = MV_DIR_FORWARD;
447
        s->mv_type = MV_TYPE_16X16; 
448
        if (h263_decode_mb(s, block) < 0) {
449
#ifdef DEBUG
450
            printf("ERROR\n");
451
#endif
452
            return -1;
453
        }
454
        MPV_decode_mb(s, block);
455
        if (++s->mb_x == s->mb_width) {
456
            s->mb_x = 0;
457
            s->mb_y++;
458
        }
459
    }
460
461
    if (s->mb_x == 0 &&
462
        s->mb_y == s->mb_height) {
463
        MPV_frame_end(s);
464
        
465
        pict->data[0] = s->current_picture[0];
466
        pict->data[1] = s->current_picture[1];
467
        pict->data[2] = s->current_picture[2];
468
        pict->linesize[0] = s->linesize;
469
        pict->linesize[1] = s->linesize / 2;
470
        pict->linesize[2] = s->linesize / 2;
471
        
472
        avctx->quality = s->qscale;
473
        *data_size = sizeof(AVPicture);
474
    } else {
475
        *data_size = 0;
476
    }
477
    return buf_size;
478
}
479
480
AVCodec rv10_decoder = {
481
    "rv10",
482
    CODEC_TYPE_VIDEO,
483
    CODEC_ID_RV10,
484
    sizeof(MpegEncContext),
485
    rv10_decode_init,
486
    NULL,
487
    rv10_decode_end,
488
    rv10_decode_frame,
489
};