← Back to branch summary

~ubuntu-branches/debian/wheezy/vlc/wheezy

« back to all changes in this revision

Viewing changes to extras/ffmpeg/libavcodec/rv10.c

Tags: upstream-0.7.2.final
Import upstream version 0.7.2.final

Show diffs side-by-side

added added

removed removed

Lines of Context:
extras/ffmpeg/libavcodec/rv10.c
 
1
/*
 
2
 * RV10 codec
 
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
 
4
 * Copyright (c) 2002-2004 Michael Niedermayer
 
5
 *
 
6
 * This library is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU Lesser General Public
 
8
 * License as published by the Free Software Foundation; either
 
9
 * version 2 of the License, or (at your option) any later version.
 
10
 *
 
11
 * This library is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
 * Lesser General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU Lesser General Public
 
17
 * License along with this library; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 */
 
20
 
 
21
/**
 
22
 * @file rv10.c
 
23
 * RV10 codec.
 
24
 */
 
25
 
 
26
#include "avcodec.h"
 
27
#include "dsputil.h"
 
28
#include "mpegvideo.h"
 
29
 
 
30
//#define DEBUG
 
31
 
 
32
#define DC_VLC_BITS 14 //FIXME find a better solution
 
33
 
 
34
static const uint16_t rv_lum_code[256] =
 
35
{
 
36
 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
 
37
 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
 
38
 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
 
39
 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
 
40
 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
 
41
 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
 
42
 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
 
43
 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
 
44
 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
 
45
 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
 
46
 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
 
47
 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
 
48
 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
 
49
 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
 
50
 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
 
51
 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
 
52
 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
 
53
 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
 
54
 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
 
55
 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
 
56
 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
 
57
 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
 
58
 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
 
59
 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
 
60
 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
 
61
 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
 
62
 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
 
63
 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
 
64
 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
 
65
 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
 
66
 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
 
67
 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
 
68
};
 
69
 
 
70
static const uint8_t rv_lum_bits[256] = 
 
71
{
 
72
 14, 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, 12, 12, 12, 12, 12, 12, 12,
 
80
 12, 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, 10, 10, 10, 10, 10, 10, 10,
 
84
 10,  8,  8,  8,  8,  8,  8,  8,
 
85
  8,  8,  8,  8,  8,  8,  8,  8,
 
86
  8,  7,  7,  7,  7,  7,  7,  7,
 
87
  7,  6,  6,  6,  6,  5,  5,  4,
 
88
  2,  4,  5,  5,  6,  6,  6,  6,
 
89
  7,  7,  7,  7,  7,  7,  7,  7,
 
90
  8,  8,  8,  8,  8,  8,  8,  8,
 
91
  8,  8,  8,  8,  8,  8,  8,  8,
 
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
 10, 10, 10, 10, 10, 10, 10, 10,
 
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
 12, 12, 12, 12, 12, 12, 12, 12,
 
104
};
 
105
 
 
106
static const uint16_t rv_chrom_code[256] =
 
107
{
 
108
 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
 
109
 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
 
110
 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
 
111
 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
 
112
 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
 
113
 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
 
114
 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
 
115
 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
 
116
 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
 
117
 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
 
118
 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
 
119
 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
 
120
 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
 
121
 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
 
122
 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
 
123
 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
 
124
 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
 
125
 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
 
126
 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
 
127
 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
 
128
 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
 
129
 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
 
130
 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
 
131
 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
 
132
 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
 
133
 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
 
134
 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
 
135
 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
 
136
 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
 
137
 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
 
138
 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
 
139
 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
 
140
};
 
141
 
 
142
static const uint8_t rv_chrom_bits[256] =
 
143
{
 
144
 16, 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, 14, 14, 14, 14, 14, 14, 14,
 
152
 14, 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, 12, 12, 12, 12, 12, 12, 12,
 
156
 12, 10, 10, 10, 10, 10, 10, 10,
 
157
 10, 10, 10, 10, 10, 10, 10, 10,
 
158
 10,  8,  8,  8,  8,  8,  8,  8,
 
159
  8,  6,  6,  6,  6,  4,  4,  3,
 
160
  2,  3,  4,  4,  6,  6,  6,  6,
 
161
  8,  8,  8,  8,  8,  8,  8,  8,
 
162
 10, 10, 10, 10, 10, 10, 10, 10,
 
163
 10, 10, 10, 10, 10, 10, 10, 10,
 
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
 12, 12, 12, 12, 12, 12, 12, 12,
 
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
 14, 14, 14, 14, 14, 14, 14, 14,
 
176
};
 
177
 
 
178
static VLC rv_dc_lum, rv_dc_chrom;
 
179
 
 
180
int rv_decode_dc(MpegEncContext *s, int n)
 
181
{
 
182
    int code;
 
183
 
 
184
    if (n < 4) {
 
185
        code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
 
186
        if (code < 0) {
 
187
            /* XXX: I don't understand why they use LONGER codes than
 
188
               necessary. The following code would be completely useless
 
189
               if they had thought about it !!! */
 
190
            code = get_bits(&s->gb, 7);
 
191
            if (code == 0x7c) {
 
192
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
 
193
            } else if (code == 0x7d) {
 
194
                code = -128 + get_bits(&s->gb, 7);
 
195
            } else if (code == 0x7e) {
 
196
                if (get_bits(&s->gb, 1) == 0)
 
197
                    code = (int8_t)(get_bits(&s->gb, 8) + 1);
 
198
                else
 
199
                    code = (int8_t)(get_bits(&s->gb, 8));
 
200
            } else if (code == 0x7f) {
 
201
                get_bits(&s->gb, 11);
 
202
                code = 1;
 
203
            }
 
204
        } else {
 
205
            code -= 128;
 
206
        }
 
207
    } else {
 
208
        code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
 
209
        /* same remark */
 
210
        if (code < 0) {
 
211
            code = get_bits(&s->gb, 9);
 
212
            if (code == 0x1fc) {
 
213
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
 
214
            } else if (code == 0x1fd) {
 
215
                code = -128 + get_bits(&s->gb, 7);
 
216
            } else if (code == 0x1fe) {
 
217
                get_bits(&s->gb, 9);
 
218
                code = 1;
 
219
            } else {
 
220
                av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
 
221
                return 0xffff;
 
222
            }
 
223
        } else {
 
224
            code -= 128;
 
225
        }
 
226
    }
 
227
    return -code;
 
228
}
 
229
 
 
230
#ifdef CONFIG_ENCODERS
 
231
 
 
232
/* write RV 1.0 compatible frame header */
 
233
void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
 
234
{
 
235
    int full_frame= 0;
 
236
 
 
237
    align_put_bits(&s->pb);
 
238
    
 
239
    put_bits(&s->pb, 1, 1);     /* marker */
 
240
 
 
241
    put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
 
242
 
 
243
    put_bits(&s->pb, 1, 0);     /* not PB frame */
 
244
 
 
245
    put_bits(&s->pb, 5, s->qscale);
 
246
 
 
247
    if (s->pict_type == I_TYPE) {
 
248
        /* specific MPEG like DC coding not used */
 
249
    }
 
250
    /* if multiple packets per frame are sent, the position at which
 
251
       to display the macro blocks is coded here */
 
252
    if(!full_frame){
 
253
        put_bits(&s->pb, 6, 0); /* mb_x */
 
254
        put_bits(&s->pb, 6, 0); /* mb_y */
 
255
        put_bits(&s->pb, 12, s->mb_width * s->mb_height);
 
256
    }
 
257
 
 
258
    put_bits(&s->pb, 3, 0);     /* ignored */
 
259
}
 
260
 
 
261
static int get_num(GetBitContext *gb)
 
262
{
 
263
    int n, n1;
 
264
 
 
265
    n = get_bits(gb, 16);
 
266
    if (n >= 0x4000) {
 
267
        return n - 0x4000;
 
268
    } else {
 
269
        n1 = get_bits(gb, 16);
 
270
        return (n << 16) | n1;
 
271
    }
 
272
}
 
273
 
 
274
#endif //CONFIG_ENCODERS
 
275
 
 
276
/* read RV 1.0 compatible frame header */
 
277
static int rv10_decode_picture_header(MpegEncContext *s)
 
278
{
 
279
    int mb_count, pb_frame, marker, full_frame, unk;
 
280
    
 
281
    full_frame= s->avctx->slice_count==1;
 
282
//printf("ff:%d\n", full_frame);
 
283
    marker = get_bits(&s->gb, 1);
 
284
 
 
285
    if (get_bits(&s->gb, 1))
 
286
        s->pict_type = P_TYPE;
 
287
    else
 
288
        s->pict_type = I_TYPE;
 
289
//printf("h:%X ver:%d\n",h,s->rv10_version);
 
290
    if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
 
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
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
 
299
        return -1;
 
300
    }
 
301
 
 
302
    s->qscale = get_bits(&s->gb, 5);
 
303
    if(s->qscale==0){
 
304
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 
305
        return -1;
 
306
    }
 
307
 
 
308
    if (s->pict_type == I_TYPE) {
 
309
        if (s->rv10_version == 3) {
 
310
            /* specific MPEG like DC coding not used */
 
311
            s->last_dc[0] = get_bits(&s->gb, 8);
 
312
            s->last_dc[1] = get_bits(&s->gb, 8);
 
313
            s->last_dc[2] = get_bits(&s->gb, 8);
 
314
#ifdef DEBUG
 
315
            printf("DC:%d %d %d\n",
 
316
                   s->last_dc[0],
 
317
                   s->last_dc[1],
 
318
                   s->last_dc[2]);
 
319
#endif
 
320
        }
 
321
    }
 
322
    /* if multiple packets per frame are sent, the position at which
 
323
       to display the macro blocks is coded here */
 
324
    if ((!full_frame) || show_bits(&s->gb, 12)==0) {
 
325
        s->mb_x = get_bits(&s->gb, 6);  /* mb_x */
 
326
        s->mb_y = get_bits(&s->gb, 6);  /* mb_y */
 
327
        mb_count = get_bits(&s->gb, 12);
 
328
    } else {
 
329
        s->mb_x = 0;
 
330
        s->mb_y = 0;
 
331
        mb_count = s->mb_width * s->mb_height;
 
332
    }
 
333
    unk= get_bits(&s->gb, 3);   /* ignored */
 
334
//printf("%d\n", unk);
 
335
    s->f_code = 1;
 
336
    s->unrestricted_mv = 1;
 
337
 
 
338
    return mb_count;
 
339
}
 
340
 
 
341
static int rv20_decode_picture_header(MpegEncContext *s)
 
342
{
 
343
    int seq, mb_pos, i;
 
344
    
 
345
    if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
 
346
        if (get_bits(&s->gb, 3)){
 
347
            av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
 
348
            return -1;
 
349
        } 
 
350
    }   
 
351
 
 
352
    i= get_bits(&s->gb, 2);
 
353
    switch(i){
 
354
    case 0: s->pict_type= I_TYPE; break;
 
355
    case 1: s->pict_type= I_TYPE; break; //hmm ...
 
356
    case 2: s->pict_type= P_TYPE; break;
 
357
    case 3: s->pict_type= B_TYPE; break;
 
358
    default: 
 
359
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
 
360
        return -1;
 
361
    }
 
362
    
 
363
    if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
 
364
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
 
365
        return -1;
 
366
    }
 
367
    
 
368
    if (get_bits(&s->gb, 1)){
 
369
        av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
 
370
        return -1;
 
371
    }
 
372
 
 
373
    s->qscale = get_bits(&s->gb, 5);
 
374
    if(s->qscale==0){
 
375
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 
376
        return -1;
 
377
    }
 
378
    if(s->avctx->sub_id == 0x30203002){
 
379
        if (get_bits(&s->gb, 1)){
 
380
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
 
381
            return -1;
 
382
        }
 
383
    }
 
384
        
 
385
    if(s->avctx->has_b_frames){
 
386
        if (get_bits(&s->gb, 1)){
 
387
//            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
 
388
//            return -1;
 
389
        }
 
390
        seq= get_bits(&s->gb, 15);
 
391
        if (s->avctx->sub_id == 0x20201002 && get_bits(&s->gb, 1)){
 
392
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit4 set\n");
 
393
//            return -1;
 
394
        }
 
395
        mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
 
396
        s->mb_x= mb_pos % s->mb_width;
 
397
        s->mb_y= mb_pos / s->mb_width;
 
398
    }else{
 
399
        seq= get_bits(&s->gb, 8)*128;
 
400
        mb_pos= ff_h263_decode_mba(s);
 
401
    }
 
402
//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
 
403
    seq |= s->time &~0x7FFF;
 
404
    if(seq - s->time >  0x4000) seq -= 0x8000;
 
405
    if(seq - s->time < -0x4000) seq += 0x8000;
 
406
    if(seq != s->time){  
 
407
        if(s->pict_type!=B_TYPE){
 
408
            s->time= seq;
 
409
            s->pp_time= s->time - s->last_non_b_time;
 
410
            s->last_non_b_time= s->time;
 
411
        }else{
 
412
            s->time= seq;
 
413
            s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
 
414
            if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
 
415
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, seeking?, skiping current b frame\n");
 
416
                return FRAME_SKIPED;
 
417
            }
 
418
        }
 
419
    }
 
420
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
 
421
/*for(i=0; i<32; i++){
 
422
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
 
423
}
 
424
av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
 
425
    s->no_rounding= get_bits1(&s->gb);
 
426
    
 
427
    s->f_code = 1;
 
428
    s->unrestricted_mv = 1;
 
429
    s->h263_aic= s->pict_type == I_TYPE;
 
430
//    s->alt_inter_vlc=1;
 
431
//    s->obmc=1;
 
432
//    s->umvplus=1;
 
433
    s->modified_quant=1;
 
434
    s->loop_filter=1;
 
435
    
 
436
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 
437
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n", 
 
438
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
 
439
    }
 
440
 
 
441
    assert(s->pict_type != B_TYPE || !s->low_delay);
 
442
 
 
443
    return s->mb_width*s->mb_height - mb_pos;
 
444
}
 
445
 
 
446
static int rv10_decode_init(AVCodecContext *avctx)
 
447
{
 
448
    MpegEncContext *s = avctx->priv_data;
 
449
    static int done=0;
 
450
 
 
451
    MPV_decode_defaults(s);
 
452
    
 
453
    s->avctx= avctx;
 
454
    s->out_format = FMT_H263;
 
455
    s->codec_id= avctx->codec_id;
 
456
 
 
457
    s->width = avctx->width;
 
458
    s->height = avctx->height;
 
459
 
 
460
    switch(avctx->sub_id){
 
461
    case 0x10000000:
 
462
        s->rv10_version= 0;
 
463
        s->h263_long_vectors=0;
 
464
        s->low_delay=1;
 
465
        break;
 
466
    case 0x10002000:
 
467
        s->rv10_version= 3;
 
468
        s->h263_long_vectors=1;
 
469
        s->low_delay=1;
 
470
        s->obmc=1;
 
471
        break;
 
472
    case 0x10003000:
 
473
        s->rv10_version= 3;
 
474
        s->h263_long_vectors=1;
 
475
        s->low_delay=1;
 
476
        break;
 
477
    case 0x10003001:
 
478
        s->rv10_version= 3;
 
479
        s->h263_long_vectors=0;
 
480
        s->low_delay=1;
 
481
        break;
 
482
    case 0x20001000:
 
483
    case 0x20100001:
 
484
    case 0x20101001:
 
485
        s->low_delay=1;
 
486
        break;
 
487
    case 0x20200002:
 
488
    case 0x20201002:
 
489
    case 0x30202002:
 
490
    case 0x30203002:
 
491
        s->low_delay=0;
 
492
        s->avctx->has_b_frames=1;
 
493
        break;
 
494
    default:
 
495
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
 
496
    }
 
497
//printf("ver:%X\n", avctx->sub_id);
 
498
    if (MPV_common_init(s) < 0)
 
499
        return -1;
 
500
 
 
501
    h263_decode_init_vlc(s);
 
502
 
 
503
    /* init rv vlc */
 
504
    if (!done) {
 
505
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
 
506
                 rv_lum_bits, 1, 1,
 
507
                 rv_lum_code, 2, 2);
 
508
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
 
509
                 rv_chrom_bits, 1, 1,
 
510
                 rv_chrom_code, 2, 2);
 
511
        done = 1;
 
512
    }
 
513
    
 
514
    avctx->pix_fmt = PIX_FMT_YUV420P;
 
515
 
 
516
    return 0;
 
517
}
 
518
 
 
519
static int rv10_decode_end(AVCodecContext *avctx)
 
520
{
 
521
    MpegEncContext *s = avctx->priv_data;
 
522
 
 
523
    MPV_common_end(s);
 
524
    return 0;
 
525
}
 
526
 
 
527
static int rv10_decode_packet(AVCodecContext *avctx, 
 
528
                             uint8_t *buf, int buf_size)
 
529
{
 
530
    MpegEncContext *s = avctx->priv_data;
 
531
    int i, mb_count, mb_pos, left;
 
532
 
 
533
    init_get_bits(&s->gb, buf, buf_size*8);
 
534
#if 0
 
535
    for(i=0; i<buf_size*8 && i<200; i++)
 
536
        printf("%d", get_bits1(&s->gb));
 
537
    printf("\n");
 
538
    return 0;
 
539
#endif
 
540
    if(s->codec_id ==CODEC_ID_RV10)
 
541
        mb_count = rv10_decode_picture_header(s);
 
542
    else
 
543
        mb_count = rv20_decode_picture_header(s);
 
544
    if (mb_count < 0) {
 
545
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 
546
        return -1;
 
547
    }
 
548
    
 
549
    if (s->mb_x >= s->mb_width ||
 
550
        s->mb_y >= s->mb_height) {
 
551
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 
552
        return -1;
 
553
    }
 
554
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
 
555
    left = s->mb_width * s->mb_height - mb_pos;
 
556
    if (mb_count > left) {
 
557
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 
558
        return -1;
 
559
    }
 
560
//if(s->pict_type == P_TYPE) return 0;
 
561
 
 
562
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
 
563
        if(MPV_frame_start(s, avctx) < 0)
 
564
            return -1;
 
565
    }
 
566
 
 
567
#ifdef DEBUG
 
568
    printf("qscale=%d\n", s->qscale);
 
569
#endif
 
570
 
 
571
    /* default quantization values */
 
572
    if(s->codec_id== CODEC_ID_RV10){
 
573
        if(s->mb_y==0) s->first_slice_line=1;
 
574
    }else{
 
575
        s->first_slice_line=1;    
 
576
        s->resync_mb_x= s->mb_x;
 
577
        s->resync_mb_y= s->mb_y;
 
578
    }
 
579
    if(s->h263_aic){
 
580
        s->y_dc_scale_table= 
 
581
        s->c_dc_scale_table= ff_aic_dc_scale_table;
 
582
    }else{
 
583
        s->y_dc_scale_table=
 
584
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 
585
    }
 
586
 
 
587
    if(s->modified_quant)
 
588
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
 
589
        
 
590
    ff_set_qscale(s, s->qscale);
 
591
 
 
592
    s->rv10_first_dc_coded[0] = 0;
 
593
    s->rv10_first_dc_coded[1] = 0;
 
594
    s->rv10_first_dc_coded[2] = 0;
 
595
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
 
596
    s->block_wrap[0]=
 
597
    s->block_wrap[1]=
 
598
    s->block_wrap[2]=
 
599
    s->block_wrap[3]= s->b8_stride;
 
600
    s->block_wrap[4]=
 
601
    s->block_wrap[5]= s->mb_stride;
 
602
    ff_init_block_index(s);
 
603
    /* decode each macroblock */
 
604
 
 
605
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
 
606
        int ret;
 
607
        ff_update_block_index(s);
 
608
#ifdef DEBUG
 
609
        printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 
610
#endif
 
611
 
 
612
        s->dsp.clear_blocks(s->block[0]);
 
613
        s->mv_dir = MV_DIR_FORWARD;
 
614
        s->mv_type = MV_TYPE_16X16; 
 
615
        ret=ff_h263_decode_mb(s, s->block);
 
616
 
 
617
        if (ret == SLICE_ERROR) {
 
618
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 
619
            return -1;
 
620
        }
 
621
        if(s->pict_type != B_TYPE)
 
622
            ff_h263_update_motion_val(s);
 
623
        MPV_decode_mb(s, s->block);
 
624
        if(s->loop_filter)
 
625
            ff_h263_loop_filter(s);
 
626
 
 
627
        if (++s->mb_x == s->mb_width) {
 
628
            s->mb_x = 0;
 
629
            s->mb_y++;
 
630
            ff_init_block_index(s);
 
631
        }
 
632
        if(s->mb_x == s->resync_mb_x)
 
633
            s->first_slice_line=0;
 
634
        if(ret == SLICE_END) break;
 
635
    }
 
636
 
 
637
    return buf_size;
 
638
}
 
639
 
 
640
static int rv10_decode_frame(AVCodecContext *avctx, 
 
641
                             void *data, int *data_size,
 
642
                             uint8_t *buf, int buf_size)
 
643
{
 
644
    MpegEncContext *s = avctx->priv_data;
 
645
    int i;
 
646
    AVFrame *pict = data; 
 
647
 
 
648
#ifdef DEBUG
 
649
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
 
650
#endif
 
651
 
 
652
    /* no supplementary picture */
 
653
    if (buf_size == 0) {
 
654
        *data_size = 0;
 
655
        return 0;
 
656
    }
 
657
 
 
658
    if(avctx->slice_count){
 
659
        for(i=0; i<avctx->slice_count; i++){
 
660
            int offset= avctx->slice_offset[i];
 
661
            int size;
 
662
            
 
663
            if(i+1 == avctx->slice_count)
 
664
                size= buf_size - offset;
 
665
            else
 
666
                size= avctx->slice_offset[i+1] - offset;
 
667
 
 
668
            if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
 
669
                return -1;
 
670
        }
 
671
    }else{
 
672
        if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
 
673
            return -1;
 
674
    }
 
675
    
 
676
    if(s->mb_y>=s->mb_height){
 
677
        MPV_frame_end(s);
 
678
    
 
679
        if(s->pict_type==B_TYPE || s->low_delay){
 
680
            *pict= *(AVFrame*)&s->current_picture;
 
681
            ff_print_debug_info(s, pict);
 
682
        } else {
 
683
            *pict= *(AVFrame*)&s->last_picture;
 
684
            ff_print_debug_info(s, pict);
 
685
        }
 
686
        
 
687
        *data_size = sizeof(AVFrame);
 
688
    }else{
 
689
        *data_size = 0;
 
690
    }
 
691
 
 
692
    return buf_size;
 
693
}
 
694
 
 
695
AVCodec rv10_decoder = {
 
696
    "rv10",
 
697
    CODEC_TYPE_VIDEO,
 
698
    CODEC_ID_RV10,
 
699
    sizeof(MpegEncContext),
 
700
    rv10_decode_init,
 
701
    NULL,
 
702
    rv10_decode_end,
 
703
    rv10_decode_frame,
 
704
    CODEC_CAP_DR1
 
705
};
 
706
 
 
707
AVCodec rv20_decoder = {
 
708
    "rv20",
 
709
    CODEC_TYPE_VIDEO,
 
710
    CODEC_ID_RV20,
 
711
    sizeof(MpegEncContext),
 
712
    rv10_decode_init,
 
713
    NULL,
 
714
    rv10_decode_end,
 
715
    rv10_decode_frame,
 
716
    CODEC_CAP_DR1
 
717
};
 
718