Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ da9c9637

History | View | Annotate | Download (21.6 KB)

1 de6d9b64 Fabrice Bellard
/*
2
 * RV10 codec
3 ff4ec49e Fabrice Bellard
 * Copyright (c) 2000,2001 Fabrice Bellard.
4 8f2ab833 Michael Niedermayer
 * Copyright (c) 2002-2004 Michael Niedermayer
5 de6d9b64 Fabrice Bellard
 *
6 ff4ec49e Fabrice Bellard
 * 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 de6d9b64 Fabrice Bellard
 *
11 ff4ec49e Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
12 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 ff4ec49e Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15 de6d9b64 Fabrice Bellard
 *
16 ff4ec49e Fabrice Bellard
 * 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 de6d9b64 Fabrice Bellard
 */
20 983e3246 Michael Niedermayer
21
/**
22
 * @file rv10.c
23
 * RV10 codec.
24
 */
25
 
26 de6d9b64 Fabrice Bellard
#include "avcodec.h"
27 6000abfa Fabrice Bellard
#include "dsputil.h"
28 de6d9b64 Fabrice Bellard
#include "mpegvideo.h"
29
30
//#define DEBUG
31
32 68bd11f5 Michael Niedermayer
#define DC_VLC_BITS 14 //FIXME find a better solution
33 a3494679 Michael Niedermayer
34 0c1a9eda Zdenek Kabelac
static const uint16_t rv_lum_code[256] =
35 de6d9b64 Fabrice Bellard
{
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 0c1a9eda Zdenek Kabelac
static const uint8_t rv_lum_bits[256] = 
71 de6d9b64 Fabrice Bellard
{
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 0c1a9eda Zdenek Kabelac
static const uint16_t rv_chrom_code[256] =
107 de6d9b64 Fabrice Bellard
{
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 0c1a9eda Zdenek Kabelac
static const uint8_t rv_chrom_bits[256] =
143 de6d9b64 Fabrice Bellard
{
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 a3494679 Michael Niedermayer
        code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
186 de6d9b64 Fabrice Bellard
        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 0c1a9eda Zdenek Kabelac
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
193 de6d9b64 Fabrice Bellard
            } 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 0c1a9eda Zdenek Kabelac
                    code = (int8_t)(get_bits(&s->gb, 8) + 1);
198 de6d9b64 Fabrice Bellard
                else
199 0c1a9eda Zdenek Kabelac
                    code = (int8_t)(get_bits(&s->gb, 8));
200 de6d9b64 Fabrice Bellard
            } else if (code == 0x7f) {
201
                get_bits(&s->gb, 11);
202
                code = 1;
203
            }
204
        } else {
205
            code -= 128;
206
        }
207
    } else {
208 a3494679 Michael Niedermayer
        code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
209 de6d9b64 Fabrice Bellard
        /* same remark */
210
        if (code < 0) {
211
            code = get_bits(&s->gb, 9);
212
            if (code == 0x1fc) {
213 0c1a9eda Zdenek Kabelac
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
214 de6d9b64 Fabrice Bellard
            } 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 9b879566 Michel Bardiaux
                av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
221 de6d9b64 Fabrice Bellard
                return 0xffff;
222
            }
223
        } else {
224
            code -= 128;
225
        }
226
    }
227
    return -code;
228
}
229
230 7604246d Wolfgang Hesseler
#ifdef CONFIG_ENCODERS
231
232 de6d9b64 Fabrice Bellard
/* write RV 1.0 compatible frame header */
233
void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
234
{
235 4c2bc159 Michael Niedermayer
    int full_frame= 0;
236 0b61920a Michael Niedermayer
237 de6d9b64 Fabrice Bellard
    align_put_bits(&s->pb);
238 0b61920a Michael Niedermayer
    
239 de6d9b64 Fabrice Bellard
    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 0b61920a Michael Niedermayer
    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 de6d9b64 Fabrice Bellard
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 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
275
276 de6d9b64 Fabrice Bellard
/* read RV 1.0 compatible frame header */
277
static int rv10_decode_picture_header(MpegEncContext *s)
278
{
279 144f0625 Michael Niedermayer
    int mb_count, pb_frame, marker, full_frame, unk;
280 de6d9b64 Fabrice Bellard
    
281 144f0625 Michael Niedermayer
    full_frame= s->avctx->slice_count==1;
282
//printf("ff:%d\n", full_frame);
283 de6d9b64 Fabrice Bellard
    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 144f0625 Michael Niedermayer
//printf("h:%X ver:%d\n",h,s->rv10_version);
290 9b879566 Michel Bardiaux
    if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
291 de6d9b64 Fabrice Bellard
    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 68bd11f5 Michael Niedermayer
    if (pb_frame){
298 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
299 de6d9b64 Fabrice Bellard
        return -1;
300 68bd11f5 Michael Niedermayer
    }
301 de6d9b64 Fabrice Bellard
302
    s->qscale = get_bits(&s->gb, 5);
303 ee3b2be6 Michael Niedermayer
    if(s->qscale==0){
304 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
305 ee3b2be6 Michael Niedermayer
        return -1;
306
    }
307 de6d9b64 Fabrice Bellard
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 144f0625 Michael Niedermayer
    if ((!full_frame) || show_bits(&s->gb, 12)==0) {
325 de6d9b64 Fabrice Bellard
        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 68bd11f5 Michael Niedermayer
    unk= get_bits(&s->gb, 3);        /* ignored */
334
//printf("%d\n", unk);
335 de6d9b64 Fabrice Bellard
    s->f_code = 1;
336
    s->unrestricted_mv = 1;
337 255b3ac2 Michael Niedermayer
338 de6d9b64 Fabrice Bellard
    return mb_count;
339
}
340
341 68b94c35 Michael Niedermayer
static int rv20_decode_picture_header(MpegEncContext *s)
342
{
343 473c7582 Michael Niedermayer
    int seq, mb_pos, i;
344 b40cd4e0 Michael Niedermayer
    
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 473c7582 Michael Niedermayer
352
    i= get_bits(&s->gb, 2);
353
    switch(i){
354
    case 0: s->pict_type= I_TYPE; break;
355 248a1aa5 Michael Niedermayer
    case 1: s->pict_type= I_TYPE; break; //hmm ...
356 473c7582 Michael Niedermayer
    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 fddae1c3 Michael Niedermayer
    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 473c7582 Michael Niedermayer
    if (get_bits(&s->gb, 1)){
369
        av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
370 68b94c35 Michael Niedermayer
        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 b40cd4e0 Michael Niedermayer
    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 ac49f3ef Michael Niedermayer
    if(s->avctx->has_b_frames){
386 b40cd4e0 Michael Niedermayer
        if (get_bits(&s->gb, 1)){
387 8135f8df Michael Niedermayer
//            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
388 bed1707c Michael Niedermayer
//            return -1;
389 b40cd4e0 Michael Niedermayer
        }
390
        seq= get_bits(&s->gb, 15);
391 9b434875 Michael Niedermayer
        if (s->avctx->sub_id == 0x20201002 && 0 && get_bits(&s->gb, 1)){
392 a3c22fbc Michael Niedermayer
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit4 set\n");
393
//            return -1;
394
        }
395 8135f8df Michael Niedermayer
        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 b40cd4e0 Michael Niedermayer
        seq= get_bits(&s->gb, 8)*128;
400 8135f8df Michael Niedermayer
        mb_pos= ff_h263_decode_mba(s);
401
    }
402 a3c22fbc Michael Niedermayer
//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
403 b40cd4e0 Michael Niedermayer
    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 d705e4a6 Michael Niedermayer
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, seeking?, skiping current b frame\n");
416 b40cd4e0 Michael Niedermayer
                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 a3c22fbc Michael Niedermayer
/*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 68b94c35 Michael Niedermayer
    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 332f9ac4 Michael Niedermayer
    s->modified_quant=1;
434
    s->loop_filter=1;
435 68b94c35 Michael Niedermayer
    
436
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
437 473c7582 Michael Niedermayer
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n", 
438 68b94c35 Michael Niedermayer
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
439
    }
440
441 b40cd4e0 Michael Niedermayer
    assert(s->pict_type != B_TYPE || !s->low_delay);
442 473c7582 Michael Niedermayer
443 68b94c35 Michael Niedermayer
    return s->mb_width*s->mb_height - mb_pos;
444
}
445
446 de6d9b64 Fabrice Bellard
static int rv10_decode_init(AVCodecContext *avctx)
447
{
448
    MpegEncContext *s = avctx->priv_data;
449 7604246d Wolfgang Hesseler
    static int done=0;
450 de6d9b64 Fabrice Bellard
451 3edcacde Michael Niedermayer
    MPV_decode_defaults(s);
452
    
453 9db99069 Michael Niedermayer
    s->avctx= avctx;
454 de6d9b64 Fabrice Bellard
    s->out_format = FMT_H263;
455 40a12840 Michael Niedermayer
    s->codec_id= avctx->codec_id;
456 de6d9b64 Fabrice Bellard
457
    s->width = avctx->width;
458
    s->height = avctx->height;
459
460 144f0625 Michael Niedermayer
    switch(avctx->sub_id){
461
    case 0x10000000:
462
        s->rv10_version= 0;
463
        s->h263_long_vectors=0;
464 b40cd4e0 Michael Niedermayer
        s->low_delay=1;
465 144f0625 Michael Niedermayer
        break;
466 8a36717a Michael Niedermayer
    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 144f0625 Michael Niedermayer
    case 0x10003000:
473
        s->rv10_version= 3;
474
        s->h263_long_vectors=1;
475 b40cd4e0 Michael Niedermayer
        s->low_delay=1;
476 144f0625 Michael Niedermayer
        break;
477
    case 0x10003001:
478
        s->rv10_version= 3;
479
        s->h263_long_vectors=0;
480 b40cd4e0 Michael Niedermayer
        s->low_delay=1;
481 144f0625 Michael Niedermayer
        break;
482 68b94c35 Michael Niedermayer
    case 0x20001000:
483 ac49f3ef Michael Niedermayer
    case 0x20100001:
484
    case 0x20101001:
485
        s->low_delay=1;
486
        break;
487 68b94c35 Michael Niedermayer
    case 0x20200002:
488 a3c22fbc Michael Niedermayer
    case 0x20201002:
489 ac49f3ef Michael Niedermayer
    case 0x30202002:
490
    case 0x30203002:
491
        s->low_delay=0;
492
        s->avctx->has_b_frames=1;
493
        break;
494 144f0625 Michael Niedermayer
    default:
495 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
496 255b3ac2 Michael Niedermayer
    }
497 144f0625 Michael Niedermayer
//printf("ver:%X\n", avctx->sub_id);
498 de6d9b64 Fabrice Bellard
    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 a3494679 Michael Niedermayer
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
506 de6d9b64 Fabrice Bellard
                 rv_lum_bits, 1, 1,
507
                 rv_lum_code, 2, 2);
508 a3494679 Michael Niedermayer
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
509 de6d9b64 Fabrice Bellard
                 rv_chrom_bits, 1, 1,
510
                 rv_chrom_code, 2, 2);
511
        done = 1;
512
    }
513 ebc51331 James Stembridge
    
514
    avctx->pix_fmt = PIX_FMT_YUV420P;
515 de6d9b64 Fabrice Bellard
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 144f0625 Michael Niedermayer
static int rv10_decode_packet(AVCodecContext *avctx, 
528 0c1a9eda Zdenek Kabelac
                             uint8_t *buf, int buf_size)
529 de6d9b64 Fabrice Bellard
{
530
    MpegEncContext *s = avctx->priv_data;
531 4df8ca9d Michael Niedermayer
    int mb_count, mb_pos, left;
532 de6d9b64 Fabrice Bellard
533 68f593b4 Michael Niedermayer
    init_get_bits(&s->gb, buf, buf_size*8);
534 68b94c35 Michael Niedermayer
    if(s->codec_id ==CODEC_ID_RV10)
535
        mb_count = rv10_decode_picture_header(s);
536
    else
537
        mb_count = rv20_decode_picture_header(s);
538 de6d9b64 Fabrice Bellard
    if (mb_count < 0) {
539 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
540 de6d9b64 Fabrice Bellard
        return -1;
541
    }
542
    
543
    if (s->mb_x >= s->mb_width ||
544
        s->mb_y >= s->mb_height) {
545 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
546 de6d9b64 Fabrice Bellard
        return -1;
547
    }
548
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
549
    left = s->mb_width * s->mb_height - mb_pos;
550
    if (mb_count > left) {
551 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
552 de6d9b64 Fabrice Bellard
        return -1;
553
    }
554 68b94c35 Michael Niedermayer
//if(s->pict_type == P_TYPE) return 0;
555 de6d9b64 Fabrice Bellard
556 bed1707c Michael Niedermayer
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
557 d6db1c9c Michael Niedermayer
        if(MPV_frame_start(s, avctx) < 0)
558
            return -1;
559 de6d9b64 Fabrice Bellard
    }
560
561
#ifdef DEBUG
562
    printf("qscale=%d\n", s->qscale);
563
#endif
564
565
    /* default quantization values */
566 68b94c35 Michael Niedermayer
    if(s->codec_id== CODEC_ID_RV10){
567
        if(s->mb_y==0) s->first_slice_line=1;
568
    }else{
569
        s->first_slice_line=1;    
570
        s->resync_mb_x= s->mb_x;
571
        s->resync_mb_y= s->mb_y;
572
    }
573
    if(s->h263_aic){
574
        s->y_dc_scale_table= 
575
        s->c_dc_scale_table= ff_aic_dc_scale_table;
576
    }else{
577
        s->y_dc_scale_table=
578
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
579
    }
580 332f9ac4 Michael Niedermayer
581
    if(s->modified_quant)
582
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
583
        
584 554daa24 Michael Niedermayer
    ff_set_qscale(s, s->qscale);
585 332f9ac4 Michael Niedermayer
586 de6d9b64 Fabrice Bellard
    s->rv10_first_dc_coded[0] = 0;
587
    s->rv10_first_dc_coded[1] = 0;
588
    s->rv10_first_dc_coded[2] = 0;
589 8e784825 Michael Niedermayer
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
590 ab00685a Michael Niedermayer
    s->block_wrap[0]=
591
    s->block_wrap[1]=
592
    s->block_wrap[2]=
593 137c8468 Michael Niedermayer
    s->block_wrap[3]= s->b8_stride;
594 ab00685a Michael Niedermayer
    s->block_wrap[4]=
595 137c8468 Michael Niedermayer
    s->block_wrap[5]= s->mb_stride;
596 4d2858de Michael Niedermayer
    ff_init_block_index(s);
597 de6d9b64 Fabrice Bellard
    /* decode each macroblock */
598 8a36717a Michael Niedermayer
599
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
600 68b94c35 Michael Niedermayer
        int ret;
601 4d2858de Michael Niedermayer
        ff_update_block_index(s);
602 de6d9b64 Fabrice Bellard
#ifdef DEBUG
603
        printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
604
#endif
605 8a36717a Michael Niedermayer
606 eb4b3dd3 Zdenek Kabelac
        s->dsp.clear_blocks(s->block[0]);
607 de6d9b64 Fabrice Bellard
        s->mv_dir = MV_DIR_FORWARD;
608
        s->mv_type = MV_TYPE_16X16; 
609 68b94c35 Michael Niedermayer
        ret=ff_h263_decode_mb(s, s->block);
610
611
        if (ret == SLICE_ERROR) {
612 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
613 de6d9b64 Fabrice Bellard
            return -1;
614
        }
615 8e784825 Michael Niedermayer
        if(s->pict_type != B_TYPE)
616
            ff_h263_update_motion_val(s);
617 4d2858de Michael Niedermayer
        MPV_decode_mb(s, s->block);
618 332f9ac4 Michael Niedermayer
        if(s->loop_filter)
619
            ff_h263_loop_filter(s);
620
621 de6d9b64 Fabrice Bellard
        if (++s->mb_x == s->mb_width) {
622
            s->mb_x = 0;
623
            s->mb_y++;
624 4d2858de Michael Niedermayer
            ff_init_block_index(s);
625 de6d9b64 Fabrice Bellard
        }
626 68b94c35 Michael Niedermayer
        if(s->mb_x == s->resync_mb_x)
627
            s->first_slice_line=0;
628
        if(ret == SLICE_END) break;
629 de6d9b64 Fabrice Bellard
    }
630
631 144f0625 Michael Niedermayer
    return buf_size;
632
}
633
634
static int rv10_decode_frame(AVCodecContext *avctx, 
635
                             void *data, int *data_size,
636 0c1a9eda Zdenek Kabelac
                             uint8_t *buf, int buf_size)
637 144f0625 Michael Niedermayer
{
638
    MpegEncContext *s = avctx->priv_data;
639
    int i;
640 492cd3a9 Michael Niedermayer
    AVFrame *pict = data; 
641 144f0625 Michael Niedermayer
642
#ifdef DEBUG
643
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
644
#endif
645
646
    /* no supplementary picture */
647
    if (buf_size == 0) {
648
        return 0;
649
    }
650 8e784825 Michael Niedermayer
651 144f0625 Michael Niedermayer
    if(avctx->slice_count){
652
        for(i=0; i<avctx->slice_count; i++){
653
            int offset= avctx->slice_offset[i];
654
            int size;
655
            
656
            if(i+1 == avctx->slice_count)
657
                size= buf_size - offset;
658
            else
659
                size= avctx->slice_offset[i+1] - offset;
660
661
            if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
662
                return -1;
663
        }
664
    }else{
665
        if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
666
            return -1;
667
    }
668 8135f8df Michael Niedermayer
    
669 144f0625 Michael Niedermayer
    if(s->mb_y>=s->mb_height){
670 de6d9b64 Fabrice Bellard
        MPV_frame_end(s);
671 144f0625 Michael Niedermayer
    
672 b40cd4e0 Michael Niedermayer
        if(s->pict_type==B_TYPE || s->low_delay){
673
            *pict= *(AVFrame*)&s->current_picture;
674 0c9bbaec Wolfgang Hesseler
            ff_print_debug_info(s, pict);
675 b40cd4e0 Michael Niedermayer
        } else {
676
            *pict= *(AVFrame*)&s->last_picture;
677 0c9bbaec Wolfgang Hesseler
            ff_print_debug_info(s, pict);
678 b40cd4e0 Michael Niedermayer
        }
679
        
680 492cd3a9 Michael Niedermayer
        *data_size = sizeof(AVFrame);
681 de6d9b64 Fabrice Bellard
    }
682 144f0625 Michael Niedermayer
683 de6d9b64 Fabrice Bellard
    return buf_size;
684
}
685
686
AVCodec rv10_decoder = {
687
    "rv10",
688
    CODEC_TYPE_VIDEO,
689
    CODEC_ID_RV10,
690
    sizeof(MpegEncContext),
691
    rv10_decode_init,
692
    NULL,
693
    rv10_decode_end,
694
    rv10_decode_frame,
695 3cf33c37 Michael Niedermayer
    CODEC_CAP_DR1
696 de6d9b64 Fabrice Bellard
};
697 68b94c35 Michael Niedermayer
698
AVCodec rv20_decoder = {
699
    "rv20",
700
    CODEC_TYPE_VIDEO,
701
    CODEC_ID_RV20,
702
    sizeof(MpegEncContext),
703
    rv10_decode_init,
704
    NULL,
705
    rv10_decode_end,
706
    rv10_decode_frame,
707
    CODEC_CAP_DR1
708
};