Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 8f2ab833

History | View | Annotate | Download (21.2 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 (get_bits(&s->gb, 1)){
364
        av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
365
        return -1;
366
    }
367

    
368
    s->qscale = get_bits(&s->gb, 5);
369
    if(s->qscale==0){
370
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
371
        return -1;
372
    }
373
    if(s->avctx->sub_id == 0x30203002){
374
        if (get_bits(&s->gb, 1)){
375
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
376
            return -1;
377
        }
378
    }
379
        
380
    if(s->avctx->has_b_frames){
381
        if (get_bits(&s->gb, 1)){
382
//            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
383
//            return -1;
384
        }
385
        seq= get_bits(&s->gb, 15);
386
        mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
387
        s->mb_x= mb_pos % s->mb_width;
388
        s->mb_y= mb_pos / s->mb_width;
389
    }else{
390
        seq= get_bits(&s->gb, 8)*128;
391
        mb_pos= ff_h263_decode_mba(s);
392
    }
393
//printf("%d\n", seq);
394
    seq |= s->time &~0x7FFF;
395
    if(seq - s->time >  0x4000) seq -= 0x8000;
396
    if(seq - s->time < -0x4000) seq += 0x8000;
397
    if(seq != s->time){  
398
        if(s->pict_type!=B_TYPE){
399
            s->time= seq;
400
            s->pp_time= s->time - s->last_non_b_time;
401
            s->last_non_b_time= s->time;
402
        }else{
403
            s->time= seq;
404
            s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
405
            if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
406
                printf("messed up order, seeking?, skiping current b frame\n");
407
                return FRAME_SKIPED;
408
            }
409
        }
410
    }
411
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
412

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

    
429
    assert(s->pict_type != B_TYPE || !s->low_delay);
430

    
431
    return s->mb_width*s->mb_height - mb_pos;
432
}
433

    
434
static int rv10_decode_init(AVCodecContext *avctx)
435
{
436
    MpegEncContext *s = avctx->priv_data;
437
    static int done=0;
438

    
439
    s->avctx= avctx;
440
    s->out_format = FMT_H263;
441
    s->codec_id= avctx->codec_id;
442

    
443
    s->width = avctx->width;
444
    s->height = avctx->height;
445

    
446
    switch(avctx->sub_id){
447
    case 0x10000000:
448
        s->rv10_version= 0;
449
        s->h263_long_vectors=0;
450
        s->low_delay=1;
451
        break;
452
    case 0x10003000:
453
        s->rv10_version= 3;
454
        s->h263_long_vectors=1;
455
        s->low_delay=1;
456
        break;
457
    case 0x10003001:
458
        s->rv10_version= 3;
459
        s->h263_long_vectors=0;
460
        s->low_delay=1;
461
        break;
462
    case 0x20001000:
463
    case 0x20100001:
464
    case 0x20101001:
465
        s->low_delay=1;
466
        break;
467
    case 0x20200002:
468
    case 0x30202002:
469
    case 0x30203002:
470
        s->low_delay=0;
471
        s->avctx->has_b_frames=1;
472
        break;
473
    default:
474
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
475
    }
476
//printf("ver:%X\n", avctx->sub_id);
477
    s->flags= avctx->flags;
478

    
479
    if (MPV_common_init(s) < 0)
480
        return -1;
481

    
482
    h263_decode_init_vlc(s);
483

    
484
    s->progressive_sequence=1;
485

    
486
    /* init rv vlc */
487
    if (!done) {
488
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
489
                 rv_lum_bits, 1, 1,
490
                 rv_lum_code, 2, 2);
491
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
492
                 rv_chrom_bits, 1, 1,
493
                 rv_chrom_code, 2, 2);
494
        done = 1;
495
    }
496
    
497
    avctx->pix_fmt = PIX_FMT_YUV420P;
498

    
499
    return 0;
500
}
501

    
502
static int rv10_decode_end(AVCodecContext *avctx)
503
{
504
    MpegEncContext *s = avctx->priv_data;
505

    
506
    MPV_common_end(s);
507
    return 0;
508
}
509

    
510
static int rv10_decode_packet(AVCodecContext *avctx, 
511
                             uint8_t *buf, int buf_size)
512
{
513
    MpegEncContext *s = avctx->priv_data;
514
    int i, mb_count, mb_pos, left;
515

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

    
545
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
546
        if(MPV_frame_start(s, avctx) < 0)
547
            return -1;
548
    }
549

    
550
#ifdef DEBUG
551
    printf("qscale=%d\n", s->qscale);
552
#endif
553

    
554
    /* default quantization values */
555
    if(s->codec_id== CODEC_ID_RV10){
556
        if(s->mb_y==0) s->first_slice_line=1;
557
    }else{
558
        s->first_slice_line=1;    
559
        s->resync_mb_x= s->mb_x;
560
        s->resync_mb_y= s->mb_y;
561
    }
562
    if(s->h263_aic){
563
        s->y_dc_scale_table= 
564
        s->c_dc_scale_table= ff_aic_dc_scale_table;
565
    }else{
566
        s->y_dc_scale_table=
567
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
568
    }
569

    
570
    if(s->modified_quant)
571
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
572
        
573
    ff_set_qscale(s, s->qscale);
574

    
575
    s->rv10_first_dc_coded[0] = 0;
576
    s->rv10_first_dc_coded[1] = 0;
577
    s->rv10_first_dc_coded[2] = 0;
578

    
579
    s->block_wrap[0]=
580
    s->block_wrap[1]=
581
    s->block_wrap[2]=
582
    s->block_wrap[3]= s->mb_width*2 + 2;
583
    s->block_wrap[4]=
584
    s->block_wrap[5]= s->mb_width + 2;
585
    ff_init_block_index(s);
586
    /* decode each macroblock */
587
    for(i=0;i<mb_count;i++) {
588
        int ret;
589
        ff_update_block_index(s);
590
#ifdef DEBUG
591
        printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
592
#endif
593
        
594
        s->dsp.clear_blocks(s->block[0]);
595
        s->mv_dir = MV_DIR_FORWARD;
596
        s->mv_type = MV_TYPE_16X16; 
597
        ret=ff_h263_decode_mb(s, s->block);
598

    
599
        if (ret == SLICE_ERROR) {
600
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
601
            return -1;
602
        }
603
        ff_h263_update_motion_val(s);
604
        MPV_decode_mb(s, s->block);
605
        if(s->loop_filter)
606
            ff_h263_loop_filter(s);
607

    
608
        if (++s->mb_x == s->mb_width) {
609
            s->mb_x = 0;
610
            s->mb_y++;
611
            ff_init_block_index(s);
612
        }
613
        if(s->mb_x == s->resync_mb_x)
614
            s->first_slice_line=0;
615
        if(ret == SLICE_END) break;
616
    }
617

    
618
    return buf_size;
619
}
620

    
621
static int rv10_decode_frame(AVCodecContext *avctx, 
622
                             void *data, int *data_size,
623
                             uint8_t *buf, int buf_size)
624
{
625
    MpegEncContext *s = avctx->priv_data;
626
    int i;
627
    AVFrame *pict = data; 
628

    
629
#ifdef DEBUG
630
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
631
#endif
632

    
633
    /* no supplementary picture */
634
    if (buf_size == 0) {
635
        *data_size = 0;
636
        return 0;
637
    }
638
    
639
    if(avctx->slice_count){
640
        for(i=0; i<avctx->slice_count; i++){
641
            int offset= avctx->slice_offset[i];
642
            int size;
643
            
644
            if(i+1 == avctx->slice_count)
645
                size= buf_size - offset;
646
            else
647
                size= avctx->slice_offset[i+1] - offset;
648

    
649
            if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
650
                return -1;
651
        }
652
    }else{
653
        if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
654
            return -1;
655
    }
656
    
657
    if(s->pict_type == B_TYPE){ //FIXME remove after cleaning mottion_val indexing
658
        memset(s->current_picture.motion_val[0], 0, sizeof(int16_t)*2*(s->mb_width*2+2)*(s->mb_height*2+2));
659
    }
660

    
661
    if(s->mb_y>=s->mb_height){
662
        MPV_frame_end(s);
663
    
664
        if(s->pict_type==B_TYPE || s->low_delay){
665
            *pict= *(AVFrame*)&s->current_picture;
666
            ff_print_debug_info(s, pict);
667
        } else {
668
            *pict= *(AVFrame*)&s->last_picture;
669
            ff_print_debug_info(s, pict);
670
        }
671
        
672
        *data_size = sizeof(AVFrame);
673
    }else{
674
        *data_size = 0;
675
    }
676

    
677
    return buf_size;
678
}
679

    
680
AVCodec rv10_decoder = {
681
    "rv10",
682
    CODEC_TYPE_VIDEO,
683
    CODEC_ID_RV10,
684
    sizeof(MpegEncContext),
685
    rv10_decode_init,
686
    NULL,
687
    rv10_decode_end,
688
    rv10_decode_frame,
689
    CODEC_CAP_DR1
690
};
691

    
692
AVCodec rv20_decoder = {
693
    "rv20",
694
    CODEC_TYPE_VIDEO,
695
    CODEC_ID_RV20,
696
    sizeof(MpegEncContext),
697
    rv10_decode_init,
698
    NULL,
699
    rv10_decode_end,
700
    rv10_decode_frame,
701
    CODEC_CAP_DR1
702
};
703