Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 35ef76b5

History | View | Annotate | Download (21.8 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
static int get_num(GetBitContext *gb)
262
{
263
    int n, n1;
264

    
265
    n = get_bits(gb, 16);
266
    if (n >= 0x4000) {
267
        return n - 0x4000;
268
    } else {
269
        n1 = get_bits(gb, 16);
270
        return (n << 16) | n1;
271
    }
272
}
273

    
274
#endif //CONFIG_ENCODERS
275

    
276
/* read RV 1.0 compatible frame header */
277
static int rv10_decode_picture_header(MpegEncContext *s)
278
{
279
    int mb_count, pb_frame, marker, full_frame, unk;
280
    
281
    full_frame= s->avctx->slice_count==1;
282
//printf("ff:%d\n", full_frame);
283
    marker = get_bits(&s->gb, 1);
284

    
285
    if (get_bits(&s->gb, 1))
286
        s->pict_type = P_TYPE;
287
    else
288
        s->pict_type = I_TYPE;
289
//printf("h:%X ver:%d\n",h,s->rv10_version);
290
    if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
291
    pb_frame = get_bits(&s->gb, 1);
292

    
293
#ifdef DEBUG
294
    printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
295
#endif
296
    
297
    if (pb_frame){
298
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
299
        return -1;
300
    }
301

    
302
    s->qscale = get_bits(&s->gb, 5);
303
    if(s->qscale==0){
304
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
305
        return -1;
306
    }
307

    
308
    if (s->pict_type == I_TYPE) {
309
        if (s->rv10_version == 3) {
310
            /* specific MPEG like DC coding not used */
311
            s->last_dc[0] = get_bits(&s->gb, 8);
312
            s->last_dc[1] = get_bits(&s->gb, 8);
313
            s->last_dc[2] = get_bits(&s->gb, 8);
314
#ifdef DEBUG
315
            printf("DC:%d %d %d\n",
316
                   s->last_dc[0],
317
                   s->last_dc[1],
318
                   s->last_dc[2]);
319
#endif
320
        }
321
    }
322
    /* if multiple packets per frame are sent, the position at which
323
       to display the macro blocks is coded here */
324
    if ((!full_frame) || show_bits(&s->gb, 12)==0) {
325
        s->mb_x = get_bits(&s->gb, 6);        /* mb_x */
326
        s->mb_y = get_bits(&s->gb, 6);        /* mb_y */
327
        mb_count = get_bits(&s->gb, 12);
328
    } else {
329
        s->mb_x = 0;
330
        s->mb_y = 0;
331
        mb_count = s->mb_width * s->mb_height;
332
    }
333
    unk= get_bits(&s->gb, 3);        /* ignored */
334
//printf("%d\n", unk);
335
    s->f_code = 1;
336
    s->unrestricted_mv = 1;
337

    
338
    return mb_count;
339
}
340

    
341
static int rv20_decode_picture_header(MpegEncContext *s)
342
{
343
    int seq, mb_pos, i;
344
    
345
#if 0
346
    GetBitContext gb= s->gb;
347
    for(i=0; i<64; i++){
348
        av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
349
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
350
    }
351
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
352
#endif
353
    
354
    if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
355
        if (get_bits(&s->gb, 3)){
356
            av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
357
            return -1;
358
        } 
359
    }   
360

    
361
    i= get_bits(&s->gb, 2);
362
    switch(i){
363
    case 0: s->pict_type= I_TYPE; break;
364
    case 1: s->pict_type= I_TYPE; break; //hmm ...
365
    case 2: s->pict_type= P_TYPE; break;
366
    case 3: s->pict_type= B_TYPE; break;
367
    default: 
368
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
369
        return -1;
370
    }
371
    
372
    if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
373
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
374
        return -1;
375
    }
376
    
377
    if (get_bits(&s->gb, 1)){
378
        av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
379
        return -1;
380
    }
381

    
382
    s->qscale = get_bits(&s->gb, 5);
383
    if(s->qscale==0){
384
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
385
        return -1;
386
    }
387
    if(s->avctx->sub_id == 0x30203002){
388
        if (get_bits(&s->gb, 1)){
389
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
390
            return -1;
391
        }
392
    }
393
        
394
    if(s->avctx->has_b_frames){
395
        if (get_bits(&s->gb, 1)){
396
//            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
397
//            return -1;
398
        }
399
        seq= get_bits(&s->gb, 15);
400
        if (s->avctx->sub_id == 0x20201002 && 0 && get_bits(&s->gb, 1)){
401
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit4 set\n");
402
//            return -1;
403
        }
404
        mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
405
        s->mb_x= mb_pos % s->mb_width;
406
        s->mb_y= mb_pos / s->mb_width;
407
    }else{
408
        seq= get_bits(&s->gb, 8)*128;
409
        mb_pos= ff_h263_decode_mba(s);
410
    }
411
//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
412
    seq |= s->time &~0x7FFF;
413
    if(seq - s->time >  0x4000) seq -= 0x8000;
414
    if(seq - s->time < -0x4000) seq += 0x8000;
415
    if(seq != s->time){  
416
        if(s->pict_type!=B_TYPE){
417
            s->time= seq;
418
            s->pp_time= s->time - s->last_non_b_time;
419
            s->last_non_b_time= s->time;
420
        }else{
421
            s->time= seq;
422
            s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
423
            if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
424
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, seeking?, skiping current b frame\n");
425
                return FRAME_SKIPED;
426
            }
427
        }
428
    }
429
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
430
/*for(i=0; i<32; i++){
431
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
432
}
433
av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
434
    s->no_rounding= get_bits1(&s->gb);
435
    
436
    s->f_code = 1;
437
    s->unrestricted_mv = 1;
438
    s->h263_aic= s->pict_type == I_TYPE;
439
//    s->alt_inter_vlc=1;
440
//    s->obmc=1;
441
//    s->umvplus=1;
442
    s->modified_quant=1;
443
    s->loop_filter=1;
444
    
445
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
446
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n", 
447
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
448
    }
449

    
450
    assert(s->pict_type != B_TYPE || !s->low_delay);
451

    
452
    return s->mb_width*s->mb_height - mb_pos;
453
}
454

    
455
static int rv10_decode_init(AVCodecContext *avctx)
456
{
457
    MpegEncContext *s = avctx->priv_data;
458
    static int done=0;
459

    
460
    MPV_decode_defaults(s);
461
    
462
    s->avctx= avctx;
463
    s->out_format = FMT_H263;
464
    s->codec_id= avctx->codec_id;
465

    
466
    s->width = avctx->width;
467
    s->height = avctx->height;
468

    
469
    switch(avctx->sub_id){
470
    case 0x10000000:
471
        s->rv10_version= 0;
472
        s->h263_long_vectors=0;
473
        s->low_delay=1;
474
        break;
475
    case 0x10002000:
476
        s->rv10_version= 3;
477
        s->h263_long_vectors=1;
478
        s->low_delay=1;
479
        s->obmc=1;
480
        break;
481
    case 0x10003000:
482
        s->rv10_version= 3;
483
        s->h263_long_vectors=1;
484
        s->low_delay=1;
485
        break;
486
    case 0x10003001:
487
        s->rv10_version= 3;
488
        s->h263_long_vectors=0;
489
        s->low_delay=1;
490
        break;
491
    case 0x20001000:
492
    case 0x20100001:
493
    case 0x20101001:
494
    case 0x20103001:
495
        s->low_delay=1;
496
        break;
497
    case 0x20200002:
498
    case 0x20201002:
499
    case 0x30202002:
500
    case 0x30203002:
501
        s->low_delay=0;
502
        s->avctx->has_b_frames=1;
503
        break;
504
    default:
505
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
506
    }
507
//printf("ver:%X\n", avctx->sub_id);
508
    if (MPV_common_init(s) < 0)
509
        return -1;
510

    
511
    h263_decode_init_vlc(s);
512

    
513
    /* init rv vlc */
514
    if (!done) {
515
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
516
                 rv_lum_bits, 1, 1,
517
                 rv_lum_code, 2, 2);
518
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
519
                 rv_chrom_bits, 1, 1,
520
                 rv_chrom_code, 2, 2);
521
        done = 1;
522
    }
523
    
524
    avctx->pix_fmt = PIX_FMT_YUV420P;
525

    
526
    return 0;
527
}
528

    
529
static int rv10_decode_end(AVCodecContext *avctx)
530
{
531
    MpegEncContext *s = avctx->priv_data;
532

    
533
    MPV_common_end(s);
534
    return 0;
535
}
536

    
537
static int rv10_decode_packet(AVCodecContext *avctx, 
538
                             uint8_t *buf, int buf_size)
539
{
540
    MpegEncContext *s = avctx->priv_data;
541
    int mb_count, mb_pos, left;
542

    
543
    init_get_bits(&s->gb, buf, buf_size*8);
544
    if(s->codec_id ==CODEC_ID_RV10)
545
        mb_count = rv10_decode_picture_header(s);
546
    else
547
        mb_count = rv20_decode_picture_header(s);
548
    if (mb_count < 0) {
549
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
550
        return -1;
551
    }
552
    
553
    if (s->mb_x >= s->mb_width ||
554
        s->mb_y >= s->mb_height) {
555
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
556
        return -1;
557
    }
558
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
559
    left = s->mb_width * s->mb_height - mb_pos;
560
    if (mb_count > left) {
561
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
562
        return -1;
563
    }
564
//if(s->pict_type == P_TYPE) return 0;
565

    
566
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
567
        if(MPV_frame_start(s, avctx) < 0)
568
            return -1;
569
    }
570

    
571
#ifdef DEBUG
572
    printf("qscale=%d\n", s->qscale);
573
#endif
574

    
575
    /* default quantization values */
576
    if(s->codec_id== CODEC_ID_RV10){
577
        if(s->mb_y==0) s->first_slice_line=1;
578
    }else{
579
        s->first_slice_line=1;    
580
        s->resync_mb_x= s->mb_x;
581
        s->resync_mb_y= s->mb_y;
582
    }
583
    if(s->h263_aic){
584
        s->y_dc_scale_table= 
585
        s->c_dc_scale_table= ff_aic_dc_scale_table;
586
    }else{
587
        s->y_dc_scale_table=
588
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
589
    }
590

    
591
    if(s->modified_quant)
592
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
593
        
594
    ff_set_qscale(s, s->qscale);
595

    
596
    s->rv10_first_dc_coded[0] = 0;
597
    s->rv10_first_dc_coded[1] = 0;
598
    s->rv10_first_dc_coded[2] = 0;
599
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
600
    s->block_wrap[0]=
601
    s->block_wrap[1]=
602
    s->block_wrap[2]=
603
    s->block_wrap[3]= s->b8_stride;
604
    s->block_wrap[4]=
605
    s->block_wrap[5]= s->mb_stride;
606
    ff_init_block_index(s);
607
    /* decode each macroblock */
608

    
609
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
610
        int ret;
611
        ff_update_block_index(s);
612
#ifdef DEBUG
613
        printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
614
#endif
615

    
616
        s->dsp.clear_blocks(s->block[0]);
617
        s->mv_dir = MV_DIR_FORWARD;
618
        s->mv_type = MV_TYPE_16X16; 
619
        ret=ff_h263_decode_mb(s, s->block);
620

    
621
        if (ret == SLICE_ERROR) {
622
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
623
            return -1;
624
        }
625
        if(s->pict_type != B_TYPE)
626
            ff_h263_update_motion_val(s);
627
        MPV_decode_mb(s, s->block);
628
        if(s->loop_filter)
629
            ff_h263_loop_filter(s);
630

    
631
        if (++s->mb_x == s->mb_width) {
632
            s->mb_x = 0;
633
            s->mb_y++;
634
            ff_init_block_index(s);
635
        }
636
        if(s->mb_x == s->resync_mb_x)
637
            s->first_slice_line=0;
638
        if(ret == SLICE_END) break;
639
    }
640

    
641
    return buf_size;
642
}
643

    
644
static int rv10_decode_frame(AVCodecContext *avctx, 
645
                             void *data, int *data_size,
646
                             uint8_t *buf, int buf_size)
647
{
648
    MpegEncContext *s = avctx->priv_data;
649
    int i;
650
    AVFrame *pict = data; 
651

    
652
#ifdef DEBUG
653
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
654
#endif
655

    
656
    /* no supplementary picture */
657
    if (buf_size == 0) {
658
        return 0;
659
    }
660

    
661
    if(avctx->slice_count){
662
        for(i=0; i<avctx->slice_count; i++){
663
            int offset= avctx->slice_offset[i];
664
            int size;
665
            
666
            if(i+1 == avctx->slice_count)
667
                size= buf_size - offset;
668
            else
669
                size= avctx->slice_offset[i+1] - offset;
670

    
671
            if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
672
                return -1;
673
        }
674
    }else{
675
        if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
676
            return -1;
677
    }
678
    
679
    if(s->mb_y>=s->mb_height){
680
        MPV_frame_end(s);
681
    
682
        if(s->pict_type==B_TYPE || s->low_delay){
683
            *pict= *(AVFrame*)&s->current_picture;
684
            ff_print_debug_info(s, pict);
685
        } else {
686
            *pict= *(AVFrame*)&s->last_picture;
687
            ff_print_debug_info(s, pict);
688
        }
689
        
690
        *data_size = sizeof(AVFrame);
691
    }
692

    
693
    return buf_size;
694
}
695

    
696
AVCodec rv10_decoder = {
697
    "rv10",
698
    CODEC_TYPE_VIDEO,
699
    CODEC_ID_RV10,
700
    sizeof(MpegEncContext),
701
    rv10_decode_init,
702
    NULL,
703
    rv10_decode_end,
704
    rv10_decode_frame,
705
    CODEC_CAP_DR1
706
};
707

    
708
AVCodec rv20_decoder = {
709
    "rv20",
710
    CODEC_TYPE_VIDEO,
711
    CODEC_ID_RV20,
712
    sizeof(MpegEncContext),
713
    rv10_decode_init,
714
    NULL,
715
    rv10_decode_end,
716
    rv10_decode_frame,
717
    CODEC_CAP_DR1
718
};
719