Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 58c2182d

History | View | Annotate | Download (21.8 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 8135f8df Michael Niedermayer
        mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
392
        s->mb_x= mb_pos % s->mb_width;
393
        s->mb_y= mb_pos / s->mb_width;
394
    }else{
395 b40cd4e0 Michael Niedermayer
        seq= get_bits(&s->gb, 8)*128;
396 8135f8df Michael Niedermayer
        mb_pos= ff_h263_decode_mba(s);
397
    }
398 b40cd4e0 Michael Niedermayer
//printf("%d\n", seq);
399
    seq |= s->time &~0x7FFF;
400
    if(seq - s->time >  0x4000) seq -= 0x8000;
401
    if(seq - s->time < -0x4000) seq += 0x8000;
402
    if(seq != s->time){  
403
        if(s->pict_type!=B_TYPE){
404
            s->time= seq;
405
            s->pp_time= s->time - s->last_non_b_time;
406
            s->last_non_b_time= s->time;
407
        }else{
408
            s->time= seq;
409
            s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
410
            if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
411 d705e4a6 Michael Niedermayer
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, seeking?, skiping current b frame\n");
412 b40cd4e0 Michael Niedermayer
                return FRAME_SKIPED;
413
            }
414
        }
415
    }
416
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
417 ba58dabc Michael Niedermayer
418 68b94c35 Michael Niedermayer
    s->no_rounding= get_bits1(&s->gb);
419
    
420
    s->f_code = 1;
421
    s->unrestricted_mv = 1;
422
    s->h263_aic= s->pict_type == I_TYPE;
423
//    s->alt_inter_vlc=1;
424
//    s->obmc=1;
425
//    s->umvplus=1;
426 332f9ac4 Michael Niedermayer
    s->modified_quant=1;
427
    s->loop_filter=1;
428 68b94c35 Michael Niedermayer
    
429
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
430 473c7582 Michael Niedermayer
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n", 
431 68b94c35 Michael Niedermayer
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
432
    }
433
434 b40cd4e0 Michael Niedermayer
    assert(s->pict_type != B_TYPE || !s->low_delay);
435 473c7582 Michael Niedermayer
436 68b94c35 Michael Niedermayer
    return s->mb_width*s->mb_height - mb_pos;
437
}
438
439 de6d9b64 Fabrice Bellard
static int rv10_decode_init(AVCodecContext *avctx)
440
{
441
    MpegEncContext *s = avctx->priv_data;
442 7604246d Wolfgang Hesseler
    static int done=0;
443 de6d9b64 Fabrice Bellard
444 3edcacde Michael Niedermayer
    MPV_decode_defaults(s);
445
    
446 9db99069 Michael Niedermayer
    s->avctx= avctx;
447 de6d9b64 Fabrice Bellard
    s->out_format = FMT_H263;
448 40a12840 Michael Niedermayer
    s->codec_id= avctx->codec_id;
449 de6d9b64 Fabrice Bellard
450
    s->width = avctx->width;
451
    s->height = avctx->height;
452
453 144f0625 Michael Niedermayer
    switch(avctx->sub_id){
454
    case 0x10000000:
455
        s->rv10_version= 0;
456
        s->h263_long_vectors=0;
457 b40cd4e0 Michael Niedermayer
        s->low_delay=1;
458 144f0625 Michael Niedermayer
        break;
459 8a36717a Michael Niedermayer
    case 0x10002000:
460
        s->rv10_version= 3;
461
        s->h263_long_vectors=1;
462
        s->low_delay=1;
463
        s->obmc=1;
464
        break;
465 144f0625 Michael Niedermayer
    case 0x10003000:
466
        s->rv10_version= 3;
467
        s->h263_long_vectors=1;
468 b40cd4e0 Michael Niedermayer
        s->low_delay=1;
469 144f0625 Michael Niedermayer
        break;
470
    case 0x10003001:
471
        s->rv10_version= 3;
472
        s->h263_long_vectors=0;
473 b40cd4e0 Michael Niedermayer
        s->low_delay=1;
474 144f0625 Michael Niedermayer
        break;
475 68b94c35 Michael Niedermayer
    case 0x20001000:
476 ac49f3ef Michael Niedermayer
    case 0x20100001:
477
    case 0x20101001:
478
        s->low_delay=1;
479
        break;
480 68b94c35 Michael Niedermayer
    case 0x20200002:
481 ac49f3ef Michael Niedermayer
    case 0x30202002:
482
    case 0x30203002:
483
        s->low_delay=0;
484
        s->avctx->has_b_frames=1;
485
        break;
486 144f0625 Michael Niedermayer
    default:
487 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
488 255b3ac2 Michael Niedermayer
    }
489 144f0625 Michael Niedermayer
//printf("ver:%X\n", avctx->sub_id);
490 de6d9b64 Fabrice Bellard
    if (MPV_common_init(s) < 0)
491
        return -1;
492
493
    h263_decode_init_vlc(s);
494
495
    /* init rv vlc */
496
    if (!done) {
497 a3494679 Michael Niedermayer
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
498 de6d9b64 Fabrice Bellard
                 rv_lum_bits, 1, 1,
499
                 rv_lum_code, 2, 2);
500 a3494679 Michael Niedermayer
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
501 de6d9b64 Fabrice Bellard
                 rv_chrom_bits, 1, 1,
502
                 rv_chrom_code, 2, 2);
503
        done = 1;
504
    }
505 ebc51331 James Stembridge
    
506
    avctx->pix_fmt = PIX_FMT_YUV420P;
507 de6d9b64 Fabrice Bellard
508
    return 0;
509
}
510
511
static int rv10_decode_end(AVCodecContext *avctx)
512
{
513
    MpegEncContext *s = avctx->priv_data;
514
515
    MPV_common_end(s);
516
    return 0;
517
}
518
519 144f0625 Michael Niedermayer
static int rv10_decode_packet(AVCodecContext *avctx, 
520 0c1a9eda Zdenek Kabelac
                             uint8_t *buf, int buf_size)
521 de6d9b64 Fabrice Bellard
{
522
    MpegEncContext *s = avctx->priv_data;
523
    int i, mb_count, mb_pos, left;
524
525 68f593b4 Michael Niedermayer
    init_get_bits(&s->gb, buf, buf_size*8);
526 68b94c35 Michael Niedermayer
#if 0
527 ac49f3ef Michael Niedermayer
    for(i=0; i<buf_size*8 && i<200; i++)
528 68b94c35 Michael Niedermayer
        printf("%d", get_bits1(&s->gb));
529
    printf("\n");
530
    return 0;
531
#endif
532
    if(s->codec_id ==CODEC_ID_RV10)
533
        mb_count = rv10_decode_picture_header(s);
534
    else
535
        mb_count = rv20_decode_picture_header(s);
536 de6d9b64 Fabrice Bellard
    if (mb_count < 0) {
537 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
538 de6d9b64 Fabrice Bellard
        return -1;
539
    }
540
    
541
    if (s->mb_x >= s->mb_width ||
542
        s->mb_y >= s->mb_height) {
543 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
544 de6d9b64 Fabrice Bellard
        return -1;
545
    }
546
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
547
    left = s->mb_width * s->mb_height - mb_pos;
548
    if (mb_count > left) {
549 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
550 de6d9b64 Fabrice Bellard
        return -1;
551
    }
552 68b94c35 Michael Niedermayer
//if(s->pict_type == P_TYPE) return 0;
553 de6d9b64 Fabrice Bellard
554 bed1707c Michael Niedermayer
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
555 d6db1c9c Michael Niedermayer
        if(MPV_frame_start(s, avctx) < 0)
556
            return -1;
557 de6d9b64 Fabrice Bellard
    }
558
559 8e784825 Michael Niedermayer
    if(s->pict_type == B_TYPE){ //FIXME remove after cleaning mottion_val indexing
560
        memset(s->current_picture.motion_val[0], 0, sizeof(int16_t)*2*(s->mb_width*2+2)*(s->mb_height*2+2));
561
    }
562
563 de6d9b64 Fabrice Bellard
#ifdef DEBUG
564
    printf("qscale=%d\n", s->qscale);
565
#endif
566
567
    /* default quantization values */
568 68b94c35 Michael Niedermayer
    if(s->codec_id== CODEC_ID_RV10){
569
        if(s->mb_y==0) s->first_slice_line=1;
570
    }else{
571
        s->first_slice_line=1;    
572
        s->resync_mb_x= s->mb_x;
573
        s->resync_mb_y= s->mb_y;
574
    }
575
    if(s->h263_aic){
576
        s->y_dc_scale_table= 
577
        s->c_dc_scale_table= ff_aic_dc_scale_table;
578
    }else{
579
        s->y_dc_scale_table=
580
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
581
    }
582 332f9ac4 Michael Niedermayer
583
    if(s->modified_quant)
584
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
585
        
586 554daa24 Michael Niedermayer
    ff_set_qscale(s, s->qscale);
587 332f9ac4 Michael Niedermayer
588 de6d9b64 Fabrice Bellard
    s->rv10_first_dc_coded[0] = 0;
589
    s->rv10_first_dc_coded[1] = 0;
590
    s->rv10_first_dc_coded[2] = 0;
591 8e784825 Michael Niedermayer
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
592 ab00685a Michael Niedermayer
    s->block_wrap[0]=
593
    s->block_wrap[1]=
594
    s->block_wrap[2]=
595
    s->block_wrap[3]= s->mb_width*2 + 2;
596
    s->block_wrap[4]=
597
    s->block_wrap[5]= s->mb_width + 2;
598 4d2858de Michael Niedermayer
    ff_init_block_index(s);
599 de6d9b64 Fabrice Bellard
    /* decode each macroblock */
600 8a36717a Michael Niedermayer
601
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
602 68b94c35 Michael Niedermayer
        int ret;
603 4d2858de Michael Niedermayer
        ff_update_block_index(s);
604 de6d9b64 Fabrice Bellard
#ifdef DEBUG
605
        printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
606
#endif
607 8a36717a Michael Niedermayer
608 eb4b3dd3 Zdenek Kabelac
        s->dsp.clear_blocks(s->block[0]);
609 de6d9b64 Fabrice Bellard
        s->mv_dir = MV_DIR_FORWARD;
610
        s->mv_type = MV_TYPE_16X16; 
611 68b94c35 Michael Niedermayer
        ret=ff_h263_decode_mb(s, s->block);
612
613
        if (ret == SLICE_ERROR) {
614 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
615 de6d9b64 Fabrice Bellard
            return -1;
616
        }
617 8e784825 Michael Niedermayer
        if(s->pict_type != B_TYPE)
618
            ff_h263_update_motion_val(s);
619 4d2858de Michael Niedermayer
        MPV_decode_mb(s, s->block);
620 332f9ac4 Michael Niedermayer
        if(s->loop_filter)
621
            ff_h263_loop_filter(s);
622
623 de6d9b64 Fabrice Bellard
        if (++s->mb_x == s->mb_width) {
624
            s->mb_x = 0;
625
            s->mb_y++;
626 4d2858de Michael Niedermayer
            ff_init_block_index(s);
627 de6d9b64 Fabrice Bellard
        }
628 68b94c35 Michael Niedermayer
        if(s->mb_x == s->resync_mb_x)
629
            s->first_slice_line=0;
630
        if(ret == SLICE_END) break;
631 de6d9b64 Fabrice Bellard
    }
632
633 144f0625 Michael Niedermayer
    return buf_size;
634
}
635
636
static int rv10_decode_frame(AVCodecContext *avctx, 
637
                             void *data, int *data_size,
638 0c1a9eda Zdenek Kabelac
                             uint8_t *buf, int buf_size)
639 144f0625 Michael Niedermayer
{
640
    MpegEncContext *s = avctx->priv_data;
641
    int i;
642 492cd3a9 Michael Niedermayer
    AVFrame *pict = data; 
643 144f0625 Michael Niedermayer
644
#ifdef DEBUG
645
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
646
#endif
647
648
    /* no supplementary picture */
649
    if (buf_size == 0) {
650
        *data_size = 0;
651
        return 0;
652
    }
653 8e784825 Michael Niedermayer
654 144f0625 Michael Niedermayer
    if(avctx->slice_count){
655
        for(i=0; i<avctx->slice_count; i++){
656
            int offset= avctx->slice_offset[i];
657
            int size;
658
            
659
            if(i+1 == avctx->slice_count)
660
                size= buf_size - offset;
661
            else
662
                size= avctx->slice_offset[i+1] - offset;
663
664
            if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
665
                return -1;
666
        }
667
    }else{
668
        if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
669
            return -1;
670
    }
671 8135f8df Michael Niedermayer
    
672
    if(s->pict_type == B_TYPE){ //FIXME remove after cleaning mottion_val indexing
673
        memset(s->current_picture.motion_val[0], 0, sizeof(int16_t)*2*(s->mb_width*2+2)*(s->mb_height*2+2));
674
    }
675 144f0625 Michael Niedermayer
676
    if(s->mb_y>=s->mb_height){
677 de6d9b64 Fabrice Bellard
        MPV_frame_end(s);
678 144f0625 Michael Niedermayer
    
679 b40cd4e0 Michael Niedermayer
        if(s->pict_type==B_TYPE || s->low_delay){
680
            *pict= *(AVFrame*)&s->current_picture;
681 0c9bbaec Wolfgang Hesseler
            ff_print_debug_info(s, pict);
682 b40cd4e0 Michael Niedermayer
        } else {
683
            *pict= *(AVFrame*)&s->last_picture;
684 0c9bbaec Wolfgang Hesseler
            ff_print_debug_info(s, pict);
685 b40cd4e0 Michael Niedermayer
        }
686
        
687 492cd3a9 Michael Niedermayer
        *data_size = sizeof(AVFrame);
688 144f0625 Michael Niedermayer
    }else{
689 de6d9b64 Fabrice Bellard
        *data_size = 0;
690
    }
691 144f0625 Michael Niedermayer
692 de6d9b64 Fabrice Bellard
    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 3cf33c37 Michael Niedermayer
    CODEC_CAP_DR1
705 de6d9b64 Fabrice Bellard
};
706 68b94c35 Michael Niedermayer
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
};