Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 284ad8a4

History | View | Annotate | Download (25 KB)

1
/*
2
 * RV10 codec
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 * Copyright (c) 2002-2004 Michael Niedermayer
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22

    
23
/**
24
 * @file rv10.c
25
 * RV10 codec.
26
 */
27

    
28
#include "avcodec.h"
29
#include "dsputil.h"
30
#include "mpegvideo.h"
31

    
32
//#define DEBUG
33

    
34
#define DC_VLC_BITS 14 //FIXME find a better solution
35

    
36
static const uint16_t rv_lum_code[256] =
37
{
38
 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
39
 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
40
 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
41
 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
42
 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
43
 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
44
 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
45
 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
46
 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
47
 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
48
 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
49
 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
50
 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
51
 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
52
 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
53
 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
54
 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
55
 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
56
 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
57
 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
58
 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
59
 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
60
 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
61
 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
62
 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
63
 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
64
 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
65
 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
66
 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
67
 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
68
 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
69
 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
70
};
71

    
72
static const uint8_t rv_lum_bits[256] =
73
{
74
 14, 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, 12, 12, 12, 12, 12, 12, 12,
81
 12, 12, 12, 12, 12, 12, 12, 12,
82
 12, 10, 10, 10, 10, 10, 10, 10,
83
 10, 10, 10, 10, 10, 10, 10, 10,
84
 10, 10, 10, 10, 10, 10, 10, 10,
85
 10, 10, 10, 10, 10, 10, 10, 10,
86
 10,  8,  8,  8,  8,  8,  8,  8,
87
  8,  8,  8,  8,  8,  8,  8,  8,
88
  8,  7,  7,  7,  7,  7,  7,  7,
89
  7,  6,  6,  6,  6,  5,  5,  4,
90
  2,  4,  5,  5,  6,  6,  6,  6,
91
  7,  7,  7,  7,  7,  7,  7,  7,
92
  8,  8,  8,  8,  8,  8,  8,  8,
93
  8,  8,  8,  8,  8,  8,  8,  8,
94
 10, 10, 10, 10, 10, 10, 10, 10,
95
 10, 10, 10, 10, 10, 10, 10, 10,
96
 10, 10, 10, 10, 10, 10, 10, 10,
97
 10, 10, 10, 10, 10, 10, 10, 10,
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
 12, 12, 12, 12, 12, 12, 12, 12,
105
 12, 12, 12, 12, 12, 12, 12, 12,
106
};
107

    
108
static const uint16_t rv_chrom_code[256] =
109
{
110
 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
111
 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
112
 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
113
 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
114
 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
115
 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
116
 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
117
 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
118
 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
119
 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
120
 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
121
 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
122
 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
123
 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
124
 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
125
 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
126
 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
127
 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
128
 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
129
 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
130
 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
131
 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
132
 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
133
 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
134
 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
135
 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
136
 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
137
 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
138
 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
139
 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
140
 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
141
 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
142
};
143

    
144
static const uint8_t rv_chrom_bits[256] =
145
{
146
 16, 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, 14, 14, 14, 14, 14, 14, 14,
153
 14, 14, 14, 14, 14, 14, 14, 14,
154
 14, 12, 12, 12, 12, 12, 12, 12,
155
 12, 12, 12, 12, 12, 12, 12, 12,
156
 12, 12, 12, 12, 12, 12, 12, 12,
157
 12, 12, 12, 12, 12, 12, 12, 12,
158
 12, 10, 10, 10, 10, 10, 10, 10,
159
 10, 10, 10, 10, 10, 10, 10, 10,
160
 10,  8,  8,  8,  8,  8,  8,  8,
161
  8,  6,  6,  6,  6,  4,  4,  3,
162
  2,  3,  4,  4,  6,  6,  6,  6,
163
  8,  8,  8,  8,  8,  8,  8,  8,
164
 10, 10, 10, 10, 10, 10, 10, 10,
165
 10, 10, 10, 10, 10, 10, 10, 10,
166
 12, 12, 12, 12, 12, 12, 12, 12,
167
 12, 12, 12, 12, 12, 12, 12, 12,
168
 12, 12, 12, 12, 12, 12, 12, 12,
169
 12, 12, 12, 12, 12, 12, 12, 12,
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
 14, 14, 14, 14, 14, 14, 14, 14,
177
 14, 14, 14, 14, 14, 14, 14, 14,
178
};
179

    
180
static VLC rv_dc_lum, rv_dc_chrom;
181

    
182
int rv_decode_dc(MpegEncContext *s, int n)
183
{
184
    int code;
185

    
186
    if (n < 4) {
187
        code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
188
        if (code < 0) {
189
            /* XXX: I don't understand why they use LONGER codes than
190
               necessary. The following code would be completely useless
191
               if they had thought about it !!! */
192
            code = get_bits(&s->gb, 7);
193
            if (code == 0x7c) {
194
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
195
            } else if (code == 0x7d) {
196
                code = -128 + get_bits(&s->gb, 7);
197
            } else if (code == 0x7e) {
198
                if (get_bits(&s->gb, 1) == 0)
199
                    code = (int8_t)(get_bits(&s->gb, 8) + 1);
200
                else
201
                    code = (int8_t)(get_bits(&s->gb, 8));
202
            } else if (code == 0x7f) {
203
                get_bits(&s->gb, 11);
204
                code = 1;
205
            }
206
        } else {
207
            code -= 128;
208
        }
209
    } else {
210
        code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
211
        /* same remark */
212
        if (code < 0) {
213
            code = get_bits(&s->gb, 9);
214
            if (code == 0x1fc) {
215
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
216
            } else if (code == 0x1fd) {
217
                code = -128 + get_bits(&s->gb, 7);
218
            } else if (code == 0x1fe) {
219
                get_bits(&s->gb, 9);
220
                code = 1;
221
            } else {
222
                av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
223
                return 0xffff;
224
            }
225
        } else {
226
            code -= 128;
227
        }
228
    }
229
    return -code;
230
}
231

    
232
#ifdef CONFIG_ENCODERS
233

    
234
/* write RV 1.0 compatible frame header */
235
void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
236
{
237
    int full_frame= 0;
238

    
239
    align_put_bits(&s->pb);
240

    
241
    put_bits(&s->pb, 1, 1);     /* marker */
242

    
243
    put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
244

    
245
    put_bits(&s->pb, 1, 0);     /* not PB frame */
246

    
247
    put_bits(&s->pb, 5, s->qscale);
248

    
249
    if (s->pict_type == I_TYPE) {
250
        /* specific MPEG like DC coding not used */
251
    }
252
    /* if multiple packets per frame are sent, the position at which
253
       to display the macro blocks is coded here */
254
    if(!full_frame){
255
        put_bits(&s->pb, 6, 0); /* mb_x */
256
        put_bits(&s->pb, 6, 0); /* mb_y */
257
        put_bits(&s->pb, 12, s->mb_width * s->mb_height);
258
    }
259

    
260
    put_bits(&s->pb, 3, 0);     /* ignored */
261
}
262

    
263
void rv20_encode_picture_header(MpegEncContext *s, int picture_number){
264
    put_bits(&s->pb, 2, s->pict_type); //I 0 vs. 1 ?
265
    put_bits(&s->pb, 1, 0);     /* unknown bit */
266
    put_bits(&s->pb, 5, s->qscale);
267

    
268
    put_bits(&s->pb, 8, picture_number&0xFF); //FIXME wrong, but correct is not known
269
    s->mb_x= s->mb_y= 0;
270
    ff_h263_encode_mba(s);
271

    
272
    put_bits(&s->pb, 1, s->no_rounding);
273

    
274
    assert(s->f_code == 1);
275
    assert(s->unrestricted_mv == 1);
276
//    assert(s->h263_aic== (s->pict_type == I_TYPE));
277
    assert(s->alt_inter_vlc == 0);
278
    assert(s->umvplus == 0);
279
    assert(s->modified_quant==1);
280
    assert(s->loop_filter==1);
281

    
282
    s->h263_aic= s->pict_type == I_TYPE;
283
    if(s->h263_aic){
284
        s->y_dc_scale_table=
285
        s->c_dc_scale_table= ff_aic_dc_scale_table;
286
    }else{
287
        s->y_dc_scale_table=
288
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
289
    }
290
}
291

    
292
#if 0 /* unused, remove? */
293
static int get_num(GetBitContext *gb)
294
{
295
    int n, n1;
296

297
    n = get_bits(gb, 16);
298
    if (n >= 0x4000) {
299
        return n - 0x4000;
300
    } else {
301
        n1 = get_bits(gb, 16);
302
        return (n << 16) | n1;
303
    }
304
}
305
#endif
306

    
307
#endif //CONFIG_ENCODERS
308

    
309
/* read RV 1.0 compatible frame header */
310
static int rv10_decode_picture_header(MpegEncContext *s)
311
{
312
    int mb_count, pb_frame, marker, unk, mb_xy;
313

    
314
//printf("ff:%d\n", full_frame);
315
    marker = get_bits(&s->gb, 1);
316

    
317
    if (get_bits(&s->gb, 1))
318
        s->pict_type = P_TYPE;
319
    else
320
        s->pict_type = I_TYPE;
321
//printf("h:%X ver:%d\n",h,s->rv10_version);
322
    if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
323
    pb_frame = get_bits(&s->gb, 1);
324

    
325
#ifdef DEBUG
326
    av_log(s->avctx, AV_LOG_DEBUG, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
327
#endif
328

    
329
    if (pb_frame){
330
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
331
        return -1;
332
    }
333

    
334
    s->qscale = get_bits(&s->gb, 5);
335
    if(s->qscale==0){
336
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
337
        return -1;
338
    }
339

    
340
    if (s->pict_type == I_TYPE) {
341
        if (s->rv10_version == 3) {
342
            /* specific MPEG like DC coding not used */
343
            s->last_dc[0] = get_bits(&s->gb, 8);
344
            s->last_dc[1] = get_bits(&s->gb, 8);
345
            s->last_dc[2] = get_bits(&s->gb, 8);
346
#ifdef DEBUG
347
            av_log(s->avctx, AV_LOG_DEBUG, "DC:%d %d %d\n",
348
                   s->last_dc[0],
349
                   s->last_dc[1],
350
                   s->last_dc[2]);
351
#endif
352
        }
353
    }
354
    /* if multiple packets per frame are sent, the position at which
355
       to display the macro blocks is coded here */
356

    
357
    mb_xy= s->mb_x + s->mb_y*s->mb_width;
358
    if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
359
        s->mb_x = get_bits(&s->gb, 6); /* mb_x */
360
        s->mb_y = get_bits(&s->gb, 6); /* mb_y */
361
        mb_count = get_bits(&s->gb, 12);
362
    } else {
363
        s->mb_x = 0;
364
        s->mb_y = 0;
365
        mb_count = s->mb_width * s->mb_height;
366
    }
367
    unk= get_bits(&s->gb, 3);   /* ignored */
368
//printf("%d\n", unk);
369
    s->f_code = 1;
370
    s->unrestricted_mv = 1;
371

    
372
    return mb_count;
373
}
374

    
375
static int rv20_decode_picture_header(MpegEncContext *s)
376
{
377
    int seq, mb_pos, i;
378

    
379
#if 0
380
    GetBitContext gb= s->gb;
381
    for(i=0; i<64; i++){
382
        av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
383
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
384
    }
385
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
386
#endif
387
#if 0
388
    av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
389
    for(i=0; i<s->avctx->extradata_size; i++){
390
        av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
391
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
392
    }
393
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
394
#endif
395

    
396
    if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
397
        if (get_bits(&s->gb, 3)){
398
            av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
399
            return -1;
400
        }
401
    }
402

    
403
    i= get_bits(&s->gb, 2);
404
    switch(i){
405
    case 0: s->pict_type= I_TYPE; break;
406
    case 1: s->pict_type= I_TYPE; break; //hmm ...
407
    case 2: s->pict_type= P_TYPE; break;
408
    case 3: s->pict_type= B_TYPE; break;
409
    default:
410
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
411
        return -1;
412
    }
413

    
414
    if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
415
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
416
        return -1;
417
    }
418

    
419
    if (get_bits(&s->gb, 1)){
420
        av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
421
        return -1;
422
    }
423

    
424
    s->qscale = get_bits(&s->gb, 5);
425
    if(s->qscale==0){
426
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
427
        return -1;
428
    }
429
    if(s->avctx->sub_id == 0x30203002){
430
        if (get_bits(&s->gb, 1)){
431
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
432
            return -1;
433
        }
434
    }
435

    
436
    if(s->avctx->has_b_frames){
437
        int f, new_w, new_h;
438
        int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
439

    
440
        if (get_bits(&s->gb, 1)){
441
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
442
//            return -1;
443
        }
444
        seq= get_bits(&s->gb, 13)<<2;
445

    
446
        f= get_bits(&s->gb, av_log2(v)+1);
447

    
448
        if(f){
449
            new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
450
            new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
451
        }else{
452
            new_w= s->width; //FIXME wrong we of course must save the original in the context
453
            new_h= s->height;
454
        }
455
        if(new_w != s->width || new_h != s->height){
456
            av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
457
            if (avcodec_check_dimensions(s->avctx, new_h, new_w) < 0)
458
                return -1;
459
            MPV_common_end(s);
460
            s->width  = s->avctx->width = new_w;
461
            s->height = s->avctx->height= new_h;
462
            if (MPV_common_init(s) < 0)
463
                return -1;
464
        }
465

    
466
        if(s->avctx->debug & FF_DEBUG_PICT_INFO){
467
            av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
468
        }
469
    }else{
470
        seq= get_bits(&s->gb, 8)*128;
471
    }
472

    
473
//     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
474
    mb_pos= ff_h263_decode_mba(s);
475
/*    }else{
476
        mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
477
        s->mb_x= mb_pos % s->mb_width;
478
        s->mb_y= mb_pos / s->mb_width;
479
    }*/
480
//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
481
    seq |= s->time &~0x7FFF;
482
    if(seq - s->time >  0x4000) seq -= 0x8000;
483
    if(seq - s->time < -0x4000) seq += 0x8000;
484
    if(seq != s->time){
485
        if(s->pict_type!=B_TYPE){
486
            s->time= seq;
487
            s->pp_time= s->time - s->last_non_b_time;
488
            s->last_non_b_time= s->time;
489
        }else{
490
            s->time= seq;
491
            s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
492
            if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
493
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
494
                return FRAME_SKIPPED;
495
            }
496
            ff_mpeg4_init_direct_mv(s);
497
        }
498
    }
499
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
500
/*for(i=0; i<32; i++){
501
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
502
}
503
av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
504
    s->no_rounding= get_bits1(&s->gb);
505

    
506
    s->f_code = 1;
507
    s->unrestricted_mv = 1;
508
    s->h263_aic= s->pict_type == I_TYPE;
509
//    s->alt_inter_vlc=1;
510
//    s->obmc=1;
511
//    s->umvplus=1;
512
    s->modified_quant=1;
513
    s->loop_filter=1;
514

    
515
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
516
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
517
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
518
    }
519

    
520
    assert(s->pict_type != B_TYPE || !s->low_delay);
521

    
522
    return s->mb_width*s->mb_height - mb_pos;
523
}
524

    
525
static int rv10_decode_init(AVCodecContext *avctx)
526
{
527
    MpegEncContext *s = avctx->priv_data;
528
    static int done=0;
529

    
530
    MPV_decode_defaults(s);
531

    
532
    s->avctx= avctx;
533
    s->out_format = FMT_H263;
534
    s->codec_id= avctx->codec_id;
535

    
536
    s->width = avctx->width;
537
    s->height = avctx->height;
538

    
539
    s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
540
    avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
541

    
542
    switch(avctx->sub_id){
543
    case 0x10000000:
544
        s->rv10_version= 0;
545
        s->low_delay=1;
546
        break;
547
    case 0x10002000:
548
        s->rv10_version= 3;
549
        s->low_delay=1;
550
        s->obmc=1;
551
        break;
552
    case 0x10003000:
553
        s->rv10_version= 3;
554
        s->low_delay=1;
555
        break;
556
    case 0x10003001:
557
        s->rv10_version= 3;
558
        s->low_delay=1;
559
        break;
560
    case 0x20001000: /* real rv20 decoder fail on this id */
561
    /*case 0x20100001:
562
    case 0x20101001:
563
    case 0x20103001:*/
564
    case 0x20100000 ... 0x2019ffff:
565
        s->low_delay=1;
566
        break;
567
    /*case 0x20200002:
568
    case 0x20201002:
569
    case 0x20203002:*/
570
    case 0x20200002 ... 0x202fffff:
571
    case 0x30202002:
572
    case 0x30203002:
573
        s->low_delay=0;
574
        s->avctx->has_b_frames=1;
575
        break;
576
    default:
577
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
578
    }
579

    
580
    if(avctx->debug & FF_DEBUG_PICT_INFO){
581
        av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
582
    }
583

    
584
    avctx->pix_fmt = PIX_FMT_YUV420P;
585

    
586
    if (MPV_common_init(s) < 0)
587
        return -1;
588

    
589
    h263_decode_init_vlc(s);
590

    
591
    /* init rv vlc */
592
    if (!done) {
593
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
594
                 rv_lum_bits, 1, 1,
595
                 rv_lum_code, 2, 2, 1);
596
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
597
                 rv_chrom_bits, 1, 1,
598
                 rv_chrom_code, 2, 2, 1);
599
        done = 1;
600
    }
601

    
602
    return 0;
603
}
604

    
605
static int rv10_decode_end(AVCodecContext *avctx)
606
{
607
    MpegEncContext *s = avctx->priv_data;
608

    
609
    MPV_common_end(s);
610
    return 0;
611
}
612

    
613
static int rv10_decode_packet(AVCodecContext *avctx,
614
                             uint8_t *buf, int buf_size)
615
{
616
    MpegEncContext *s = avctx->priv_data;
617
    int mb_count, mb_pos, left, start_mb_x;
618

    
619
    init_get_bits(&s->gb, buf, buf_size*8);
620
    if(s->codec_id ==CODEC_ID_RV10)
621
        mb_count = rv10_decode_picture_header(s);
622
    else
623
        mb_count = rv20_decode_picture_header(s);
624
    if (mb_count < 0) {
625
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
626
        return -1;
627
    }
628

    
629
    if (s->mb_x >= s->mb_width ||
630
        s->mb_y >= s->mb_height) {
631
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
632
        return -1;
633
    }
634
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
635
    left = s->mb_width * s->mb_height - mb_pos;
636
    if (mb_count > left) {
637
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
638
        return -1;
639
    }
640
//if(s->pict_type == P_TYPE) return 0;
641

    
642
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
643
        if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
644
            ff_er_frame_end(s);
645
            MPV_frame_end(s);
646
            s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
647
        }
648
        if(MPV_frame_start(s, avctx) < 0)
649
            return -1;
650
        ff_er_frame_start(s);
651
    }
652

    
653
#ifdef DEBUG
654
    av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
655
#endif
656

    
657
    /* default quantization values */
658
    if(s->codec_id== CODEC_ID_RV10){
659
        if(s->mb_y==0) s->first_slice_line=1;
660
    }else{
661
        s->first_slice_line=1;
662
        s->resync_mb_x= s->mb_x;
663
    }
664
    start_mb_x= s->mb_x;
665
    s->resync_mb_y= s->mb_y;
666
    if(s->h263_aic){
667
        s->y_dc_scale_table=
668
        s->c_dc_scale_table= ff_aic_dc_scale_table;
669
    }else{
670
        s->y_dc_scale_table=
671
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
672
    }
673

    
674
    if(s->modified_quant)
675
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
676

    
677
    ff_set_qscale(s, s->qscale);
678

    
679
    s->rv10_first_dc_coded[0] = 0;
680
    s->rv10_first_dc_coded[1] = 0;
681
    s->rv10_first_dc_coded[2] = 0;
682
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
683
    s->block_wrap[0]=
684
    s->block_wrap[1]=
685
    s->block_wrap[2]=
686
    s->block_wrap[3]= s->b8_stride;
687
    s->block_wrap[4]=
688
    s->block_wrap[5]= s->mb_stride;
689
    ff_init_block_index(s);
690
    /* decode each macroblock */
691

    
692
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
693
        int ret;
694
        ff_update_block_index(s);
695
#ifdef DEBUG
696
        av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
697
#endif
698

    
699
        s->mv_dir = MV_DIR_FORWARD;
700
        s->mv_type = MV_TYPE_16X16;
701
        ret=ff_h263_decode_mb(s, s->block);
702

    
703
        if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
704
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
705
            return -1;
706
        }
707
        if(s->pict_type != B_TYPE)
708
            ff_h263_update_motion_val(s);
709
        MPV_decode_mb(s, s->block);
710
        if(s->loop_filter)
711
            ff_h263_loop_filter(s);
712

    
713
        if (++s->mb_x == s->mb_width) {
714
            s->mb_x = 0;
715
            s->mb_y++;
716
            ff_init_block_index(s);
717
        }
718
        if(s->mb_x == s->resync_mb_x)
719
            s->first_slice_line=0;
720
        if(ret == SLICE_END) break;
721
    }
722

    
723
    ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
724

    
725
    return buf_size;
726
}
727

    
728
static int rv10_decode_frame(AVCodecContext *avctx,
729
                             void *data, int *data_size,
730
                             uint8_t *buf, int buf_size)
731
{
732
    MpegEncContext *s = avctx->priv_data;
733
    int i;
734
    AVFrame *pict = data;
735

    
736
#ifdef DEBUG
737
    av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
738
#endif
739

    
740
    /* no supplementary picture */
741
    if (buf_size == 0) {
742
        return 0;
743
    }
744

    
745
    if(avctx->slice_count){
746
        for(i=0; i<avctx->slice_count; i++){
747
            int offset= avctx->slice_offset[i];
748
            int size;
749

    
750
            if(i+1 == avctx->slice_count)
751
                size= buf_size - offset;
752
            else
753
                size= avctx->slice_offset[i+1] - offset;
754

    
755
            rv10_decode_packet(avctx, buf+offset, size);
756
        }
757
    }else{
758
        rv10_decode_packet(avctx, buf, buf_size);
759
    }
760

    
761
    if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
762
        ff_er_frame_end(s);
763
        MPV_frame_end(s);
764

    
765
        if (s->pict_type == B_TYPE || s->low_delay) {
766
            *pict= *(AVFrame*)s->current_picture_ptr;
767
        } else if (s->last_picture_ptr != NULL) {
768
            *pict= *(AVFrame*)s->last_picture_ptr;
769
        }
770

    
771
        if(s->last_picture_ptr || s->low_delay){
772
            *data_size = sizeof(AVFrame);
773
            ff_print_debug_info(s, pict);
774
        }
775
        s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
776
    }
777

    
778
    return buf_size;
779
}
780

    
781
AVCodec rv10_decoder = {
782
    "rv10",
783
    CODEC_TYPE_VIDEO,
784
    CODEC_ID_RV10,
785
    sizeof(MpegEncContext),
786
    rv10_decode_init,
787
    NULL,
788
    rv10_decode_end,
789
    rv10_decode_frame,
790
    CODEC_CAP_DR1
791
};
792

    
793
AVCodec rv20_decoder = {
794
    "rv20",
795
    CODEC_TYPE_VIDEO,
796
    CODEC_ID_RV20,
797
    sizeof(MpegEncContext),
798
    rv10_decode_init,
799
    NULL,
800
    rv10_decode_end,
801
    rv10_decode_frame,
802
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
803
    .flush= ff_mpeg_flush,
804
};
805