Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 7ae7300e

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_bits1(&s->gb) == 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
                skip_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
                skip_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_bits1(&s->gb);
316

    
317
    if (get_bits1(&s->gb))
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_bits1(&s->gb);
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_bits1(&s->gb)){
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_bits1(&s->gb)){
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_bits1(&s->gb)){
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
    if (avctx->sub_id == 0x10000000) {
543
        s->rv10_version= 0;
544
        s->low_delay=1;
545
    } else if (avctx->sub_id == 0x10002000) {
546
        s->rv10_version= 3;
547
        s->low_delay=1;
548
        s->obmc=1;
549
    } else if (avctx->sub_id == 0x10003000) {
550
        s->rv10_version= 3;
551
        s->low_delay=1;
552
    } else if (avctx->sub_id == 0x10003001) {
553
        s->rv10_version= 3;
554
        s->low_delay=1;
555
    } else if (    avctx->sub_id == 0x20001000
556
               || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
557
        s->low_delay=1;
558
    } else if (    avctx->sub_id == 0x30202002
559
               ||  avctx->sub_id == 0x30203002
560
               || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
561
        s->low_delay=0;
562
        s->avctx->has_b_frames=1;
563
    } else
564
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
565

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

    
570
    avctx->pix_fmt = PIX_FMT_YUV420P;
571

    
572
    if (MPV_common_init(s) < 0)
573
        return -1;
574

    
575
    h263_decode_init_vlc(s);
576

    
577
    /* init rv vlc */
578
    if (!done) {
579
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
580
                 rv_lum_bits, 1, 1,
581
                 rv_lum_code, 2, 2, 1);
582
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
583
                 rv_chrom_bits, 1, 1,
584
                 rv_chrom_code, 2, 2, 1);
585
        done = 1;
586
    }
587

    
588
    return 0;
589
}
590

    
591
static int rv10_decode_end(AVCodecContext *avctx)
592
{
593
    MpegEncContext *s = avctx->priv_data;
594

    
595
    MPV_common_end(s);
596
    return 0;
597
}
598

    
599
static int rv10_decode_packet(AVCodecContext *avctx,
600
                             uint8_t *buf, int buf_size)
601
{
602
    MpegEncContext *s = avctx->priv_data;
603
    int mb_count, mb_pos, left, start_mb_x;
604

    
605
    init_get_bits(&s->gb, buf, buf_size*8);
606
    if(s->codec_id ==CODEC_ID_RV10)
607
        mb_count = rv10_decode_picture_header(s);
608
    else
609
        mb_count = rv20_decode_picture_header(s);
610
    if (mb_count < 0) {
611
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
612
        return -1;
613
    }
614

    
615
    if (s->mb_x >= s->mb_width ||
616
        s->mb_y >= s->mb_height) {
617
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
618
        return -1;
619
    }
620
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
621
    left = s->mb_width * s->mb_height - mb_pos;
622
    if (mb_count > left) {
623
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
624
        return -1;
625
    }
626
//if(s->pict_type == P_TYPE) return 0;
627

    
628
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
629
        if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
630
            ff_er_frame_end(s);
631
            MPV_frame_end(s);
632
            s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
633
        }
634
        if(MPV_frame_start(s, avctx) < 0)
635
            return -1;
636
        ff_er_frame_start(s);
637
    }
638

    
639
#ifdef DEBUG
640
    av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
641
#endif
642

    
643
    /* default quantization values */
644
    if(s->codec_id== CODEC_ID_RV10){
645
        if(s->mb_y==0) s->first_slice_line=1;
646
    }else{
647
        s->first_slice_line=1;
648
        s->resync_mb_x= s->mb_x;
649
    }
650
    start_mb_x= s->mb_x;
651
    s->resync_mb_y= s->mb_y;
652
    if(s->h263_aic){
653
        s->y_dc_scale_table=
654
        s->c_dc_scale_table= ff_aic_dc_scale_table;
655
    }else{
656
        s->y_dc_scale_table=
657
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
658
    }
659

    
660
    if(s->modified_quant)
661
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
662

    
663
    ff_set_qscale(s, s->qscale);
664

    
665
    s->rv10_first_dc_coded[0] = 0;
666
    s->rv10_first_dc_coded[1] = 0;
667
    s->rv10_first_dc_coded[2] = 0;
668
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
669
    s->block_wrap[0]=
670
    s->block_wrap[1]=
671
    s->block_wrap[2]=
672
    s->block_wrap[3]= s->b8_stride;
673
    s->block_wrap[4]=
674
    s->block_wrap[5]= s->mb_stride;
675
    ff_init_block_index(s);
676
    /* decode each macroblock */
677

    
678
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
679
        int ret;
680
        ff_update_block_index(s);
681
#ifdef DEBUG
682
        av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
683
#endif
684

    
685
        s->mv_dir = MV_DIR_FORWARD;
686
        s->mv_type = MV_TYPE_16X16;
687
        ret=ff_h263_decode_mb(s, s->block);
688

    
689
        if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
690
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
691
            return -1;
692
        }
693
        if(s->pict_type != B_TYPE)
694
            ff_h263_update_motion_val(s);
695
        MPV_decode_mb(s, s->block);
696
        if(s->loop_filter)
697
            ff_h263_loop_filter(s);
698

    
699
        if (++s->mb_x == s->mb_width) {
700
            s->mb_x = 0;
701
            s->mb_y++;
702
            ff_init_block_index(s);
703
        }
704
        if(s->mb_x == s->resync_mb_x)
705
            s->first_slice_line=0;
706
        if(ret == SLICE_END) break;
707
    }
708

    
709
    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);
710

    
711
    return buf_size;
712
}
713

    
714
static int rv10_decode_frame(AVCodecContext *avctx,
715
                             void *data, int *data_size,
716
                             uint8_t *buf, int buf_size)
717
{
718
    MpegEncContext *s = avctx->priv_data;
719
    int i;
720
    AVFrame *pict = data;
721

    
722
#ifdef DEBUG
723
    av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
724
#endif
725

    
726
    /* no supplementary picture */
727
    if (buf_size == 0) {
728
        return 0;
729
    }
730

    
731
    if(avctx->slice_count){
732
        for(i=0; i<avctx->slice_count; i++){
733
            int offset= avctx->slice_offset[i];
734
            int size;
735

    
736
            if(i+1 == avctx->slice_count)
737
                size= buf_size - offset;
738
            else
739
                size= avctx->slice_offset[i+1] - offset;
740

    
741
            rv10_decode_packet(avctx, buf+offset, size);
742
        }
743
    }else{
744
        rv10_decode_packet(avctx, buf, buf_size);
745
    }
746

    
747
    if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
748
        ff_er_frame_end(s);
749
        MPV_frame_end(s);
750

    
751
        if (s->pict_type == B_TYPE || s->low_delay) {
752
            *pict= *(AVFrame*)s->current_picture_ptr;
753
        } else if (s->last_picture_ptr != NULL) {
754
            *pict= *(AVFrame*)s->last_picture_ptr;
755
        }
756

    
757
        if(s->last_picture_ptr || s->low_delay){
758
            *data_size = sizeof(AVFrame);
759
            ff_print_debug_info(s, pict);
760
        }
761
        s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
762
    }
763

    
764
    return buf_size;
765
}
766

    
767
AVCodec rv10_decoder = {
768
    "rv10",
769
    CODEC_TYPE_VIDEO,
770
    CODEC_ID_RV10,
771
    sizeof(MpegEncContext),
772
    rv10_decode_init,
773
    NULL,
774
    rv10_decode_end,
775
    rv10_decode_frame,
776
    CODEC_CAP_DR1
777
};
778

    
779
AVCodec rv20_decoder = {
780
    "rv20",
781
    CODEC_TYPE_VIDEO,
782
    CODEC_ID_RV20,
783
    sizeof(MpegEncContext),
784
    rv10_decode_init,
785
    NULL,
786
    rv10_decode_end,
787
    rv10_decode_frame,
788
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
789
    .flush= ff_mpeg_flush,
790
};
791