Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 688621d7

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
#include "mpeg4video.h"
32
#include "h263.h"
33

    
34
//#define DEBUG
35

    
36
#define DC_VLC_BITS 14 //FIXME find a better solution
37

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

    
74
static const uint8_t rv_lum_bits[256] =
75
{
76
 14, 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, 12, 12, 12, 12, 12, 12, 12,
83
 12, 12, 12, 12, 12, 12, 12, 12,
84
 12, 10, 10, 10, 10, 10, 10, 10,
85
 10, 10, 10, 10, 10, 10, 10, 10,
86
 10, 10, 10, 10, 10, 10, 10, 10,
87
 10, 10, 10, 10, 10, 10, 10, 10,
88
 10,  8,  8,  8,  8,  8,  8,  8,
89
  8,  8,  8,  8,  8,  8,  8,  8,
90
  8,  7,  7,  7,  7,  7,  7,  7,
91
  7,  6,  6,  6,  6,  5,  5,  4,
92
  2,  4,  5,  5,  6,  6,  6,  6,
93
  7,  7,  7,  7,  7,  7,  7,  7,
94
  8,  8,  8,  8,  8,  8,  8,  8,
95
  8,  8,  8,  8,  8,  8,  8,  8,
96
 10, 10, 10, 10, 10, 10, 10, 10,
97
 10, 10, 10, 10, 10, 10, 10, 10,
98
 10, 10, 10, 10, 10, 10, 10, 10,
99
 10, 10, 10, 10, 10, 10, 10, 10,
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
 12, 12, 12, 12, 12, 12, 12, 12,
107
 12, 12, 12, 12, 12, 12, 12, 12,
108
};
109

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

    
146
static const uint8_t rv_chrom_bits[256] =
147
{
148
 16, 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, 14, 14, 14, 14, 14, 14, 14,
155
 14, 14, 14, 14, 14, 14, 14, 14,
156
 14, 12, 12, 12, 12, 12, 12, 12,
157
 12, 12, 12, 12, 12, 12, 12, 12,
158
 12, 12, 12, 12, 12, 12, 12, 12,
159
 12, 12, 12, 12, 12, 12, 12, 12,
160
 12, 10, 10, 10, 10, 10, 10, 10,
161
 10, 10, 10, 10, 10, 10, 10, 10,
162
 10,  8,  8,  8,  8,  8,  8,  8,
163
  8,  6,  6,  6,  6,  4,  4,  3,
164
  2,  3,  4,  4,  6,  6,  6,  6,
165
  8,  8,  8,  8,  8,  8,  8,  8,
166
 10, 10, 10, 10, 10, 10, 10, 10,
167
 10, 10, 10, 10, 10, 10, 10, 10,
168
 12, 12, 12, 12, 12, 12, 12, 12,
169
 12, 12, 12, 12, 12, 12, 12, 12,
170
 12, 12, 12, 12, 12, 12, 12, 12,
171
 12, 12, 12, 12, 12, 12, 12, 12,
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
 14, 14, 14, 14, 14, 14, 14, 14,
179
 14, 14, 14, 14, 14, 14, 14, 14,
180
};
181

    
182
static VLC rv_dc_lum, rv_dc_chrom;
183

    
184
int rv_decode_dc(MpegEncContext *s, int n)
185
{
186
    int code;
187

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

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

    
239
    marker = get_bits1(&s->gb);
240

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

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

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

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

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

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

    
288
    return mb_count;
289
}
290

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

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

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

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

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

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

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

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

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

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

    
363
        if(f){
364
            new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
365
            new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
366
        }else{
367
            new_w= s->orig_width ;
368
            new_h= s->orig_height;
369
        }
370
        if(new_w != s->width || new_h != s->height){
371
            av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
372
            if (avcodec_check_dimensions(s->avctx, new_w, new_h) < 0)
373
                return -1;
374
            MPV_common_end(s);
375
            avcodec_set_dimensions(s->avctx, new_w, new_h);
376
            s->width  = new_w;
377
            s->height = new_h;
378
            if (MPV_common_init(s) < 0)
379
                return -1;
380
        }
381

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

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

    
422
    s->f_code = 1;
423
    s->unrestricted_mv = 1;
424
    s->h263_aic= s->pict_type == FF_I_TYPE;
425
//    s->alt_inter_vlc=1;
426
//    s->obmc=1;
427
//    s->umvplus=1;
428
    s->modified_quant=1;
429
    if(!s->avctx->lowres)
430
        s->loop_filter=1;
431

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

    
437
    assert(s->pict_type != FF_B_TYPE || !s->low_delay);
438

    
439
    return s->mb_width*s->mb_height - mb_pos;
440
}
441

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

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

    
452
    MPV_decode_defaults(s);
453

    
454
    s->avctx= avctx;
455
    s->out_format = FMT_H263;
456
    s->codec_id= avctx->codec_id;
457

    
458
    s->orig_width = s->width  = avctx->coded_width;
459
    s->orig_height= s->height = avctx->coded_height;
460

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

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

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

    
495
    avctx->pix_fmt = PIX_FMT_YUV420P;
496

    
497
    if (MPV_common_init(s) < 0)
498
        return -1;
499

    
500
    h263_decode_init_vlc(s);
501

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

    
513
    return 0;
514
}
515

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

    
520
    MPV_common_end(s);
521
    return 0;
522
}
523

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

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

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

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

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

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

    
582
    if(s->modified_quant)
583
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
584

    
585
    ff_set_qscale(s, s->qscale);
586

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

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

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

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

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

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

    
634
    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);
635

    
636
    return s->gb.size_in_bits;
637
}
638

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

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

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

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

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

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

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

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

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

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

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

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

    
706
    return buf_size;
707
}
708

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

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