Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 5509bffa

History | View | Annotate | Download (23.9 KB)

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

    
21
/**
22
 * @file rv10.c
23
 * RV10 codec.
24
 */
25

    
26
#include "avcodec.h"
27
#include "dsputil.h"
28
#include "mpegvideo.h"
29

    
30
//#define DEBUG
31

    
32
#define DC_VLC_BITS 14 //FIXME find a better solution
33

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

    
70
static const uint8_t rv_lum_bits[256] =
71
{
72
 14, 12, 12, 12, 12, 12, 12, 12,
73
 12, 12, 12, 12, 12, 12, 12, 12,
74
 12, 12, 12, 12, 12, 12, 12, 12,
75
 12, 12, 12, 12, 12, 12, 12, 12,
76
 12, 12, 12, 12, 12, 12, 12, 12,
77
 12, 12, 12, 12, 12, 12, 12, 12,
78
 12, 12, 12, 12, 12, 12, 12, 12,
79
 12, 12, 12, 12, 12, 12, 12, 12,
80
 12, 10, 10, 10, 10, 10, 10, 10,
81
 10, 10, 10, 10, 10, 10, 10, 10,
82
 10, 10, 10, 10, 10, 10, 10, 10,
83
 10, 10, 10, 10, 10, 10, 10, 10,
84
 10,  8,  8,  8,  8,  8,  8,  8,
85
  8,  8,  8,  8,  8,  8,  8,  8,
86
  8,  7,  7,  7,  7,  7,  7,  7,
87
  7,  6,  6,  6,  6,  5,  5,  4,
88
  2,  4,  5,  5,  6,  6,  6,  6,
89
  7,  7,  7,  7,  7,  7,  7,  7,
90
  8,  8,  8,  8,  8,  8,  8,  8,
91
  8,  8,  8,  8,  8,  8,  8,  8,
92
 10, 10, 10, 10, 10, 10, 10, 10,
93
 10, 10, 10, 10, 10, 10, 10, 10,
94
 10, 10, 10, 10, 10, 10, 10, 10,
95
 10, 10, 10, 10, 10, 10, 10, 10,
96
 12, 12, 12, 12, 12, 12, 12, 12,
97
 12, 12, 12, 12, 12, 12, 12, 12,
98
 12, 12, 12, 12, 12, 12, 12, 12,
99
 12, 12, 12, 12, 12, 12, 12, 12,
100
 12, 12, 12, 12, 12, 12, 12, 12,
101
 12, 12, 12, 12, 12, 12, 12, 12,
102
 12, 12, 12, 12, 12, 12, 12, 12,
103
 12, 12, 12, 12, 12, 12, 12, 12,
104
};
105

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

    
142
static const uint8_t rv_chrom_bits[256] =
143
{
144
 16, 14, 14, 14, 14, 14, 14, 14,
145
 14, 14, 14, 14, 14, 14, 14, 14,
146
 14, 14, 14, 14, 14, 14, 14, 14,
147
 14, 14, 14, 14, 14, 14, 14, 14,
148
 14, 14, 14, 14, 14, 14, 14, 14,
149
 14, 14, 14, 14, 14, 14, 14, 14,
150
 14, 14, 14, 14, 14, 14, 14, 14,
151
 14, 14, 14, 14, 14, 14, 14, 14,
152
 14, 12, 12, 12, 12, 12, 12, 12,
153
 12, 12, 12, 12, 12, 12, 12, 12,
154
 12, 12, 12, 12, 12, 12, 12, 12,
155
 12, 12, 12, 12, 12, 12, 12, 12,
156
 12, 10, 10, 10, 10, 10, 10, 10,
157
 10, 10, 10, 10, 10, 10, 10, 10,
158
 10,  8,  8,  8,  8,  8,  8,  8,
159
  8,  6,  6,  6,  6,  4,  4,  3,
160
  2,  3,  4,  4,  6,  6,  6,  6,
161
  8,  8,  8,  8,  8,  8,  8,  8,
162
 10, 10, 10, 10, 10, 10, 10, 10,
163
 10, 10, 10, 10, 10, 10, 10, 10,
164
 12, 12, 12, 12, 12, 12, 12, 12,
165
 12, 12, 12, 12, 12, 12, 12, 12,
166
 12, 12, 12, 12, 12, 12, 12, 12,
167
 12, 12, 12, 12, 12, 12, 12, 12,
168
 14, 14, 14, 14, 14, 14, 14, 14,
169
 14, 14, 14, 14, 14, 14, 14, 14,
170
 14, 14, 14, 14, 14, 14, 14, 14,
171
 14, 14, 14, 14, 14, 14, 14, 14,
172
 14, 14, 14, 14, 14, 14, 14, 14,
173
 14, 14, 14, 14, 14, 14, 14, 14,
174
 14, 14, 14, 14, 14, 14, 14, 14,
175
 14, 14, 14, 14, 14, 14, 14, 14,
176
};
177

    
178
static VLC rv_dc_lum, rv_dc_chrom;
179

    
180
int rv_decode_dc(MpegEncContext *s, int n)
181
{
182
    int code;
183

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

    
230
#ifdef CONFIG_ENCODERS
231

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

    
237
    align_put_bits(&s->pb);
238

    
239
    put_bits(&s->pb, 1, 1);     /* marker */
240

    
241
    put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
242

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

    
245
    put_bits(&s->pb, 5, s->qscale);
246

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

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

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

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

    
270
    put_bits(&s->pb, 1, s->no_rounding);
271

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

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

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

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

    
305
#endif //CONFIG_ENCODERS
306

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

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

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

    
323
#ifdef DEBUG
324
    printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
325
#endif
326

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

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

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

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

    
370
    return mb_count;
371
}
372

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

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

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

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

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

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

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

    
433
    if(s->avctx->has_b_frames){
434
        int f=9;
435
        int v= s->avctx->extradata_size >= 4 ? ((uint8_t*)s->avctx->extradata)[1] : 0;
436

    
437
        if (get_bits(&s->gb, 1)){
438
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
439
//            return -1;
440
        }
441
        seq= get_bits(&s->gb, 14)<<1;
442

    
443
        if(v)
444
            f= get_bits(&s->gb, av_log2(v));
445

    
446
        if(s->avctx->debug & FF_DEBUG_PICT_INFO){
447
            av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
448
        }
449
    }else{
450
        seq= get_bits(&s->gb, 8)*128;
451
    }
452

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

    
485
    s->f_code = 1;
486
    s->unrestricted_mv = 1;
487
    s->h263_aic= s->pict_type == I_TYPE;
488
//    s->alt_inter_vlc=1;
489
//    s->obmc=1;
490
//    s->umvplus=1;
491
    s->modified_quant=1;
492
    s->loop_filter=1;
493

    
494
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
495
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
496
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
497
    }
498

    
499
    assert(s->pict_type != B_TYPE || !s->low_delay);
500

    
501
    return s->mb_width*s->mb_height - mb_pos;
502
}
503

    
504
static int rv10_decode_init(AVCodecContext *avctx)
505
{
506
    MpegEncContext *s = avctx->priv_data;
507
    static int done=0;
508

    
509
    MPV_decode_defaults(s);
510

    
511
    s->avctx= avctx;
512
    s->out_format = FMT_H263;
513
    s->codec_id= avctx->codec_id;
514

    
515
    s->width = avctx->width;
516
    s->height = avctx->height;
517

    
518
    switch(avctx->sub_id){
519
    case 0x10000000:
520
        s->rv10_version= 0;
521
        s->h263_long_vectors=0;
522
        s->low_delay=1;
523
        break;
524
    case 0x10002000:
525
        s->rv10_version= 3;
526
        s->h263_long_vectors=1;
527
        s->low_delay=1;
528
        s->obmc=1;
529
        break;
530
    case 0x10003000:
531
        s->rv10_version= 3;
532
        s->h263_long_vectors=1;
533
        s->low_delay=1;
534
        break;
535
    case 0x10003001:
536
        s->rv10_version= 3;
537
        s->h263_long_vectors=0;
538
        s->low_delay=1;
539
        break;
540
    case 0x20001000: /* real rv20 decoder fail on this id */
541
    /*case 0x20100001:
542
    case 0x20101001:
543
    case 0x20103001:*/
544
    case 0x20100000 ... 0x2019ffff:
545
        s->low_delay=1;
546
        break;
547
    /*case 0x20200002:
548
    case 0x20201002:
549
    case 0x20203002:*/
550
    case 0x20200002 ... 0x202fffff:
551
    case 0x30202002:
552
    case 0x30203002:
553
        s->low_delay=0;
554
        s->avctx->has_b_frames=1;
555
        break;
556
    default:
557
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
558
    }
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(&rv_dc_lum, DC_VLC_BITS, 256,
574
                 rv_lum_bits, 1, 1,
575
                 rv_lum_code, 2, 2, 1);
576
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
577
                 rv_chrom_bits, 1, 1,
578
                 rv_chrom_code, 2, 2, 1);
579
        done = 1;
580
    }
581

    
582
    return 0;
583
}
584

    
585
static 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
                             uint8_t *buf, int buf_size)
595
{
596
    MpegEncContext *s = avctx->priv_data;
597
    int mb_count, mb_pos, left;
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 == 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
    printf("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
        s->resync_mb_y= s->mb_y;
644
    }
645
    if(s->h263_aic){
646
        s->y_dc_scale_table=
647
        s->c_dc_scale_table= ff_aic_dc_scale_table;
648
    }else{
649
        s->y_dc_scale_table=
650
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
651
    }
652

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

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

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

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

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

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

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

    
702
    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
703

    
704
    return buf_size;
705
}
706

    
707
static int rv10_decode_frame(AVCodecContext *avctx,
708
                             void *data, int *data_size,
709
                             uint8_t *buf, int buf_size)
710
{
711
    MpegEncContext *s = avctx->priv_data;
712
    int i;
713
    AVFrame *pict = data;
714

    
715
#ifdef DEBUG
716
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
717
#endif
718

    
719
    /* no supplementary picture */
720
    if (buf_size == 0) {
721
        return 0;
722
    }
723

    
724
    if(avctx->slice_count){
725
        for(i=0; i<avctx->slice_count; i++){
726
            int offset= avctx->slice_offset[i];
727
            int size;
728

    
729
            if(i+1 == avctx->slice_count)
730
                size= buf_size - offset;
731
            else
732
                size= avctx->slice_offset[i+1] - offset;
733

    
734
            rv10_decode_packet(avctx, buf+offset, size);
735
        }
736
    }else{
737
        rv10_decode_packet(avctx, buf, buf_size);
738
    }
739

    
740
    if(s->mb_y>=s->mb_height){
741
        ff_er_frame_end(s);
742
        MPV_frame_end(s);
743

    
744
        if(s->pict_type==B_TYPE || s->low_delay){
745
            *pict= *(AVFrame*)&s->current_picture;
746
            ff_print_debug_info(s, pict);
747
        } else {
748
            *pict= *(AVFrame*)&s->last_picture;
749
            ff_print_debug_info(s, pict);
750
        }
751
        if(s->last_picture_ptr || s->low_delay)
752
            *data_size = sizeof(AVFrame);
753
        s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
754
    }
755

    
756
    return buf_size;
757
}
758

    
759
AVCodec rv10_decoder = {
760
    "rv10",
761
    CODEC_TYPE_VIDEO,
762
    CODEC_ID_RV10,
763
    sizeof(MpegEncContext),
764
    rv10_decode_init,
765
    NULL,
766
    rv10_decode_end,
767
    rv10_decode_frame,
768
    CODEC_CAP_DR1
769
};
770

    
771
AVCodec rv20_decoder = {
772
    "rv20",
773
    CODEC_TYPE_VIDEO,
774
    CODEC_ID_RV20,
775
    sizeof(MpegEncContext),
776
    rv10_decode_init,
777
    NULL,
778
    rv10_decode_end,
779
    rv10_decode_frame,
780
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
781
    .flush= ff_mpeg_flush,
782
};
783