Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ ce6636b1

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 libavcodec/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 CONFIG_RV10_ENCODER || 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
#endif /* CONFIG_RV10_ENCODER || CONFIG_RV20_ENCODER */
293

    
294
/* read RV 1.0 compatible frame header */
295
static int rv10_decode_picture_header(MpegEncContext *s)
296
{
297
    int mb_count, pb_frame, marker, unk, mb_xy;
298

    
299
//printf("ff:%d\n", full_frame);
300
    marker = get_bits1(&s->gb);
301

    
302
    if (get_bits1(&s->gb))
303
        s->pict_type = FF_P_TYPE;
304
    else
305
        s->pict_type = FF_I_TYPE;
306
//printf("h:%X ver:%d\n",h,s->rv10_version);
307
    if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
308
    pb_frame = get_bits1(&s->gb);
309

    
310
#ifdef DEBUG
311
    av_log(s->avctx, AV_LOG_DEBUG, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
312
#endif
313

    
314
    if (pb_frame){
315
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
316
        return -1;
317
    }
318

    
319
    s->qscale = get_bits(&s->gb, 5);
320
    if(s->qscale==0){
321
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
322
        return -1;
323
    }
324

    
325
    if (s->pict_type == FF_I_TYPE) {
326
        if (s->rv10_version == 3) {
327
            /* specific MPEG like DC coding not used */
328
            s->last_dc[0] = get_bits(&s->gb, 8);
329
            s->last_dc[1] = get_bits(&s->gb, 8);
330
            s->last_dc[2] = get_bits(&s->gb, 8);
331
#ifdef DEBUG
332
            av_log(s->avctx, AV_LOG_DEBUG, "DC:%d %d %d\n",
333
                   s->last_dc[0],
334
                   s->last_dc[1],
335
                   s->last_dc[2]);
336
#endif
337
        }
338
    }
339
    /* if multiple packets per frame are sent, the position at which
340
       to display the macroblocks is coded here */
341

    
342
    mb_xy= s->mb_x + s->mb_y*s->mb_width;
343
    if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
344
        s->mb_x = get_bits(&s->gb, 6); /* mb_x */
345
        s->mb_y = get_bits(&s->gb, 6); /* mb_y */
346
        mb_count = get_bits(&s->gb, 12);
347
    } else {
348
        s->mb_x = 0;
349
        s->mb_y = 0;
350
        mb_count = s->mb_width * s->mb_height;
351
    }
352
    unk= get_bits(&s->gb, 3);   /* ignored */
353
//printf("%d\n", unk);
354
    s->f_code = 1;
355
    s->unrestricted_mv = 1;
356

    
357
    return mb_count;
358
}
359

    
360
static int rv20_decode_picture_header(MpegEncContext *s)
361
{
362
    int seq, mb_pos, i;
363

    
364
#if 0
365
    GetBitContext gb= s->gb;
366
    for(i=0; i<64; i++){
367
        av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
368
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
369
    }
370
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
371
#endif
372
#if 0
373
    av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
374
    for(i=0; i<s->avctx->extradata_size; i++){
375
        av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
376
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
377
    }
378
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
379
#endif
380

    
381
    if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
382
        if (get_bits(&s->gb, 3)){
383
            av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
384
            return -1;
385
        }
386
    }
387

    
388
    i= get_bits(&s->gb, 2);
389
    switch(i){
390
    case 0: s->pict_type= FF_I_TYPE; break;
391
    case 1: s->pict_type= FF_I_TYPE; break; //hmm ...
392
    case 2: s->pict_type= FF_P_TYPE; break;
393
    case 3: s->pict_type= FF_B_TYPE; break;
394
    default:
395
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
396
        return -1;
397
    }
398

    
399
    if(s->last_picture_ptr==NULL && s->pict_type==FF_B_TYPE){
400
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
401
        return -1;
402
    }
403

    
404
    if (get_bits1(&s->gb)){
405
        av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
406
        return -1;
407
    }
408

    
409
    s->qscale = get_bits(&s->gb, 5);
410
    if(s->qscale==0){
411
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
412
        return -1;
413
    }
414
    if(s->avctx->sub_id == 0x30203002){
415
        if (get_bits1(&s->gb)){
416
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
417
            return -1;
418
        }
419
    }
420

    
421
    if(s->avctx->has_b_frames){
422
        int f, new_w, new_h;
423
        int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
424

    
425
        if (get_bits1(&s->gb)){
426
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
427
//            return -1;
428
        }
429
        seq= get_bits(&s->gb, 13)<<2;
430

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

    
433
        if(f){
434
            new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
435
            new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
436
        }else{
437
            new_w= s->width; //FIXME wrong we of course must save the original in the context
438
            new_h= s->height;
439
        }
440
        if(new_w != s->width || new_h != s->height){
441
            av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
442
            if (avcodec_check_dimensions(s->avctx, new_h, new_w) < 0)
443
                return -1;
444
            MPV_common_end(s);
445
            s->width  = s->avctx->width = new_w;
446
            s->height = s->avctx->height= new_h;
447
            if (MPV_common_init(s) < 0)
448
                return -1;
449
        }
450

    
451
        if(s->avctx->debug & FF_DEBUG_PICT_INFO){
452
            av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
453
        }
454
    }else{
455
        seq= get_bits(&s->gb, 8)*128;
456
    }
457

    
458
//     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
459
    mb_pos= ff_h263_decode_mba(s);
460
/*    }else{
461
        mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
462
        s->mb_x= mb_pos % s->mb_width;
463
        s->mb_y= mb_pos / s->mb_width;
464
    }*/
465
//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
466
    seq |= s->time &~0x7FFF;
467
    if(seq - s->time >  0x4000) seq -= 0x8000;
468
    if(seq - s->time < -0x4000) seq += 0x8000;
469
    if(seq != s->time){
470
        if(s->pict_type!=FF_B_TYPE){
471
            s->time= seq;
472
            s->pp_time= s->time - s->last_non_b_time;
473
            s->last_non_b_time= s->time;
474
        }else{
475
            s->time= seq;
476
            s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
477
            if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
478
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
479
                return FRAME_SKIPPED;
480
            }
481
            ff_mpeg4_init_direct_mv(s);
482
        }
483
    }
484
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
485
/*for(i=0; i<32; i++){
486
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
487
}
488
av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
489
    s->no_rounding= get_bits1(&s->gb);
490

    
491
    s->f_code = 1;
492
    s->unrestricted_mv = 1;
493
    s->h263_aic= s->pict_type == FF_I_TYPE;
494
//    s->alt_inter_vlc=1;
495
//    s->obmc=1;
496
//    s->umvplus=1;
497
    s->modified_quant=1;
498
    if(!s->avctx->lowres)
499
        s->loop_filter=1;
500

    
501
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
502
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
503
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
504
    }
505

    
506
    assert(s->pict_type != FF_B_TYPE || !s->low_delay);
507

    
508
    return s->mb_width*s->mb_height - mb_pos;
509
}
510

    
511
static av_cold int rv10_decode_init(AVCodecContext *avctx)
512
{
513
    MpegEncContext *s = avctx->priv_data;
514
    static int done=0;
515

    
516
    if (avctx->extradata_size < 8) {
517
        av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
518
        return -1;
519
    }
520

    
521
    MPV_decode_defaults(s);
522

    
523
    s->avctx= avctx;
524
    s->out_format = FMT_H263;
525
    s->codec_id= avctx->codec_id;
526

    
527
    s->width = avctx->coded_width;
528
    s->height = avctx->coded_height;
529

    
530
    s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
531
    avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
532

    
533
    if (avctx->sub_id == 0x10000000) {
534
        s->rv10_version= 0;
535
        s->low_delay=1;
536
    } else if (avctx->sub_id == 0x10001000) {
537
        s->rv10_version= 3;
538
        s->low_delay=1;
539
    } else if (avctx->sub_id == 0x10002000) {
540
        s->rv10_version= 3;
541
        s->low_delay=1;
542
        s->obmc=1;
543
    } else if (avctx->sub_id == 0x10003000) {
544
        s->rv10_version= 3;
545
        s->low_delay=1;
546
    } else if (avctx->sub_id == 0x10003001) {
547
        s->rv10_version= 3;
548
        s->low_delay=1;
549
    } else if (    avctx->sub_id == 0x20001000
550
               || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
551
        s->low_delay=1;
552
    } else if (    avctx->sub_id == 0x30202002
553
               ||  avctx->sub_id == 0x30203002
554
               || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
555
        s->low_delay=0;
556
        s->avctx->has_b_frames=1;
557
    } else
558
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
559

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

    
564
    avctx->pix_fmt = PIX_FMT_YUV420P;
565

    
566
    if (MPV_common_init(s) < 0)
567
        return -1;
568

    
569
    h263_decode_init_vlc(s);
570

    
571
    /* init rv vlc */
572
    if (!done) {
573
        INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
574
                 rv_lum_bits, 1, 1,
575
                 rv_lum_code, 2, 2, 16384);
576
        INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
577
                 rv_chrom_bits, 1, 1,
578
                 rv_chrom_code, 2, 2, 16388);
579
        done = 1;
580
    }
581

    
582
    return 0;
583
}
584

    
585
static av_cold int rv10_decode_end(AVCodecContext *avctx)
586
{
587
    MpegEncContext *s = avctx->priv_data;
588

    
589
    MPV_common_end(s);
590
    return 0;
591
}
592

    
593
static int rv10_decode_packet(AVCodecContext *avctx,
594
                             const uint8_t *buf, int buf_size)
595
{
596
    MpegEncContext *s = avctx->priv_data;
597
    int mb_count, mb_pos, left, start_mb_x;
598

    
599
    init_get_bits(&s->gb, buf, buf_size*8);
600
    if(s->codec_id ==CODEC_ID_RV10)
601
        mb_count = rv10_decode_picture_header(s);
602
    else
603
        mb_count = rv20_decode_picture_header(s);
604
    if (mb_count < 0) {
605
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
606
        return -1;
607
    }
608

    
609
    if (s->mb_x >= s->mb_width ||
610
        s->mb_y >= s->mb_height) {
611
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
612
        return -1;
613
    }
614
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
615
    left = s->mb_width * s->mb_height - mb_pos;
616
    if (mb_count > left) {
617
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
618
        return -1;
619
    }
620
//if(s->pict_type == FF_P_TYPE) return 0;
621

    
622
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
623
        if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
624
            ff_er_frame_end(s);
625
            MPV_frame_end(s);
626
            s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
627
        }
628
        if(MPV_frame_start(s, avctx) < 0)
629
            return -1;
630
        ff_er_frame_start(s);
631
    }
632

    
633
#ifdef DEBUG
634
    av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
635
#endif
636

    
637
    /* default quantization values */
638
    if(s->codec_id== CODEC_ID_RV10){
639
        if(s->mb_y==0) s->first_slice_line=1;
640
    }else{
641
        s->first_slice_line=1;
642
        s->resync_mb_x= s->mb_x;
643
    }
644
    start_mb_x= s->mb_x;
645
    s->resync_mb_y= s->mb_y;
646
    if(s->h263_aic){
647
        s->y_dc_scale_table=
648
        s->c_dc_scale_table= ff_aic_dc_scale_table;
649
    }else{
650
        s->y_dc_scale_table=
651
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
652
    }
653

    
654
    if(s->modified_quant)
655
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
656

    
657
    ff_set_qscale(s, s->qscale);
658

    
659
    s->rv10_first_dc_coded[0] = 0;
660
    s->rv10_first_dc_coded[1] = 0;
661
    s->rv10_first_dc_coded[2] = 0;
662
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
663
    s->block_wrap[0]=
664
    s->block_wrap[1]=
665
    s->block_wrap[2]=
666
    s->block_wrap[3]= s->b8_stride;
667
    s->block_wrap[4]=
668
    s->block_wrap[5]= s->mb_stride;
669
    ff_init_block_index(s);
670
    /* decode each macroblock */
671

    
672
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
673
        int ret;
674
        ff_update_block_index(s);
675
#ifdef DEBUG
676
        av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
677
#endif
678

    
679
        s->mv_dir = MV_DIR_FORWARD;
680
        s->mv_type = MV_TYPE_16X16;
681
        ret=ff_h263_decode_mb(s, s->block);
682

    
683
        if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
684
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
685
            return -1;
686
        }
687
        if(s->pict_type != FF_B_TYPE)
688
            ff_h263_update_motion_val(s);
689
        MPV_decode_mb(s, s->block);
690
        if(s->loop_filter)
691
            ff_h263_loop_filter(s);
692

    
693
        if (++s->mb_x == s->mb_width) {
694
            s->mb_x = 0;
695
            s->mb_y++;
696
            ff_init_block_index(s);
697
        }
698
        if(s->mb_x == s->resync_mb_x)
699
            s->first_slice_line=0;
700
        if(ret == SLICE_END) break;
701
    }
702

    
703
    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);
704

    
705
    return buf_size;
706
}
707

    
708
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
709
{
710
    if(avctx->slice_count) return avctx->slice_offset[n];
711
    else                   return AV_RL32(buf + n*8);
712
}
713

    
714
static int rv10_decode_frame(AVCodecContext *avctx,
715
                             void *data, int *data_size,
716
                             AVPacket *avpkt)
717
{
718
    const uint8_t *buf = avpkt->data;
719
    int buf_size = avpkt->size;
720
    MpegEncContext *s = avctx->priv_data;
721
    int i;
722
    AVFrame *pict = data;
723
    int slice_count;
724
    const uint8_t *slices_hdr = NULL;
725

    
726
#ifdef DEBUG
727
    av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
728
#endif
729

    
730
    /* no supplementary picture */
731
    if (buf_size == 0) {
732
        return 0;
733
    }
734

    
735
    if(!avctx->slice_count){
736
        slice_count = (*buf++) + 1;
737
        slices_hdr = buf + 4;
738
        buf += 8 * slice_count;
739
    }else
740
        slice_count = avctx->slice_count;
741

    
742
    for(i=0; i<slice_count; i++){
743
        int offset= get_slice_offset(avctx, slices_hdr, i);
744
        int size;
745

    
746
        if(i+1 == slice_count)
747
            size= buf_size - offset;
748
        else
749
            size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
750

    
751
        rv10_decode_packet(avctx, buf+offset, size);
752
    }
753

    
754
    if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
755
        ff_er_frame_end(s);
756
        MPV_frame_end(s);
757

    
758
        if (s->pict_type == FF_B_TYPE || s->low_delay) {
759
            *pict= *(AVFrame*)s->current_picture_ptr;
760
        } else if (s->last_picture_ptr != NULL) {
761
            *pict= *(AVFrame*)s->last_picture_ptr;
762
        }
763

    
764
        if(s->last_picture_ptr || s->low_delay){
765
            *data_size = sizeof(AVFrame);
766
            ff_print_debug_info(s, pict);
767
        }
768
        s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
769
    }
770

    
771
    return buf_size;
772
}
773

    
774
AVCodec rv10_decoder = {
775
    "rv10",
776
    CODEC_TYPE_VIDEO,
777
    CODEC_ID_RV10,
778
    sizeof(MpegEncContext),
779
    rv10_decode_init,
780
    NULL,
781
    rv10_decode_end,
782
    rv10_decode_frame,
783
    CODEC_CAP_DR1,
784
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
785
    .pix_fmts= ff_pixfmt_list_420,
786
};
787

    
788
AVCodec rv20_decoder = {
789
    "rv20",
790
    CODEC_TYPE_VIDEO,
791
    CODEC_ID_RV20,
792
    sizeof(MpegEncContext),
793
    rv10_decode_init,
794
    NULL,
795
    rv10_decode_end,
796
    rv10_decode_frame,
797
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
798
    .flush= ff_mpeg_flush,
799
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
800
    .pix_fmts= ff_pixfmt_list_420,
801
};
802