Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ ac52613c

History | View | Annotate | Download (25.7 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

    
233
#if defined(CONFIG_RV10_ENCODER) || defined(CONFIG_RV20_ENCODER)
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 == FF_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 == FF_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 macroblocks 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_sbits(&s->pb, 8, picture_number); //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 == FF_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 == FF_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 /* defined(CONFIG_RV10_ENCODER) || defined(CONFIG_RV20_ENCODER) */
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 = FF_P_TYPE;
319
    else
320
        s->pict_type = FF_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 == FF_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 macroblocks 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= FF_I_TYPE; break;
406
    case 1: s->pict_type= FF_I_TYPE; break; //hmm ...
407
    case 2: s->pict_type= FF_P_TYPE; break;
408
    case 3: s->pict_type= FF_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==FF_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!=FF_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 == FF_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 != FF_B_TYPE || !s->low_delay);
521

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

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

    
530
    if (avctx->extradata_size < 8) {
531
        av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
532
        return -1;
533
    }
534

    
535
    MPV_decode_defaults(s);
536

    
537
    s->avctx= avctx;
538
    s->out_format = FMT_H263;
539
    s->codec_id= avctx->codec_id;
540

    
541
    s->width = avctx->width;
542
    s->height = avctx->height;
543

    
544
    s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
545
    avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
546

    
547
    if (avctx->sub_id == 0x10000000) {
548
        s->rv10_version= 0;
549
        s->low_delay=1;
550
    } else if (avctx->sub_id == 0x10002000) {
551
        s->rv10_version= 3;
552
        s->low_delay=1;
553
        s->obmc=1;
554
    } else if (avctx->sub_id == 0x10003000) {
555
        s->rv10_version= 3;
556
        s->low_delay=1;
557
    } else if (avctx->sub_id == 0x10003001) {
558
        s->rv10_version= 3;
559
        s->low_delay=1;
560
    } else if (    avctx->sub_id == 0x20001000
561
               || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
562
        s->low_delay=1;
563
    } else if (    avctx->sub_id == 0x30202002
564
               ||  avctx->sub_id == 0x30203002
565
               || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
566
        s->low_delay=0;
567
        s->avctx->has_b_frames=1;
568
    } else
569
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
570

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

    
575
    avctx->pix_fmt = PIX_FMT_YUV420P;
576

    
577
    if (MPV_common_init(s) < 0)
578
        return -1;
579

    
580
    h263_decode_init_vlc(s);
581

    
582
    /* init rv vlc */
583
    if (!done) {
584
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
585
                 rv_lum_bits, 1, 1,
586
                 rv_lum_code, 2, 2, 1);
587
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
588
                 rv_chrom_bits, 1, 1,
589
                 rv_chrom_code, 2, 2, 1);
590
        done = 1;
591
    }
592

    
593
    return 0;
594
}
595

    
596
static av_cold int rv10_decode_end(AVCodecContext *avctx)
597
{
598
    MpegEncContext *s = avctx->priv_data;
599

    
600
    MPV_common_end(s);
601
    return 0;
602
}
603

    
604
static int rv10_decode_packet(AVCodecContext *avctx,
605
                             const uint8_t *buf, int buf_size)
606
{
607
    MpegEncContext *s = avctx->priv_data;
608
    int mb_count, mb_pos, left, start_mb_x;
609

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

    
620
    if (s->mb_x >= s->mb_width ||
621
        s->mb_y >= s->mb_height) {
622
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
623
        return -1;
624
    }
625
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
626
    left = s->mb_width * s->mb_height - mb_pos;
627
    if (mb_count > left) {
628
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
629
        return -1;
630
    }
631
//if(s->pict_type == FF_P_TYPE) return 0;
632

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

    
644
#ifdef DEBUG
645
    av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
646
#endif
647

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

    
665
    if(s->modified_quant)
666
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
667

    
668
    ff_set_qscale(s, s->qscale);
669

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

    
683
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
684
        int ret;
685
        ff_update_block_index(s);
686
#ifdef DEBUG
687
        av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
688
#endif
689

    
690
        s->mv_dir = MV_DIR_FORWARD;
691
        s->mv_type = MV_TYPE_16X16;
692
        ret=ff_h263_decode_mb(s, s->block);
693

    
694
        if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
695
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
696
            return -1;
697
        }
698
        if(s->pict_type != FF_B_TYPE)
699
            ff_h263_update_motion_val(s);
700
        MPV_decode_mb(s, s->block);
701
        if(s->loop_filter)
702
            ff_h263_loop_filter(s);
703

    
704
        if (++s->mb_x == s->mb_width) {
705
            s->mb_x = 0;
706
            s->mb_y++;
707
            ff_init_block_index(s);
708
        }
709
        if(s->mb_x == s->resync_mb_x)
710
            s->first_slice_line=0;
711
        if(ret == SLICE_END) break;
712
    }
713

    
714
    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);
715

    
716
    return buf_size;
717
}
718

    
719
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
720
{
721
    if(avctx->slice_count) return avctx->slice_offset[n];
722
    else                   return AV_RL32(buf + n*8);
723
}
724

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

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

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

    
744
    if(!avctx->slice_count){
745
        slice_count = (*buf++) + 1;
746
        slices_hdr = buf + 4;
747
        buf += 8 * slice_count;
748
    }else
749
        slice_count = avctx->slice_count;
750

    
751
    for(i=0; i<slice_count; i++){
752
        int offset= get_slice_offset(avctx, slices_hdr, i);
753
        int size;
754

    
755
        if(i+1 == slice_count)
756
            size= buf_size - offset;
757
        else
758
            size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
759

    
760
        rv10_decode_packet(avctx, buf+offset, size);
761
    }
762

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

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

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

    
780
    return buf_size;
781
}
782

    
783
AVCodec rv10_decoder = {
784
    "rv10",
785
    CODEC_TYPE_VIDEO,
786
    CODEC_ID_RV10,
787
    sizeof(MpegEncContext),
788
    rv10_decode_init,
789
    NULL,
790
    rv10_decode_end,
791
    rv10_decode_frame,
792
    CODEC_CAP_DR1,
793
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
794
};
795

    
796
AVCodec rv20_decoder = {
797
    "rv20",
798
    CODEC_TYPE_VIDEO,
799
    CODEC_ID_RV20,
800
    sizeof(MpegEncContext),
801
    rv10_decode_init,
802
    NULL,
803
    rv10_decode_end,
804
    rv10_decode_frame,
805
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
806
    .flush= ff_mpeg_flush,
807
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
808
};
809