Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 137c8468

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(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
346
        if (get_bits(&s->gb, 3)){
347
            av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
348
            return -1;
349
        } 
350
    }   
351

    
352
    i= get_bits(&s->gb, 2);
353
    switch(i){
354
    case 0: s->pict_type= I_TYPE; break;
355
    case 1: s->pict_type= I_TYPE; break; //hmm ...
356
    case 2: s->pict_type= P_TYPE; break;
357
    case 3: s->pict_type= B_TYPE; break;
358
    default: 
359
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
360
        return -1;
361
    }
362
    
363
    if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
364
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
365
        return -1;
366
    }
367
    
368
    if (get_bits(&s->gb, 1)){
369
        av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
370
        return -1;
371
    }
372

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

    
441
    assert(s->pict_type != B_TYPE || !s->low_delay);
442

    
443
    return s->mb_width*s->mb_height - mb_pos;
444
}
445

    
446
static int rv10_decode_init(AVCodecContext *avctx)
447
{
448
    MpegEncContext *s = avctx->priv_data;
449
    static int done=0;
450

    
451
    MPV_decode_defaults(s);
452
    
453
    s->avctx= avctx;
454
    s->out_format = FMT_H263;
455
    s->codec_id= avctx->codec_id;
456

    
457
    s->width = avctx->width;
458
    s->height = avctx->height;
459

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

    
501
    h263_decode_init_vlc(s);
502

    
503
    /* init rv vlc */
504
    if (!done) {
505
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
506
                 rv_lum_bits, 1, 1,
507
                 rv_lum_code, 2, 2);
508
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
509
                 rv_chrom_bits, 1, 1,
510
                 rv_chrom_code, 2, 2);
511
        done = 1;
512
    }
513
    
514
    avctx->pix_fmt = PIX_FMT_YUV420P;
515

    
516
    return 0;
517
}
518

    
519
static int rv10_decode_end(AVCodecContext *avctx)
520
{
521
    MpegEncContext *s = avctx->priv_data;
522

    
523
    MPV_common_end(s);
524
    return 0;
525
}
526

    
527
static int rv10_decode_packet(AVCodecContext *avctx, 
528
                             uint8_t *buf, int buf_size)
529
{
530
    MpegEncContext *s = avctx->priv_data;
531
    int i, mb_count, mb_pos, left;
532

    
533
    init_get_bits(&s->gb, buf, buf_size*8);
534
#if 0
535
    for(i=0; i<buf_size*8 && i<200; i++)
536
        printf("%d", get_bits1(&s->gb));
537
    printf("\n");
538
    return 0;
539
#endif
540
    if(s->codec_id ==CODEC_ID_RV10)
541
        mb_count = rv10_decode_picture_header(s);
542
    else
543
        mb_count = rv20_decode_picture_header(s);
544
    if (mb_count < 0) {
545
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
546
        return -1;
547
    }
548
    
549
    if (s->mb_x >= s->mb_width ||
550
        s->mb_y >= s->mb_height) {
551
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
552
        return -1;
553
    }
554
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
555
    left = s->mb_width * s->mb_height - mb_pos;
556
    if (mb_count > left) {
557
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
558
        return -1;
559
    }
560
//if(s->pict_type == P_TYPE) return 0;
561

    
562
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
563
        if(MPV_frame_start(s, avctx) < 0)
564
            return -1;
565
    }
566

    
567
#ifdef DEBUG
568
    printf("qscale=%d\n", s->qscale);
569
#endif
570

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

    
587
    if(s->modified_quant)
588
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
589
        
590
    ff_set_qscale(s, s->qscale);
591

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

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

    
612
        s->dsp.clear_blocks(s->block[0]);
613
        s->mv_dir = MV_DIR_FORWARD;
614
        s->mv_type = MV_TYPE_16X16; 
615
        ret=ff_h263_decode_mb(s, s->block);
616

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

    
627
        if (++s->mb_x == s->mb_width) {
628
            s->mb_x = 0;
629
            s->mb_y++;
630
            ff_init_block_index(s);
631
        }
632
        if(s->mb_x == s->resync_mb_x)
633
            s->first_slice_line=0;
634
        if(ret == SLICE_END) break;
635
    }
636

    
637
    return buf_size;
638
}
639

    
640
static int rv10_decode_frame(AVCodecContext *avctx, 
641
                             void *data, int *data_size,
642
                             uint8_t *buf, int buf_size)
643
{
644
    MpegEncContext *s = avctx->priv_data;
645
    int i;
646
    AVFrame *pict = data; 
647

    
648
#ifdef DEBUG
649
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
650
#endif
651

    
652
    /* no supplementary picture */
653
    if (buf_size == 0) {
654
        *data_size = 0;
655
        return 0;
656
    }
657

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

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

    
692
    return buf_size;
693
}
694

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

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