Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ e7e578b7

History | View | Annotate | Download (24 KB)

1
/*
2
 * RV10/RV20 decoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard
4
 * Copyright (c) 2002-2004 Michael Niedermayer
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22

    
23
/**
24
 * @file libavcodec/rv10.c
25
 * RV10/RV20 decoder
26
 */
27

    
28
#include "avcodec.h"
29
#include "dsputil.h"
30
#include "mpegvideo.h"
31

    
32
//#define DEBUG
33

    
34
#define DC_VLC_BITS 14 //FIXME find a better solution
35

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

    
72
static const uint8_t rv_lum_bits[256] =
73
{
74
 14, 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, 12, 12, 12, 12, 12, 12, 12,
81
 12, 12, 12, 12, 12, 12, 12, 12,
82
 12, 10, 10, 10, 10, 10, 10, 10,
83
 10, 10, 10, 10, 10, 10, 10, 10,
84
 10, 10, 10, 10, 10, 10, 10, 10,
85
 10, 10, 10, 10, 10, 10, 10, 10,
86
 10,  8,  8,  8,  8,  8,  8,  8,
87
  8,  8,  8,  8,  8,  8,  8,  8,
88
  8,  7,  7,  7,  7,  7,  7,  7,
89
  7,  6,  6,  6,  6,  5,  5,  4,
90
  2,  4,  5,  5,  6,  6,  6,  6,
91
  7,  7,  7,  7,  7,  7,  7,  7,
92
  8,  8,  8,  8,  8,  8,  8,  8,
93
  8,  8,  8,  8,  8,  8,  8,  8,
94
 10, 10, 10, 10, 10, 10, 10, 10,
95
 10, 10, 10, 10, 10, 10, 10, 10,
96
 10, 10, 10, 10, 10, 10, 10, 10,
97
 10, 10, 10, 10, 10, 10, 10, 10,
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
 12, 12, 12, 12, 12, 12, 12, 12,
105
 12, 12, 12, 12, 12, 12, 12, 12,
106
};
107

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

    
144
static const uint8_t rv_chrom_bits[256] =
145
{
146
 16, 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, 14, 14, 14, 14, 14, 14, 14,
153
 14, 14, 14, 14, 14, 14, 14, 14,
154
 14, 12, 12, 12, 12, 12, 12, 12,
155
 12, 12, 12, 12, 12, 12, 12, 12,
156
 12, 12, 12, 12, 12, 12, 12, 12,
157
 12, 12, 12, 12, 12, 12, 12, 12,
158
 12, 10, 10, 10, 10, 10, 10, 10,
159
 10, 10, 10, 10, 10, 10, 10, 10,
160
 10,  8,  8,  8,  8,  8,  8,  8,
161
  8,  6,  6,  6,  6,  4,  4,  3,
162
  2,  3,  4,  4,  6,  6,  6,  6,
163
  8,  8,  8,  8,  8,  8,  8,  8,
164
 10, 10, 10, 10, 10, 10, 10, 10,
165
 10, 10, 10, 10, 10, 10, 10, 10,
166
 12, 12, 12, 12, 12, 12, 12, 12,
167
 12, 12, 12, 12, 12, 12, 12, 12,
168
 12, 12, 12, 12, 12, 12, 12, 12,
169
 12, 12, 12, 12, 12, 12, 12, 12,
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
 14, 14, 14, 14, 14, 14, 14, 14,
177
 14, 14, 14, 14, 14, 14, 14, 14,
178
};
179

    
180
static VLC rv_dc_lum, rv_dc_chrom;
181

    
182
int rv_decode_dc(MpegEncContext *s, int n)
183
{
184
    int code;
185

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

    
232
/* read RV 1.0 compatible frame header */
233
static int rv10_decode_picture_header(MpegEncContext *s)
234
{
235
    int mb_count, pb_frame, marker, unk, mb_xy;
236

    
237
    marker = get_bits1(&s->gb);
238

    
239
    if (get_bits1(&s->gb))
240
        s->pict_type = FF_P_TYPE;
241
    else
242
        s->pict_type = FF_I_TYPE;
243
    if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
244
    pb_frame = get_bits1(&s->gb);
245

    
246
    dprintf(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
247

    
248
    if (pb_frame){
249
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
250
        return -1;
251
    }
252

    
253
    s->qscale = get_bits(&s->gb, 5);
254
    if(s->qscale==0){
255
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
256
        return -1;
257
    }
258

    
259
    if (s->pict_type == FF_I_TYPE) {
260
        if (s->rv10_version == 3) {
261
            /* specific MPEG like DC coding not used */
262
            s->last_dc[0] = get_bits(&s->gb, 8);
263
            s->last_dc[1] = get_bits(&s->gb, 8);
264
            s->last_dc[2] = get_bits(&s->gb, 8);
265
            dprintf(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
266
                    s->last_dc[1], s->last_dc[2]);
267
        }
268
    }
269
    /* if multiple packets per frame are sent, the position at which
270
       to display the macroblocks is coded here */
271

    
272
    mb_xy= s->mb_x + s->mb_y*s->mb_width;
273
    if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
274
        s->mb_x = get_bits(&s->gb, 6); /* mb_x */
275
        s->mb_y = get_bits(&s->gb, 6); /* mb_y */
276
        mb_count = get_bits(&s->gb, 12);
277
    } else {
278
        s->mb_x = 0;
279
        s->mb_y = 0;
280
        mb_count = s->mb_width * s->mb_height;
281
    }
282
    unk= get_bits(&s->gb, 3);   /* ignored */
283
    s->f_code = 1;
284
    s->unrestricted_mv = 1;
285

    
286
    return mb_count;
287
}
288

    
289
static int rv20_decode_picture_header(MpegEncContext *s)
290
{
291
    int seq, mb_pos, i;
292

    
293
#if 0
294
    GetBitContext gb= s->gb;
295
    for(i=0; i<64; i++){
296
        av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
297
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
298
    }
299
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
300
#endif
301
#if 0
302
    av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
303
    for(i=0; i<s->avctx->extradata_size; i++){
304
        av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
305
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
306
    }
307
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
308
#endif
309

    
310
    if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
311
        if (get_bits(&s->gb, 3)){
312
            av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
313
            return -1;
314
        }
315
    }
316

    
317
    i= get_bits(&s->gb, 2);
318
    switch(i){
319
    case 0: s->pict_type= FF_I_TYPE; break;
320
    case 1: s->pict_type= FF_I_TYPE; break; //hmm ...
321
    case 2: s->pict_type= FF_P_TYPE; break;
322
    case 3: s->pict_type= FF_B_TYPE; break;
323
    default:
324
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
325
        return -1;
326
    }
327

    
328
    if(s->last_picture_ptr==NULL && s->pict_type==FF_B_TYPE){
329
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
330
        return -1;
331
    }
332

    
333
    if (get_bits1(&s->gb)){
334
        av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
335
        return -1;
336
    }
337

    
338
    s->qscale = get_bits(&s->gb, 5);
339
    if(s->qscale==0){
340
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
341
        return -1;
342
    }
343
    if(s->avctx->sub_id == 0x30203002){
344
        if (get_bits1(&s->gb)){
345
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
346
            return -1;
347
        }
348
    }
349

    
350
    if(s->avctx->has_b_frames){
351
        int f, new_w, new_h;
352
        int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
353

    
354
        if (get_bits1(&s->gb)){
355
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
356
        }
357
        seq= get_bits(&s->gb, 13)<<2;
358

    
359
        f= get_bits(&s->gb, av_log2(v)+1);
360

    
361
        if(f){
362
            new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
363
            new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
364
        }else{
365
            new_w= s->width; //FIXME wrong we of course must save the original in the context
366
            new_h= s->height;
367
        }
368
        if(new_w != s->width || new_h != s->height){
369
            av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
370
            if (avcodec_check_dimensions(s->avctx, new_w, new_h) < 0)
371
                return -1;
372
            MPV_common_end(s);
373
            avcodec_set_dimensions(s->avctx, new_w, new_h);
374
            s->width  = new_w;
375
            s->height = new_h;
376
            if (MPV_common_init(s) < 0)
377
                return -1;
378
        }
379

    
380
        if(s->avctx->debug & FF_DEBUG_PICT_INFO){
381
            av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
382
        }
383
    }else{
384
        seq= get_bits(&s->gb, 8)*128;
385
    }
386

    
387
//     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
388
    mb_pos= ff_h263_decode_mba(s);
389
/*    }else{
390
        mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
391
        s->mb_x= mb_pos % s->mb_width;
392
        s->mb_y= mb_pos / s->mb_width;
393
    }*/
394
//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
395
    seq |= s->time &~0x7FFF;
396
    if(seq - s->time >  0x4000) seq -= 0x8000;
397
    if(seq - s->time < -0x4000) seq += 0x8000;
398
    if(seq != s->time){
399
        if(s->pict_type!=FF_B_TYPE){
400
            s->time= seq;
401
            s->pp_time= s->time - s->last_non_b_time;
402
            s->last_non_b_time= s->time;
403
        }else{
404
            s->time= seq;
405
            s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
406
            if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
407
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
408
                return FRAME_SKIPPED;
409
            }
410
            ff_mpeg4_init_direct_mv(s);
411
        }
412
    }
413
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
414
/*for(i=0; i<32; i++){
415
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
416
}
417
av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
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 == FF_I_TYPE;
423
//    s->alt_inter_vlc=1;
424
//    s->obmc=1;
425
//    s->umvplus=1;
426
    s->modified_quant=1;
427
    if(!s->avctx->lowres)
428
        s->loop_filter=1;
429

    
430
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
431
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
432
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
433
    }
434

    
435
    assert(s->pict_type != FF_B_TYPE || !s->low_delay);
436

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

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

    
445
    if (avctx->extradata_size < 8) {
446
        av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
447
        return -1;
448
    }
449

    
450
    MPV_decode_defaults(s);
451

    
452
    s->avctx= avctx;
453
    s->out_format = FMT_H263;
454
    s->codec_id= avctx->codec_id;
455

    
456
    s->width = avctx->coded_width;
457
    s->height = avctx->coded_height;
458

    
459
    s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
460
    avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
461

    
462
    if (avctx->sub_id == 0x10000000) {
463
        s->rv10_version= 0;
464
        s->low_delay=1;
465
    } else if (avctx->sub_id == 0x10001000) {
466
        s->rv10_version= 3;
467
        s->low_delay=1;
468
    } else if (avctx->sub_id == 0x10002000) {
469
        s->rv10_version= 3;
470
        s->low_delay=1;
471
        s->obmc=1;
472
    } else if (avctx->sub_id == 0x10003000) {
473
        s->rv10_version= 3;
474
        s->low_delay=1;
475
    } else if (avctx->sub_id == 0x10003001) {
476
        s->rv10_version= 3;
477
        s->low_delay=1;
478
    } else if (    avctx->sub_id == 0x20001000
479
               || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
480
        s->low_delay=1;
481
    } else if (    avctx->sub_id == 0x30202002
482
               ||  avctx->sub_id == 0x30203002
483
               || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
484
        s->low_delay=0;
485
        s->avctx->has_b_frames=1;
486
    } else
487
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
488

    
489
    if(avctx->debug & FF_DEBUG_PICT_INFO){
490
        av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
491
    }
492

    
493
    avctx->pix_fmt = PIX_FMT_YUV420P;
494

    
495
    if (MPV_common_init(s) < 0)
496
        return -1;
497

    
498
    h263_decode_init_vlc(s);
499

    
500
    /* init rv vlc */
501
    if (!done) {
502
        INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
503
                 rv_lum_bits, 1, 1,
504
                 rv_lum_code, 2, 2, 16384);
505
        INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
506
                 rv_chrom_bits, 1, 1,
507
                 rv_chrom_code, 2, 2, 16388);
508
        done = 1;
509
    }
510

    
511
    return 0;
512
}
513

    
514
static av_cold int rv10_decode_end(AVCodecContext *avctx)
515
{
516
    MpegEncContext *s = avctx->priv_data;
517

    
518
    MPV_common_end(s);
519
    return 0;
520
}
521

    
522
static int rv10_decode_packet(AVCodecContext *avctx,
523
                             const uint8_t *buf, int buf_size, int buf_size2)
524
{
525
    MpegEncContext *s = avctx->priv_data;
526
    int mb_count, mb_pos, left, start_mb_x;
527

    
528
    init_get_bits(&s->gb, buf, buf_size*8);
529
    if(s->codec_id ==CODEC_ID_RV10)
530
        mb_count = rv10_decode_picture_header(s);
531
    else
532
        mb_count = rv20_decode_picture_header(s);
533
    if (mb_count < 0) {
534
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
535
        return -1;
536
    }
537

    
538
    if (s->mb_x >= s->mb_width ||
539
        s->mb_y >= s->mb_height) {
540
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
541
        return -1;
542
    }
543
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
544
    left = s->mb_width * s->mb_height - mb_pos;
545
    if (mb_count > left) {
546
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
547
        return -1;
548
    }
549

    
550
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
551
        if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
552
            ff_er_frame_end(s);
553
            MPV_frame_end(s);
554
            s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
555
        }
556
        if(MPV_frame_start(s, avctx) < 0)
557
            return -1;
558
        ff_er_frame_start(s);
559
    }
560

    
561
    dprintf(avctx, "qscale=%d\n", s->qscale);
562

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

    
580
    if(s->modified_quant)
581
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
582

    
583
    ff_set_qscale(s, s->qscale);
584

    
585
    s->rv10_first_dc_coded[0] = 0;
586
    s->rv10_first_dc_coded[1] = 0;
587
    s->rv10_first_dc_coded[2] = 0;
588
    s->block_wrap[0]=
589
    s->block_wrap[1]=
590
    s->block_wrap[2]=
591
    s->block_wrap[3]= s->b8_stride;
592
    s->block_wrap[4]=
593
    s->block_wrap[5]= s->mb_stride;
594
    ff_init_block_index(s);
595
    /* decode each macroblock */
596

    
597
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
598
        int ret;
599
        ff_update_block_index(s);
600
        dprintf(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
601

    
602
        s->mv_dir = MV_DIR_FORWARD;
603
        s->mv_type = MV_TYPE_16X16;
604
        ret=ff_h263_decode_mb(s, s->block);
605

    
606
        if (ret != SLICE_ERROR && s->gb.size_in_bits < get_bits_count(&s->gb) && 8*buf_size2 >= get_bits_count(&s->gb)){
607
            av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n", s->gb.size_in_bits, 8*buf_size2);
608
            s->gb.size_in_bits= 8*buf_size2;
609
            ret= SLICE_OK;
610
        }
611

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

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

    
632
    ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
633

    
634
    return s->gb.size_in_bits;
635
}
636

    
637
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
638
{
639
    if(avctx->slice_count) return avctx->slice_offset[n];
640
    else                   return AV_RL32(buf + n*8);
641
}
642

    
643
static int rv10_decode_frame(AVCodecContext *avctx,
644
                             void *data, int *data_size,
645
                             AVPacket *avpkt)
646
{
647
    const uint8_t *buf = avpkt->data;
648
    int buf_size = avpkt->size;
649
    MpegEncContext *s = avctx->priv_data;
650
    int i;
651
    AVFrame *pict = data;
652
    int slice_count;
653
    const uint8_t *slices_hdr = NULL;
654

    
655
    dprintf(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
656

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

    
662
    if(!avctx->slice_count){
663
        slice_count = (*buf++) + 1;
664
        slices_hdr = buf + 4;
665
        buf += 8 * slice_count;
666
    }else
667
        slice_count = avctx->slice_count;
668

    
669
    for(i=0; i<slice_count; i++){
670
        int offset= get_slice_offset(avctx, slices_hdr, i);
671
        int size, size2;
672

    
673
        if(i+1 == slice_count)
674
            size= buf_size - offset;
675
        else
676
            size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
677

    
678
        if(i+2 >= slice_count)
679
            size2= buf_size - offset;
680
        else
681
            size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
682

    
683
        if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
684
            i++;
685
    }
686

    
687
    if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
688
        ff_er_frame_end(s);
689
        MPV_frame_end(s);
690

    
691
        if (s->pict_type == FF_B_TYPE || s->low_delay) {
692
            *pict= *(AVFrame*)s->current_picture_ptr;
693
        } else if (s->last_picture_ptr != NULL) {
694
            *pict= *(AVFrame*)s->last_picture_ptr;
695
        }
696

    
697
        if(s->last_picture_ptr || s->low_delay){
698
            *data_size = sizeof(AVFrame);
699
            ff_print_debug_info(s, pict);
700
        }
701
        s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
702
    }
703

    
704
    return buf_size;
705
}
706

    
707
AVCodec rv10_decoder = {
708
    "rv10",
709
    CODEC_TYPE_VIDEO,
710
    CODEC_ID_RV10,
711
    sizeof(MpegEncContext),
712
    rv10_decode_init,
713
    NULL,
714
    rv10_decode_end,
715
    rv10_decode_frame,
716
    CODEC_CAP_DR1,
717
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
718
    .pix_fmts= ff_pixfmt_list_420,
719
};
720

    
721
AVCodec rv20_decoder = {
722
    "rv20",
723
    CODEC_TYPE_VIDEO,
724
    CODEC_ID_RV20,
725
    sizeof(MpegEncContext),
726
    rv10_decode_init,
727
    NULL,
728
    rv10_decode_end,
729
    rv10_decode_frame,
730
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
731
    .flush= ff_mpeg_flush,
732
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
733
    .pix_fmts= ff_pixfmt_list_420,
734
};