Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 58c2182d

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
        mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
392
        s->mb_x= mb_pos % s->mb_width;
393
        s->mb_y= mb_pos / s->mb_width;
394
    }else{
395
        seq= get_bits(&s->gb, 8)*128;
396
        mb_pos= ff_h263_decode_mba(s);
397
    }
398
//printf("%d\n", seq);
399
    seq |= s->time &~0x7FFF;
400
    if(seq - s->time >  0x4000) seq -= 0x8000;
401
    if(seq - s->time < -0x4000) seq += 0x8000;
402
    if(seq != s->time){  
403
        if(s->pict_type!=B_TYPE){
404
            s->time= seq;
405
            s->pp_time= s->time - s->last_non_b_time;
406
            s->last_non_b_time= s->time;
407
        }else{
408
            s->time= seq;
409
            s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
410
            if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
411
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, seeking?, skiping current b frame\n");
412
                return FRAME_SKIPED;
413
            }
414
        }
415
    }
416
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
417

    
418
    s->no_rounding= get_bits1(&s->gb);
419
    
420
    s->f_code = 1;
421
    s->unrestricted_mv = 1;
422
    s->h263_aic= s->pict_type == I_TYPE;
423
//    s->alt_inter_vlc=1;
424
//    s->obmc=1;
425
//    s->umvplus=1;
426
    s->modified_quant=1;
427
    s->loop_filter=1;
428
    
429
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
430
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n", 
431
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
432
    }
433

    
434
    assert(s->pict_type != B_TYPE || !s->low_delay);
435

    
436
    return s->mb_width*s->mb_height - mb_pos;
437
}
438

    
439
static int rv10_decode_init(AVCodecContext *avctx)
440
{
441
    MpegEncContext *s = avctx->priv_data;
442
    static int done=0;
443

    
444
    MPV_decode_defaults(s);
445
    
446
    s->avctx= avctx;
447
    s->out_format = FMT_H263;
448
    s->codec_id= avctx->codec_id;
449

    
450
    s->width = avctx->width;
451
    s->height = avctx->height;
452

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

    
493
    h263_decode_init_vlc(s);
494

    
495
    /* init rv vlc */
496
    if (!done) {
497
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
498
                 rv_lum_bits, 1, 1,
499
                 rv_lum_code, 2, 2);
500
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
501
                 rv_chrom_bits, 1, 1,
502
                 rv_chrom_code, 2, 2);
503
        done = 1;
504
    }
505
    
506
    avctx->pix_fmt = PIX_FMT_YUV420P;
507

    
508
    return 0;
509
}
510

    
511
static int rv10_decode_end(AVCodecContext *avctx)
512
{
513
    MpegEncContext *s = avctx->priv_data;
514

    
515
    MPV_common_end(s);
516
    return 0;
517
}
518

    
519
static int rv10_decode_packet(AVCodecContext *avctx, 
520
                             uint8_t *buf, int buf_size)
521
{
522
    MpegEncContext *s = avctx->priv_data;
523
    int i, mb_count, mb_pos, left;
524

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

    
554
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
555
        if(MPV_frame_start(s, avctx) < 0)
556
            return -1;
557
    }
558

    
559
    if(s->pict_type == B_TYPE){ //FIXME remove after cleaning mottion_val indexing
560
        memset(s->current_picture.motion_val[0], 0, sizeof(int16_t)*2*(s->mb_width*2+2)*(s->mb_height*2+2));
561
    }
562

    
563
#ifdef DEBUG
564
    printf("qscale=%d\n", s->qscale);
565
#endif
566

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

    
583
    if(s->modified_quant)
584
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
585
        
586
    ff_set_qscale(s, s->qscale);
587

    
588
    s->rv10_first_dc_coded[0] = 0;
589
    s->rv10_first_dc_coded[1] = 0;
590
    s->rv10_first_dc_coded[2] = 0;
591
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
592
    s->block_wrap[0]=
593
    s->block_wrap[1]=
594
    s->block_wrap[2]=
595
    s->block_wrap[3]= s->mb_width*2 + 2;
596
    s->block_wrap[4]=
597
    s->block_wrap[5]= s->mb_width + 2;
598
    ff_init_block_index(s);
599
    /* decode each macroblock */
600

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

    
608
        s->dsp.clear_blocks(s->block[0]);
609
        s->mv_dir = MV_DIR_FORWARD;
610
        s->mv_type = MV_TYPE_16X16; 
611
        ret=ff_h263_decode_mb(s, s->block);
612

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

    
623
        if (++s->mb_x == s->mb_width) {
624
            s->mb_x = 0;
625
            s->mb_y++;
626
            ff_init_block_index(s);
627
        }
628
        if(s->mb_x == s->resync_mb_x)
629
            s->first_slice_line=0;
630
        if(ret == SLICE_END) break;
631
    }
632

    
633
    return buf_size;
634
}
635

    
636
static int rv10_decode_frame(AVCodecContext *avctx, 
637
                             void *data, int *data_size,
638
                             uint8_t *buf, int buf_size)
639
{
640
    MpegEncContext *s = avctx->priv_data;
641
    int i;
642
    AVFrame *pict = data; 
643

    
644
#ifdef DEBUG
645
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
646
#endif
647

    
648
    /* no supplementary picture */
649
    if (buf_size == 0) {
650
        *data_size = 0;
651
        return 0;
652
    }
653

    
654
    if(avctx->slice_count){
655
        for(i=0; i<avctx->slice_count; i++){
656
            int offset= avctx->slice_offset[i];
657
            int size;
658
            
659
            if(i+1 == avctx->slice_count)
660
                size= buf_size - offset;
661
            else
662
                size= avctx->slice_offset[i+1] - offset;
663

    
664
            if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
665
                return -1;
666
        }
667
    }else{
668
        if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
669
            return -1;
670
    }
671
    
672
    if(s->pict_type == B_TYPE){ //FIXME remove after cleaning mottion_val indexing
673
        memset(s->current_picture.motion_val[0], 0, sizeof(int16_t)*2*(s->mb_width*2+2)*(s->mb_height*2+2));
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