Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ b846b231

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