← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linphone/quantal

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/rv10.c

  • Committer: Bazaar Package Importer
  • Author(s): Samuel Mimram
  • Date: 2004-06-30 13:58:16 UTC
  • Revision ID: james.westby@ubuntu.com-20040630135816-wwx75gdlodkqbabb
Tags: upstream-0.12.2
Import upstream version 0.12.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/rv10.c
 
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
};