Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ d0271e8a

History | View | Annotate | Download (23.6 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
static int get_num(GetBitContext *gb)
291
{
292
    int n, n1;
293

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

    
303
#endif //CONFIG_ENCODERS
304

    
305
/* read RV 1.0 compatible frame header */
306
static int rv10_decode_picture_header(MpegEncContext *s)
307
{
308
    int mb_count, pb_frame, marker, unk, mb_xy;
309
    
310
//printf("ff:%d\n", full_frame);
311
    marker = get_bits(&s->gb, 1);
312

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

    
321
#ifdef DEBUG
322
    printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
323
#endif
324
    
325
    if (pb_frame){
326
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
327
        return -1;
328
    }
329

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

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

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

    
368
    return mb_count;
369
}
370

    
371
static int rv20_decode_picture_header(MpegEncContext *s)
372
{
373
    int seq, mb_pos, i;
374
    
375
#if 0
376
    GetBitContext gb= s->gb;
377
    for(i=0; i<64; i++){
378
        av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
379
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
380
    }
381
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
382
#endif
383
#if 0
384
    for(i=0; i<s->avctx->extradata_size; i++){
385
        av_log(s->avctx, AV_LOG_DEBUG, "%2X ", ((uint8_t*)s->avctx->extradata)[i]);
386
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
387
    }
388
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
389
#endif
390
    
391
    if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
392
        if (get_bits(&s->gb, 3)){
393
            av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
394
            return -1;
395
        } 
396
    }   
397

    
398
    i= get_bits(&s->gb, 2);
399
    switch(i){
400
    case 0: s->pict_type= I_TYPE; break;
401
    case 1: s->pict_type= I_TYPE; break; //hmm ...
402
    case 2: s->pict_type= P_TYPE; break;
403
    case 3: s->pict_type= B_TYPE; break;
404
    default: 
405
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
406
        return -1;
407
    }
408
    
409
    if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
410
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
411
        return -1;
412
    }
413
    
414
    if (get_bits(&s->gb, 1)){
415
        av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
416
        return -1;
417
    }
418

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

    
436
        if (get_bits(&s->gb, 1)){
437
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
438
//            return -1;
439
        }
440
        seq= get_bits(&s->gb, 14)<<1;
441
        
442
        if(s->avctx->extradata_size >= 4 && ((uint8_t*)s->avctx->extradata)[1]&1){
443
            f1= get_bits(&s->gb, 1);
444
        }
445
        if(s->avctx->extradata_size >= 4 && ((uint8_t*)s->avctx->extradata)[1]&2){
446
            f2= get_bits(&s->gb, 1);
447
        }
448
        if(s->avctx->extradata_size >= 4 && ((uint8_t*)s->avctx->extradata)[1]&4){
449
            f3= get_bits(&s->gb, 2);
450
        }
451
        
452
        if(s->avctx->debug & FF_DEBUG_PICT_INFO){
453
            av_log(s->avctx, AV_LOG_DEBUG, "F %d %d %d\n", f1,f2,f3);            
454
        }
455

    
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
    }else{
460
        seq= get_bits(&s->gb, 8)*128;
461
        mb_pos= ff_h263_decode_mba(s);
462
    }
463
//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
464
    seq |= s->time &~0x7FFF;
465
    if(seq - s->time >  0x4000) seq -= 0x8000;
466
    if(seq - s->time < -0x4000) seq += 0x8000;
467
    if(seq != s->time){  
468
        if(s->pict_type!=B_TYPE){
469
            s->time= seq;
470
            s->pp_time= s->time - s->last_non_b_time;
471
            s->last_non_b_time= s->time;
472
        }else{
473
            s->time= seq;
474
            s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
475
            if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
476
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, seeking?, skiping current b frame\n");
477
                return FRAME_SKIPED;
478
            }
479
        }
480
    }
481
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
482
/*for(i=0; i<32; i++){
483
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
484
}
485
av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
486
    s->no_rounding= get_bits1(&s->gb);
487
    
488
    s->f_code = 1;
489
    s->unrestricted_mv = 1;
490
    s->h263_aic= s->pict_type == I_TYPE;
491
//    s->alt_inter_vlc=1;
492
//    s->obmc=1;
493
//    s->umvplus=1;
494
    s->modified_quant=1;
495
    s->loop_filter=1;
496
    
497
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
498
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n", 
499
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
500
    }
501

    
502
    assert(s->pict_type != B_TYPE || !s->low_delay);
503

    
504
    return s->mb_width*s->mb_height - mb_pos;
505
}
506

    
507
static int rv10_decode_init(AVCodecContext *avctx)
508
{
509
    MpegEncContext *s = avctx->priv_data;
510
    static int done=0;
511

    
512
    MPV_decode_defaults(s);
513
    
514
    s->avctx= avctx;
515
    s->out_format = FMT_H263;
516
    s->codec_id= avctx->codec_id;
517

    
518
    s->width = avctx->width;
519
    s->height = avctx->height;
520

    
521
    switch(avctx->sub_id){
522
    case 0x10000000:
523
        s->rv10_version= 0;
524
        s->h263_long_vectors=0;
525
        s->low_delay=1;
526
        break;
527
    case 0x10002000:
528
        s->rv10_version= 3;
529
        s->h263_long_vectors=1;
530
        s->low_delay=1;
531
        s->obmc=1;
532
        break;
533
    case 0x10003000:
534
        s->rv10_version= 3;
535
        s->h263_long_vectors=1;
536
        s->low_delay=1;
537
        break;
538
    case 0x10003001:
539
        s->rv10_version= 3;
540
        s->h263_long_vectors=0;
541
        s->low_delay=1;
542
        break;
543
    case 0x20001000:
544
    case 0x20100001:
545
    case 0x20101001:
546
    case 0x20103001:
547
        s->low_delay=1;
548
        break;
549
    case 0x20200002:
550
    case 0x20201002:
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
    if (MPV_common_init(s) < 0)
565
        return -1;
566

    
567
    h263_decode_init_vlc(s);
568

    
569
    /* init rv vlc */
570
    if (!done) {
571
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
572
                 rv_lum_bits, 1, 1,
573
                 rv_lum_code, 2, 2, 1);
574
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
575
                 rv_chrom_bits, 1, 1,
576
                 rv_chrom_code, 2, 2, 1);
577
        done = 1;
578
    }
579
    
580
    avctx->pix_fmt = PIX_FMT_YUV420P;
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(MPV_frame_start(s, avctx) < 0)
624
            return -1;
625
    }
626

    
627
#ifdef DEBUG
628
    printf("qscale=%d\n", s->qscale);
629
#endif
630

    
631
    /* default quantization values */
632
    if(s->codec_id== CODEC_ID_RV10){
633
        if(s->mb_y==0) s->first_slice_line=1;
634
    }else{
635
        s->first_slice_line=1;    
636
        s->resync_mb_x= s->mb_x;
637
        s->resync_mb_y= s->mb_y;
638
    }
639
    if(s->h263_aic){
640
        s->y_dc_scale_table= 
641
        s->c_dc_scale_table= ff_aic_dc_scale_table;
642
    }else{
643
        s->y_dc_scale_table=
644
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
645
    }
646

    
647
    if(s->modified_quant)
648
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
649
        
650
    ff_set_qscale(s, s->qscale);
651

    
652
    s->rv10_first_dc_coded[0] = 0;
653
    s->rv10_first_dc_coded[1] = 0;
654
    s->rv10_first_dc_coded[2] = 0;
655
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
656
    s->block_wrap[0]=
657
    s->block_wrap[1]=
658
    s->block_wrap[2]=
659
    s->block_wrap[3]= s->b8_stride;
660
    s->block_wrap[4]=
661
    s->block_wrap[5]= s->mb_stride;
662
    ff_init_block_index(s);
663
    /* decode each macroblock */
664

    
665
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
666
        int ret;
667
        ff_update_block_index(s);
668
#ifdef DEBUG
669
        printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
670
#endif
671

    
672
        s->dsp.clear_blocks(s->block[0]);
673
        s->mv_dir = MV_DIR_FORWARD;
674
        s->mv_type = MV_TYPE_16X16; 
675
        ret=ff_h263_decode_mb(s, s->block);
676

    
677
        if (ret == SLICE_ERROR) {
678
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
679
            return -1;
680
        }
681
        if(s->pict_type != B_TYPE)
682
            ff_h263_update_motion_val(s);
683
        MPV_decode_mb(s, s->block);
684
        if(s->loop_filter)
685
            ff_h263_loop_filter(s);
686

    
687
        if (++s->mb_x == s->mb_width) {
688
            s->mb_x = 0;
689
            s->mb_y++;
690
            ff_init_block_index(s);
691
        }
692
        if(s->mb_x == s->resync_mb_x)
693
            s->first_slice_line=0;
694
        if(ret == SLICE_END) break;
695
    }
696

    
697
    return buf_size;
698
}
699

    
700
static int rv10_decode_frame(AVCodecContext *avctx, 
701
                             void *data, int *data_size,
702
                             uint8_t *buf, int buf_size)
703
{
704
    MpegEncContext *s = avctx->priv_data;
705
    int i;
706
    AVFrame *pict = data; 
707

    
708
#ifdef DEBUG
709
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
710
#endif
711

    
712
    /* no supplementary picture */
713
    if (buf_size == 0) {
714
        return 0;
715
    }
716

    
717
    if(avctx->slice_count){
718
        for(i=0; i<avctx->slice_count; i++){
719
            int offset= avctx->slice_offset[i];
720
            int size;
721
            
722
            if(i+1 == avctx->slice_count)
723
                size= buf_size - offset;
724
            else
725
                size= avctx->slice_offset[i+1] - offset;
726

    
727
            if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
728
                return -1;
729
        }
730
    }else{
731
        if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
732
            return -1;
733
    }
734
    
735
    if(s->mb_y>=s->mb_height){
736
        MPV_frame_end(s);
737
    
738
        if(s->pict_type==B_TYPE || s->low_delay){
739
            *pict= *(AVFrame*)&s->current_picture;
740
            ff_print_debug_info(s, pict);
741
        } else {
742
            *pict= *(AVFrame*)&s->last_picture;
743
            ff_print_debug_info(s, pict);
744
        }
745
        if(s->last_picture_ptr || s->low_delay)
746
            *data_size = sizeof(AVFrame);
747
    }
748

    
749
    return buf_size;
750
}
751

    
752
AVCodec rv10_decoder = {
753
    "rv10",
754
    CODEC_TYPE_VIDEO,
755
    CODEC_ID_RV10,
756
    sizeof(MpegEncContext),
757
    rv10_decode_init,
758
    NULL,
759
    rv10_decode_end,
760
    rv10_decode_frame,
761
    CODEC_CAP_DR1
762
};
763

    
764
AVCodec rv20_decoder = {
765
    "rv20",
766
    CODEC_TYPE_VIDEO,
767
    CODEC_ID_RV20,
768
    sizeof(MpegEncContext),
769
    rv10_decode_init,
770
    NULL,
771
    rv10_decode_end,
772
    rv10_decode_frame,
773
    CODEC_CAP_DR1,
774
    .flush= ff_mpeg_flush,
775
};
776