Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 68ca24e6

History | View | Annotate | Download (16.6 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 983e3246 Michael Niedermayer
20
/**
21
 * @file rv10.c
22
 * RV10 codec.
23
 */
24
 
25 de6d9b64 Fabrice Bellard
#include "avcodec.h"
26 6000abfa Fabrice Bellard
#include "dsputil.h"
27 de6d9b64 Fabrice Bellard
#include "mpegvideo.h"
28
29
//#define DEBUG
30
31 68bd11f5 Michael Niedermayer
#define DC_VLC_BITS 14 //FIXME find a better solution
32 a3494679 Michael Niedermayer
33 0c1a9eda Zdenek Kabelac
static const uint16_t rv_lum_code[256] =
34 de6d9b64 Fabrice Bellard
{
35
 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
36
 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
37
 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
38
 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
39
 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
40
 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
41
 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
42
 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
43
 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
44
 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
45
 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
46
 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
47
 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
48
 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
49
 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
50
 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
51
 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
52
 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
53
 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
54
 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
55
 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
56
 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
57
 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
58
 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
59
 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
60
 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
61
 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
62
 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
63
 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
64
 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
65
 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
66
 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
67
};
68
69 0c1a9eda Zdenek Kabelac
static const uint8_t rv_lum_bits[256] = 
70 de6d9b64 Fabrice Bellard
{
71
 14, 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, 12, 12, 12, 12, 12, 12, 12,
76
 12, 12, 12, 12, 12, 12, 12, 12,
77
 12, 12, 12, 12, 12, 12, 12, 12,
78
 12, 12, 12, 12, 12, 12, 12, 12,
79
 12, 10, 10, 10, 10, 10, 10, 10,
80
 10, 10, 10, 10, 10, 10, 10, 10,
81
 10, 10, 10, 10, 10, 10, 10, 10,
82
 10, 10, 10, 10, 10, 10, 10, 10,
83
 10,  8,  8,  8,  8,  8,  8,  8,
84
  8,  8,  8,  8,  8,  8,  8,  8,
85
  8,  7,  7,  7,  7,  7,  7,  7,
86
  7,  6,  6,  6,  6,  5,  5,  4,
87
  2,  4,  5,  5,  6,  6,  6,  6,
88
  7,  7,  7,  7,  7,  7,  7,  7,
89
  8,  8,  8,  8,  8,  8,  8,  8,
90
  8,  8,  8,  8,  8,  8,  8,  8,
91
 10, 10, 10, 10, 10, 10, 10, 10,
92
 10, 10, 10, 10, 10, 10, 10, 10,
93
 10, 10, 10, 10, 10, 10, 10, 10,
94
 10, 10, 10, 10, 10, 10, 10, 10,
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
 12, 12, 12, 12, 12, 12, 12, 12,
100
 12, 12, 12, 12, 12, 12, 12, 12,
101
 12, 12, 12, 12, 12, 12, 12, 12,
102
 12, 12, 12, 12, 12, 12, 12, 12,
103
};
104
105 0c1a9eda Zdenek Kabelac
static const uint16_t rv_chrom_code[256] =
106 de6d9b64 Fabrice Bellard
{
107
 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
108
 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
109
 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
110
 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
111
 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
112
 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
113
 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
114
 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
115
 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
116
 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
117
 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
118
 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
119
 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
120
 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
121
 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
122
 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
123
 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
124
 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
125
 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
126
 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
127
 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
128
 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
129
 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
130
 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
131
 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
132
 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
133
 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
134
 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
135
 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
136
 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
137
 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
138
 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
139
};
140
141 0c1a9eda Zdenek Kabelac
static const uint8_t rv_chrom_bits[256] =
142 de6d9b64 Fabrice Bellard
{
143
 16, 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, 14, 14, 14, 14, 14, 14, 14,
148
 14, 14, 14, 14, 14, 14, 14, 14,
149
 14, 14, 14, 14, 14, 14, 14, 14,
150
 14, 14, 14, 14, 14, 14, 14, 14,
151
 14, 12, 12, 12, 12, 12, 12, 12,
152
 12, 12, 12, 12, 12, 12, 12, 12,
153
 12, 12, 12, 12, 12, 12, 12, 12,
154
 12, 12, 12, 12, 12, 12, 12, 12,
155
 12, 10, 10, 10, 10, 10, 10, 10,
156
 10, 10, 10, 10, 10, 10, 10, 10,
157
 10,  8,  8,  8,  8,  8,  8,  8,
158
  8,  6,  6,  6,  6,  4,  4,  3,
159
  2,  3,  4,  4,  6,  6,  6,  6,
160
  8,  8,  8,  8,  8,  8,  8,  8,
161
 10, 10, 10, 10, 10, 10, 10, 10,
162
 10, 10, 10, 10, 10, 10, 10, 10,
163
 12, 12, 12, 12, 12, 12, 12, 12,
164
 12, 12, 12, 12, 12, 12, 12, 12,
165
 12, 12, 12, 12, 12, 12, 12, 12,
166
 12, 12, 12, 12, 12, 12, 12, 12,
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
 14, 14, 14, 14, 14, 14, 14, 14,
172
 14, 14, 14, 14, 14, 14, 14, 14,
173
 14, 14, 14, 14, 14, 14, 14, 14,
174
 14, 14, 14, 14, 14, 14, 14, 14,
175
};
176
177
static VLC rv_dc_lum, rv_dc_chrom;
178
179
int rv_decode_dc(MpegEncContext *s, int n)
180
{
181
    int code;
182
183
    if (n < 4) {
184 a3494679 Michael Niedermayer
        code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
185 de6d9b64 Fabrice Bellard
        if (code < 0) {
186
            /* XXX: I don't understand why they use LONGER codes than
187
               necessary. The following code would be completely useless
188
               if they had thought about it !!! */
189
            code = get_bits(&s->gb, 7);
190
            if (code == 0x7c) {
191 0c1a9eda Zdenek Kabelac
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
192 de6d9b64 Fabrice Bellard
            } else if (code == 0x7d) {
193
                code = -128 + get_bits(&s->gb, 7);
194
            } else if (code == 0x7e) {
195
                if (get_bits(&s->gb, 1) == 0)
196 0c1a9eda Zdenek Kabelac
                    code = (int8_t)(get_bits(&s->gb, 8) + 1);
197 de6d9b64 Fabrice Bellard
                else
198 0c1a9eda Zdenek Kabelac
                    code = (int8_t)(get_bits(&s->gb, 8));
199 de6d9b64 Fabrice Bellard
            } else if (code == 0x7f) {
200
                get_bits(&s->gb, 11);
201
                code = 1;
202
            }
203
        } else {
204
            code -= 128;
205
        }
206
    } else {
207 a3494679 Michael Niedermayer
        code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
208 de6d9b64 Fabrice Bellard
        /* same remark */
209
        if (code < 0) {
210
            code = get_bits(&s->gb, 9);
211
            if (code == 0x1fc) {
212 0c1a9eda Zdenek Kabelac
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
213 de6d9b64 Fabrice Bellard
            } else if (code == 0x1fd) {
214
                code = -128 + get_bits(&s->gb, 7);
215
            } else if (code == 0x1fe) {
216
                get_bits(&s->gb, 9);
217
                code = 1;
218
            } else {
219 9b879566 Michel Bardiaux
                av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
220 de6d9b64 Fabrice Bellard
                return 0xffff;
221
            }
222
        } else {
223
            code -= 128;
224
        }
225
    }
226
    return -code;
227
}
228
229 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
230
231 de6d9b64 Fabrice Bellard
/* write RV 1.0 compatible frame header */
232
void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
233
{
234 4c2bc159 Michael Niedermayer
    int full_frame= 0;
235 0b61920a Michael Niedermayer
236 de6d9b64 Fabrice Bellard
    align_put_bits(&s->pb);
237 0b61920a Michael Niedermayer
    
238 de6d9b64 Fabrice Bellard
    put_bits(&s->pb, 1, 1);        /* marker */
239
240
    put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
241
242
    put_bits(&s->pb, 1, 0);        /* not PB frame */
243
244
    put_bits(&s->pb, 5, s->qscale);
245
246
    if (s->pict_type == I_TYPE) {
247
        /* specific MPEG like DC coding not used */
248
    }
249
    /* if multiple packets per frame are sent, the position at which
250
       to display the macro blocks is coded here */
251 0b61920a Michael Niedermayer
    if(!full_frame){
252
        put_bits(&s->pb, 6, 0);        /* mb_x */
253
        put_bits(&s->pb, 6, 0);        /* mb_y */
254
        put_bits(&s->pb, 12, s->mb_width * s->mb_height);
255
    }
256 de6d9b64 Fabrice Bellard
257
    put_bits(&s->pb, 3, 0);        /* ignored */
258
}
259
260
static int get_num(GetBitContext *gb)
261
{
262
    int n, n1;
263
264
    n = get_bits(gb, 16);
265
    if (n >= 0x4000) {
266
        return n - 0x4000;
267
    } else {
268
        n1 = get_bits(gb, 16);
269
        return (n << 16) | n1;
270
    }
271
}
272
273 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
274
275 de6d9b64 Fabrice Bellard
/* read RV 1.0 compatible frame header */
276
static int rv10_decode_picture_header(MpegEncContext *s)
277
{
278 144f0625 Michael Niedermayer
    int mb_count, pb_frame, marker, full_frame, unk;
279 de6d9b64 Fabrice Bellard
    
280 144f0625 Michael Niedermayer
    full_frame= s->avctx->slice_count==1;
281
//printf("ff:%d\n", full_frame);
282 de6d9b64 Fabrice Bellard
    marker = get_bits(&s->gb, 1);
283
284
    if (get_bits(&s->gb, 1))
285
        s->pict_type = P_TYPE;
286
    else
287
        s->pict_type = I_TYPE;
288 144f0625 Michael Niedermayer
//printf("h:%X ver:%d\n",h,s->rv10_version);
289 9b879566 Michel Bardiaux
    if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
290 de6d9b64 Fabrice Bellard
    pb_frame = get_bits(&s->gb, 1);
291
292
#ifdef DEBUG
293
    printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
294
#endif
295
    
296 68bd11f5 Michael Niedermayer
    if (pb_frame){
297 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
298 de6d9b64 Fabrice Bellard
        return -1;
299 68bd11f5 Michael Niedermayer
    }
300 de6d9b64 Fabrice Bellard
301
    s->qscale = get_bits(&s->gb, 5);
302 ee3b2be6 Michael Niedermayer
    if(s->qscale==0){
303 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
304 ee3b2be6 Michael Niedermayer
        return -1;
305
    }
306 de6d9b64 Fabrice Bellard
307
    if (s->pict_type == I_TYPE) {
308
        if (s->rv10_version == 3) {
309
            /* specific MPEG like DC coding not used */
310
            s->last_dc[0] = get_bits(&s->gb, 8);
311
            s->last_dc[1] = get_bits(&s->gb, 8);
312
            s->last_dc[2] = get_bits(&s->gb, 8);
313
#ifdef DEBUG
314
            printf("DC:%d %d %d\n",
315
                   s->last_dc[0],
316
                   s->last_dc[1],
317
                   s->last_dc[2]);
318
#endif
319
        }
320
    }
321
    /* if multiple packets per frame are sent, the position at which
322
       to display the macro blocks is coded here */
323 144f0625 Michael Niedermayer
    if ((!full_frame) || show_bits(&s->gb, 12)==0) {
324 de6d9b64 Fabrice Bellard
        s->mb_x = get_bits(&s->gb, 6);        /* mb_x */
325
        s->mb_y = get_bits(&s->gb, 6);        /* mb_y */
326
        mb_count = get_bits(&s->gb, 12);
327
    } else {
328
        s->mb_x = 0;
329
        s->mb_y = 0;
330
        mb_count = s->mb_width * s->mb_height;
331
    }
332 68bd11f5 Michael Niedermayer
    unk= get_bits(&s->gb, 3);        /* ignored */
333
//printf("%d\n", unk);
334 de6d9b64 Fabrice Bellard
    s->f_code = 1;
335
    s->unrestricted_mv = 1;
336 255b3ac2 Michael Niedermayer
337 de6d9b64 Fabrice Bellard
    return mb_count;
338
}
339
340
static int rv10_decode_init(AVCodecContext *avctx)
341
{
342
    MpegEncContext *s = avctx->priv_data;
343 7604246d Wolfgang Hesseler
    static int done=0;
344 de6d9b64 Fabrice Bellard
345 9db99069 Michael Niedermayer
    s->avctx= avctx;
346 de6d9b64 Fabrice Bellard
    s->out_format = FMT_H263;
347
348
    s->width = avctx->width;
349
    s->height = avctx->height;
350
351
    s->h263_rv10 = 1;
352 144f0625 Michael Niedermayer
    switch(avctx->sub_id){
353
    case 0x10000000:
354
        s->rv10_version= 0;
355
        s->h263_long_vectors=0;
356
        break;
357
    case 0x10003000:
358
        s->rv10_version= 3;
359
        s->h263_long_vectors=1;
360
        break;
361
    case 0x10003001:
362
        s->rv10_version= 3;
363
        s->h263_long_vectors=0;
364
        break;
365
    default:
366 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
367 255b3ac2 Michael Niedermayer
    }
368 144f0625 Michael Niedermayer
//printf("ver:%X\n", avctx->sub_id);
369 3cf33c37 Michael Niedermayer
    s->flags= avctx->flags;
370 de6d9b64 Fabrice Bellard
371
    if (MPV_common_init(s) < 0)
372
        return -1;
373
374
    h263_decode_init_vlc(s);
375
376 ee3b2be6 Michael Niedermayer
    s->y_dc_scale_table=
377
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
378 4d2858de Michael Niedermayer
    s->progressive_sequence=1;
379 ee3b2be6 Michael Niedermayer
380 de6d9b64 Fabrice Bellard
    /* init rv vlc */
381
    if (!done) {
382 a3494679 Michael Niedermayer
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
383 de6d9b64 Fabrice Bellard
                 rv_lum_bits, 1, 1,
384
                 rv_lum_code, 2, 2);
385 a3494679 Michael Niedermayer
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
386 de6d9b64 Fabrice Bellard
                 rv_chrom_bits, 1, 1,
387
                 rv_chrom_code, 2, 2);
388
        done = 1;
389
    }
390 ebc51331 James Stembridge
    
391
    avctx->pix_fmt = PIX_FMT_YUV420P;
392 de6d9b64 Fabrice Bellard
393
    return 0;
394
}
395
396
static int rv10_decode_end(AVCodecContext *avctx)
397
{
398
    MpegEncContext *s = avctx->priv_data;
399
400
    MPV_common_end(s);
401
    return 0;
402
}
403
404 144f0625 Michael Niedermayer
static int rv10_decode_packet(AVCodecContext *avctx, 
405 0c1a9eda Zdenek Kabelac
                             uint8_t *buf, int buf_size)
406 de6d9b64 Fabrice Bellard
{
407
    MpegEncContext *s = avctx->priv_data;
408
    int i, mb_count, mb_pos, left;
409
410 68f593b4 Michael Niedermayer
    init_get_bits(&s->gb, buf, buf_size*8);
411 144f0625 Michael Niedermayer
    
412 de6d9b64 Fabrice Bellard
    mb_count = rv10_decode_picture_header(s);
413
    if (mb_count < 0) {
414 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
415 de6d9b64 Fabrice Bellard
        return -1;
416
    }
417
    
418
    if (s->mb_x >= s->mb_width ||
419
        s->mb_y >= s->mb_height) {
420 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
421 de6d9b64 Fabrice Bellard
        return -1;
422
    }
423
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
424
    left = s->mb_width * s->mb_height - mb_pos;
425
    if (mb_count > left) {
426 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
427 de6d9b64 Fabrice Bellard
        return -1;
428
    }
429
430
    if (s->mb_x == 0 && s->mb_y == 0) {
431 d6db1c9c Michael Niedermayer
        if(MPV_frame_start(s, avctx) < 0)
432
            return -1;
433 de6d9b64 Fabrice Bellard
    }
434
435
#ifdef DEBUG
436
    printf("qscale=%d\n", s->qscale);
437
#endif
438
439
    /* default quantization values */
440
    s->y_dc_scale = 8;
441
    s->c_dc_scale = 8;
442
    s->rv10_first_dc_coded[0] = 0;
443
    s->rv10_first_dc_coded[1] = 0;
444
    s->rv10_first_dc_coded[2] = 0;
445 ab00685a Michael Niedermayer
446 4d2858de Michael Niedermayer
    if(s->mb_y==0) s->first_slice_line=1;
447
    
448 ab00685a Michael Niedermayer
    s->block_wrap[0]=
449
    s->block_wrap[1]=
450
    s->block_wrap[2]=
451
    s->block_wrap[3]= s->mb_width*2 + 2;
452
    s->block_wrap[4]=
453
    s->block_wrap[5]= s->mb_width + 2;
454 4d2858de Michael Niedermayer
    ff_init_block_index(s);
455 de6d9b64 Fabrice Bellard
    /* decode each macroblock */
456
    for(i=0;i<mb_count;i++) {
457 4d2858de Michael Niedermayer
        ff_update_block_index(s);
458 de6d9b64 Fabrice Bellard
#ifdef DEBUG
459
        printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
460
#endif
461
        
462 eb4b3dd3 Zdenek Kabelac
        s->dsp.clear_blocks(s->block[0]);
463 de6d9b64 Fabrice Bellard
        s->mv_dir = MV_DIR_FORWARD;
464
        s->mv_type = MV_TYPE_16X16; 
465 4d2858de Michael Niedermayer
        if (ff_h263_decode_mb(s, s->block) == SLICE_ERROR) {
466 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
467 de6d9b64 Fabrice Bellard
            return -1;
468
        }
469 7d1c3fc1 Michael Niedermayer
        ff_h263_update_motion_val(s);
470 4d2858de Michael Niedermayer
        MPV_decode_mb(s, s->block);
471 de6d9b64 Fabrice Bellard
        if (++s->mb_x == s->mb_width) {
472
            s->mb_x = 0;
473
            s->mb_y++;
474 4d2858de Michael Niedermayer
            ff_init_block_index(s);
475
            s->first_slice_line=0;
476 de6d9b64 Fabrice Bellard
        }
477
    }
478
479 144f0625 Michael Niedermayer
    return buf_size;
480
}
481
482
static int rv10_decode_frame(AVCodecContext *avctx, 
483
                             void *data, int *data_size,
484 0c1a9eda Zdenek Kabelac
                             uint8_t *buf, int buf_size)
485 144f0625 Michael Niedermayer
{
486
    MpegEncContext *s = avctx->priv_data;
487
    int i;
488 492cd3a9 Michael Niedermayer
    AVFrame *pict = data; 
489 144f0625 Michael Niedermayer
490
#ifdef DEBUG
491
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
492
#endif
493
494
    /* no supplementary picture */
495
    if (buf_size == 0) {
496
        *data_size = 0;
497
        return 0;
498
    }
499
    
500
    if(avctx->slice_count){
501
        for(i=0; i<avctx->slice_count; i++){
502
            int offset= avctx->slice_offset[i];
503
            int size;
504
            
505
            if(i+1 == avctx->slice_count)
506
                size= buf_size - offset;
507
            else
508
                size= avctx->slice_offset[i+1] - offset;
509
510
            if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
511
                return -1;
512
        }
513
    }else{
514
        if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
515
            return -1;
516
    }
517
518
    if(s->mb_y>=s->mb_height){
519 de6d9b64 Fabrice Bellard
        MPV_frame_end(s);
520
        
521 492cd3a9 Michael Niedermayer
        *pict= *(AVFrame*)&s->current_picture;
522 144f0625 Michael Niedermayer
    
523 492cd3a9 Michael Niedermayer
        *data_size = sizeof(AVFrame);
524 144f0625 Michael Niedermayer
    }else{
525 de6d9b64 Fabrice Bellard
        *data_size = 0;
526
    }
527 144f0625 Michael Niedermayer
528 de6d9b64 Fabrice Bellard
    return buf_size;
529
}
530
531
AVCodec rv10_decoder = {
532
    "rv10",
533
    CODEC_TYPE_VIDEO,
534
    CODEC_ID_RV10,
535
    sizeof(MpegEncContext),
536
    rv10_decode_init,
537
    NULL,
538
    rv10_decode_end,
539
    rv10_decode_frame,
540 3cf33c37 Michael Niedermayer
    CODEC_CAP_DR1
541 de6d9b64 Fabrice Bellard
};