Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ b846b231

History | View | Annotate | Download (21.1 KB)

1
/*
2
 * RV10 codec
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19

    
20
/**
21
 * @file rv10.c
22
 * RV10 codec.
23
 */
24
 
25
#include "avcodec.h"
26
#include "dsputil.h"
27
#include "mpegvideo.h"
28

    
29
//#define DEBUG
30

    
31
#define DC_VLC_BITS 14 //FIXME find a better solution
32

    
33
static const uint16_t rv_lum_code[256] =
34
{
35
 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
36
 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
37
 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
38
 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
39
 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
40
 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
41
 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
42
 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
43
 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
44
 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
45
 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
46
 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
47
 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
48
 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
49
 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
50
 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
51
 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
52
 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
53
 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
54
 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
55
 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
56
 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
57
 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
58
 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
59
 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
60
 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
61
 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
62
 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
63
 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
64
 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
65
 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
66
 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
67
};
68

    
69
static const uint8_t rv_lum_bits[256] = 
70
{
71
 14, 12, 12, 12, 12, 12, 12, 12,
72
 12, 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, 10, 10, 10, 10, 10, 10, 10,
80
 10, 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,  8,  8,  8,  8,  8,  8,  8,
84
  8,  8,  8,  8,  8,  8,  8,  8,
85
  8,  7,  7,  7,  7,  7,  7,  7,
86
  7,  6,  6,  6,  6,  5,  5,  4,
87
  2,  4,  5,  5,  6,  6,  6,  6,
88
  7,  7,  7,  7,  7,  7,  7,  7,
89
  8,  8,  8,  8,  8,  8,  8,  8,
90
  8,  8,  8,  8,  8,  8,  8,  8,
91
 10, 10, 10, 10, 10, 10, 10, 10,
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
 12, 12, 12, 12, 12, 12, 12, 12,
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
};
104

    
105
static const uint16_t rv_chrom_code[256] =
106
{
107
 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
108
 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
109
 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
110
 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
111
 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
112
 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
113
 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
114
 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
115
 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
116
 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
117
 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
118
 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
119
 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
120
 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
121
 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
122
 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
123
 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
124
 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
125
 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
126
 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
127
 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
128
 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
129
 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
130
 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
131
 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
132
 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
133
 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
134
 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
135
 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
136
 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
137
 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
138
 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
139
};
140

    
141
static const uint8_t rv_chrom_bits[256] =
142
{
143
 16, 14, 14, 14, 14, 14, 14, 14,
144
 14, 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, 12, 12, 12, 12, 12, 12, 12,
152
 12, 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, 10, 10, 10, 10, 10, 10, 10,
156
 10, 10, 10, 10, 10, 10, 10, 10,
157
 10,  8,  8,  8,  8,  8,  8,  8,
158
  8,  6,  6,  6,  6,  4,  4,  3,
159
  2,  3,  4,  4,  6,  6,  6,  6,
160
  8,  8,  8,  8,  8,  8,  8,  8,
161
 10, 10, 10, 10, 10, 10, 10, 10,
162
 10, 10, 10, 10, 10, 10, 10, 10,
163
 12, 12, 12, 12, 12, 12, 12, 12,
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
 14, 14, 14, 14, 14, 14, 14, 14,
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
};
176

    
177
static VLC rv_dc_lum, rv_dc_chrom;
178

    
179
int rv_decode_dc(MpegEncContext *s, int n)
180
{
181
    int code;
182

    
183
    if (n < 4) {
184
        code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
185
        if (code < 0) {
186
            /* XXX: I don't understand why they use LONGER codes than
187
               necessary. The following code would be completely useless
188
               if they had thought about it !!! */
189
            code = get_bits(&s->gb, 7);
190
            if (code == 0x7c) {
191
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
192
            } else if (code == 0x7d) {
193
                code = -128 + get_bits(&s->gb, 7);
194
            } else if (code == 0x7e) {
195
                if (get_bits(&s->gb, 1) == 0)
196
                    code = (int8_t)(get_bits(&s->gb, 8) + 1);
197
                else
198
                    code = (int8_t)(get_bits(&s->gb, 8));
199
            } else if (code == 0x7f) {
200
                get_bits(&s->gb, 11);
201
                code = 1;
202
            }
203
        } else {
204
            code -= 128;
205
        }
206
    } else {
207
        code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
208
        /* same remark */
209
        if (code < 0) {
210
            code = get_bits(&s->gb, 9);
211
            if (code == 0x1fc) {
212
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
213
            } else if (code == 0x1fd) {
214
                code = -128 + get_bits(&s->gb, 7);
215
            } else if (code == 0x1fe) {
216
                get_bits(&s->gb, 9);
217
                code = 1;
218
            } else {
219
                av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
220
                return 0xffff;
221
            }
222
        } else {
223
            code -= 128;
224
        }
225
    }
226
    return -code;
227
}
228

    
229
#ifdef CONFIG_ENCODERS
230

    
231
/* write RV 1.0 compatible frame header */
232
void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
233
{
234
    int full_frame= 0;
235

    
236
    align_put_bits(&s->pb);
237
    
238
    put_bits(&s->pb, 1, 1);        /* marker */
239

    
240
    put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
241

    
242
    put_bits(&s->pb, 1, 0);        /* not PB frame */
243

    
244
    put_bits(&s->pb, 5, s->qscale);
245

    
246
    if (s->pict_type == I_TYPE) {
247
        /* specific MPEG like DC coding not used */
248
    }
249
    /* if multiple packets per frame are sent, the position at which
250
       to display the macro blocks is coded here */
251
    if(!full_frame){
252
        put_bits(&s->pb, 6, 0);        /* mb_x */
253
        put_bits(&s->pb, 6, 0);        /* mb_y */
254
        put_bits(&s->pb, 12, s->mb_width * s->mb_height);
255
    }
256

    
257
    put_bits(&s->pb, 3, 0);        /* ignored */
258
}
259

    
260
static int get_num(GetBitContext *gb)
261
{
262
    int n, n1;
263

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

    
273
#endif //CONFIG_ENCODERS
274

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

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

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

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

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

    
337
    return mb_count;
338
}
339

    
340
static int rv20_decode_picture_header(MpegEncContext *s)
341
{
342
    int seq, mb_pos, i;
343
    
344
    if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
345
        if (get_bits(&s->gb, 3)){
346
            av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
347
            return -1;
348
        } 
349
    }   
350

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

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

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

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

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

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

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

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

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

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

    
481
    h263_decode_init_vlc(s);
482

    
483
    s->progressive_sequence=1;
484

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

    
498
    return 0;
499
}
500

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

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

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

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

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

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

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

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

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

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

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

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

    
617
    return buf_size;
618
}
619

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

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

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

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

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

    
676
    return buf_size;
677
}
678

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

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