Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ bb71e317

History | View | Annotate | Download (14.9 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->avctx= avctx;
344
    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
};