Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ dfd2a005

History | View | Annotate | Download (24.1 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
25
 * RV10/RV20 decoder
26
 */
27

    
28
#include "libavcore/imgutils.h"
29
#include "avcodec.h"
30
#include "dsputil.h"
31
#include "mpegvideo.h"
32
#include "mpeg4video.h"
33
#include "h263.h"
34

    
35
//#define DEBUG
36

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

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

    
75
static const uint8_t rv_lum_bits[256] =
76
{
77
 14, 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, 12, 12, 12, 12, 12, 12, 12,
85
 12, 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, 10, 10, 10, 10, 10, 10, 10,
89
 10,  8,  8,  8,  8,  8,  8,  8,
90
  8,  8,  8,  8,  8,  8,  8,  8,
91
  8,  7,  7,  7,  7,  7,  7,  7,
92
  7,  6,  6,  6,  6,  5,  5,  4,
93
  2,  4,  5,  5,  6,  6,  6,  6,
94
  7,  7,  7,  7,  7,  7,  7,  7,
95
  8,  8,  8,  8,  8,  8,  8,  8,
96
  8,  8,  8,  8,  8,  8,  8,  8,
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
 10, 10, 10, 10, 10, 10, 10, 10,
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
 12, 12, 12, 12, 12, 12, 12, 12,
109
};
110

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

    
147
static const uint8_t rv_chrom_bits[256] =
148
{
149
 16, 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, 14, 14, 14, 14, 14, 14, 14,
157
 14, 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, 12, 12, 12, 12, 12, 12, 12,
161
 12, 10, 10, 10, 10, 10, 10, 10,
162
 10, 10, 10, 10, 10, 10, 10, 10,
163
 10,  8,  8,  8,  8,  8,  8,  8,
164
  8,  6,  6,  6,  6,  4,  4,  3,
165
  2,  3,  4,  4,  6,  6,  6,  6,
166
  8,  8,  8,  8,  8,  8,  8,  8,
167
 10, 10, 10, 10, 10, 10, 10, 10,
168
 10, 10, 10, 10, 10, 10, 10, 10,
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
 12, 12, 12, 12, 12, 12, 12, 12,
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
 14, 14, 14, 14, 14, 14, 14, 14,
181
};
182

    
183
static VLC rv_dc_lum, rv_dc_chrom;
184

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

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

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

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

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

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

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

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

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

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

    
289
    return mb_count;
290
}
291

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
453
    MPV_decode_defaults(s);
454

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

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

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

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

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

    
496
    avctx->pix_fmt = PIX_FMT_YUV420P;
497

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

    
501
    h263_decode_init_vlc(s);
502

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

    
514
    return 0;
515
}
516

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
707
    return buf_size;
708
}
709

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

    
725
AVCodec ff_rv20_decoder = {
726
    "rv20",
727
    AVMEDIA_TYPE_VIDEO,
728
    CODEC_ID_RV20,
729
    sizeof(MpegEncContext),
730
    rv10_decode_init,
731
    NULL,
732
    rv10_decode_end,
733
    rv10_decode_frame,
734
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
735
    .flush= ff_mpeg_flush,
736
    .max_lowres = 3,
737
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
738
    .pix_fmts= ff_pixfmt_list_420,
739
};