rv10.c 27 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1
/*
2
 * RV10/RV20 decoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard
4
 * Copyright (c) 2002-2004 Michael Niedermayer
Fabrice Bellard's avatar
Fabrice Bellard committed
5
 *
6 7 8
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
9 10
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
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
Fabrice Bellard's avatar
Fabrice Bellard committed
21
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
22 23

/**
24
 * @file
25
 * RV10/RV20 decoder
Michael Niedermayer's avatar
Michael Niedermayer committed
26
 */
27

28
#include "libavutil/imgutils.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
29
#include "avcodec.h"
30
#include "error_resilience.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
31
#include "mpegvideo.h"
32
#include "mpeg4video.h"
33
#include "h263.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
34

35 36 37 38
#define RV_GET_MAJOR_VER(x)  ((x) >> 28)
#define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
#define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)

39
#define DC_VLC_BITS 14 //FIXME find a better solution
40

41 42 43 44 45
typedef struct RVDecContext {
    MpegEncContext m;
    int sub_id;
} RVDecContext;

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

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
static const uint8_t rv_lum_bits[256] = {
    14, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 10, 10, 10, 10, 10, 10, 10,
    10, 10, 10, 10, 10, 10, 10, 10,
    10, 10, 10, 10, 10, 10, 10, 10,
    10, 10, 10, 10, 10, 10, 10, 10,
    10,  8,  8,  8,  8,  8,  8,  8,
     8,  8,  8,  8,  8,  8,  8,  8,
     8,  7,  7,  7,  7,  7,  7,  7,
     7,  6,  6,  6,  6,  5,  5,  4,
     2,  4,  5,  5,  6,  6,  6,  6,
     7,  7,  7,  7,  7,  7,  7,  7,
     8,  8,  8,  8,  8,  8,  8,  8,
     8,  8,  8,  8,  8,  8,  8,  8,
    10, 10, 10, 10, 10, 10, 10, 10,
    10, 10, 10, 10, 10, 10, 10, 10,
    10, 10, 10, 10, 10, 10, 10, 10,
    10, 10, 10, 10, 10, 10, 10, 10,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
Fabrice Bellard's avatar
Fabrice Bellard committed
114 115
};

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

151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
static const uint8_t rv_chrom_bits[256] = {
    16, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 10, 10, 10, 10, 10, 10, 10,
    10, 10, 10, 10, 10, 10, 10, 10,
    10,  8,  8,  8,  8,  8,  8,  8,
     8,  6,  6,  6,  6,  4,  4,  3,
     2,  3,  4,  4,  6,  6,  6,  6,
     8,  8,  8,  8,  8,  8,  8,  8,
    10, 10, 10, 10, 10, 10, 10, 10,
    10, 10, 10, 10, 10, 10, 10, 10,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    12, 12, 12, 12, 12, 12, 12, 12,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
    14, 14, 14, 14, 14, 14, 14, 14,
Fabrice Bellard's avatar
Fabrice Bellard committed
184 185 186 187
};

static VLC rv_dc_lum, rv_dc_chrom;

188
int ff_rv_decode_dc(MpegEncContext *s, int n)
Fabrice Bellard's avatar
Fabrice Bellard committed
189 190 191 192
{
    int code;

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

/* read RV 1.0 compatible frame header */
static int rv10_decode_picture_header(MpegEncContext *s)
{
Mans Rullgard's avatar
Mans Rullgard committed
241
    int mb_count, pb_frame, marker, mb_xy;
242

243
    marker = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
244

245
    if (get_bits1(&s->gb))
246
        s->pict_type = AV_PICTURE_TYPE_P;
Fabrice Bellard's avatar
Fabrice Bellard committed
247
    else
248
        s->pict_type = AV_PICTURE_TYPE_I;
249 250 251 252

    if (!marker)
        av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");

253
    pb_frame = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
254

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

257
    if (pb_frame) {
258 259
        avpriv_request_sample(s->avctx, "pb frame");
        return AVERROR_PATCHWELCOME;
260
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
261 262

    s->qscale = get_bits(&s->gb, 5);
263
    if (s->qscale == 0) {
264 265
        av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
        return AVERROR_INVALIDDATA;
266
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
267

268
    if (s->pict_type == AV_PICTURE_TYPE_I) {
Fabrice Bellard's avatar
Fabrice Bellard committed
269 270 271 272 273
        if (s->rv10_version == 3) {
            /* specific MPEG like DC coding not used */
            s->last_dc[0] = get_bits(&s->gb, 8);
            s->last_dc[1] = get_bits(&s->gb, 8);
            s->last_dc[2] = get_bits(&s->gb, 8);
274
            av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
275
                    s->last_dc[1], s->last_dc[2]);
Fabrice Bellard's avatar
Fabrice Bellard committed
276 277 278
        }
    }
    /* if multiple packets per frame are sent, the position at which
Diego Biurrun's avatar
Diego Biurrun committed
279
       to display the macroblocks is coded here */
280

281 282 283 284
    mb_xy = s->mb_x + s->mb_y * s->mb_width;
    if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
        s->mb_x  = get_bits(&s->gb, 6); /* mb_x */
        s->mb_y  = get_bits(&s->gb, 6); /* mb_y */
Fabrice Bellard's avatar
Fabrice Bellard committed
285 286
        mb_count = get_bits(&s->gb, 12);
    } else {
287 288
        s->mb_x  = 0;
        s->mb_y  = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
289 290
        mb_count = s->mb_width * s->mb_height;
    }
Mans Rullgard's avatar
Mans Rullgard committed
291
    skip_bits(&s->gb, 3);   /* ignored */
Fabrice Bellard's avatar
Fabrice Bellard committed
292 293
    s->f_code = 1;
    s->unrestricted_mv = 1;
294

Fabrice Bellard's avatar
Fabrice Bellard committed
295 296 297
    return mb_count;
}

298
static int rv20_decode_picture_header(RVDecContext *rv)
Michael Niedermayer's avatar
Michael Niedermayer committed
299
{
300
    MpegEncContext *s = &rv->m;
301
    int seq, mb_pos, i, ret;
302
    int rpr_bits;
303

304
    i = get_bits(&s->gb, 2);
305
    switch(i) {
306 307 308 309
    case 0: s->pict_type = AV_PICTURE_TYPE_I; break;
    case 1: s->pict_type = AV_PICTURE_TYPE_I; break; //hmm ...
    case 2: s->pict_type = AV_PICTURE_TYPE_P; break;
    case 3: s->pict_type = AV_PICTURE_TYPE_B; break;
310
    default:
311
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
312
        return AVERROR_INVALIDDATA;
313
    }
314

315
    if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
316 317 318
        av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
        return -1;
    }
319
    if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
320 321
        av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
        return AVERROR_INVALIDDATA;
322
    }
323

324
    if (get_bits1(&s->gb)) {
325
        av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
326
        return AVERROR_INVALIDDATA;
Michael Niedermayer's avatar
Michael Niedermayer committed
327 328 329
    }

    s->qscale = get_bits(&s->gb, 5);
330
    if (s->qscale == 0) {
331 332
        av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
        return AVERROR_INVALIDDATA;
Michael Niedermayer's avatar
Michael Niedermayer committed
333
    }
334

335
    if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
336
        s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
Michael Niedermayer's avatar
Michael Niedermayer committed
337

338
    if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
339 340 341 342 343
        seq = get_bits(&s->gb, 8) << 7;
    else
        seq = get_bits(&s->gb, 13) << 2;

    rpr_bits = s->avctx->extradata[1] & 7;
344
    if (rpr_bits) {
345 346
        int f, new_w, new_h;
        rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
347

348
        f = get_bits(&s->gb, rpr_bits);
349

350
        if (f) {
351 352 353 354 355
            if (s->avctx->extradata_size < 8 + 2 * f) {
                av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
                return AVERROR_INVALIDDATA;
            }

356 357 358 359 360
            new_w = 4 * ((uint8_t*)s->avctx->extradata)[6 + 2 * f];
            new_h = 4 * ((uint8_t*)s->avctx->extradata)[7 + 2 * f];
        } else {
            new_w = s->orig_width ;
            new_h = s->orig_height;
361
        }
362
        if (new_w != s->width || new_h != s->height) {
363
            AVRational old_aspect = s->avctx->sample_aspect_ratio;
364 365
            av_log(s->avctx, AV_LOG_DEBUG,
                   "attempting to change resolution to %dx%d\n", new_w, new_h);
366
            if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
367
                return AVERROR_INVALIDDATA;
368
            ff_MPV_common_end(s);
369 370 371 372 373 374 375 376

            // attempt to keep aspect during typical resolution switches
            if (!old_aspect.num)
                old_aspect = (AVRational){1, 1};
            if (2 * new_w * s->height == new_h * s->width)
                s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
            if (new_w * s->height == 2 * new_h * s->width)
                s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
377 378 379
            avcodec_set_dimensions(s->avctx, new_w, new_h);
            s->width  = new_w;
            s->height = new_h;
380 381
            if ((ret = ff_MPV_common_init(s)) < 0)
                return ret;
382
        }
383

384
        if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
385
            av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
Michael Niedermayer's avatar
Michael Niedermayer committed
386
        }
387 388
    }
    if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
389
        return AVERROR_INVALIDDATA;
390

391 392
    mb_pos = ff_h263_decode_mba(s);

393 394 395 396 397 398 399 400 401 402 403 404 405 406
    seq |= s->time & ~0x7FFF;
    if (seq - s->time >  0x4000)
        seq -= 0x8000;
    if (seq - s->time < -0x4000)
        seq += 0x8000;

    if (seq != s->time) {
        if (s->pict_type != AV_PICTURE_TYPE_B) {
            s->time            = seq;
            s->pp_time         = s->time - s->last_non_b_time;
            s->last_non_b_time = s->time;
        } else {
            s->time    = seq;
            s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
407 408
        }
    }
409 410 411 412
    if (s->pict_type == AV_PICTURE_TYPE_B) {
        if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
            av_log(s->avctx, AV_LOG_DEBUG,
                   "messed up order, possible from seeking? skipping current b frame\n");
413 414
#define ERROR_SKIP_FRAME -123
            return ERROR_SKIP_FRAME;
415 416 417
        }
        ff_mpeg4_init_direct_mv(s);
    }
418

419
    s->no_rounding = get_bits1(&s->gb);
420

421
    if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
422 423
        skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used

424
    s->f_code          = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
425
    s->unrestricted_mv = 1;
426 427
    s->h263_aic        = s->pict_type == AV_PICTURE_TYPE_I;
    s->modified_quant  = 1;
428 429
    if (!s->avctx->lowres)
        s->loop_filter = 1;
430 431 432 433

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

436
    av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
437

Michael Niedermayer's avatar
Michael Niedermayer committed
438 439 440
    return s->mb_width*s->mb_height - mb_pos;
}

441
static av_cold int rv10_decode_init(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
442
{
443 444
    RVDecContext  *rv = avctx->priv_data;
    MpegEncContext *s = &rv->m;
445
    static int done = 0;
446
    int major_ver, minor_ver, micro_ver, ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
447

448 449
    if (avctx->extradata_size < 8) {
        av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
450
        return AVERROR_INVALIDDATA;
451
    }
452 453 454
    if ((ret = av_image_check_size(avctx->coded_width,
                                   avctx->coded_height, 0, avctx)) < 0)
        return ret;
455

456
    ff_MPV_decode_defaults(s);
457

458
    s->avctx      = avctx;
Fabrice Bellard's avatar
Fabrice Bellard committed
459
    s->out_format = FMT_H263;
460
    s->codec_id   = avctx->codec_id;
Fabrice Bellard's avatar
Fabrice Bellard committed
461

462 463
    s->orig_width  = s->width  = avctx->coded_width;
    s->orig_height = s->height = avctx->coded_height;
Fabrice Bellard's avatar
Fabrice Bellard committed
464

465 466
    s->h263_long_vectors = ((uint8_t*)avctx->extradata)[3] & 1;
    rv->sub_id           = AV_RB32((uint8_t*)avctx->extradata + 4);
Michael Niedermayer's avatar
Michael Niedermayer committed
467

468 469 470
    major_ver = RV_GET_MAJOR_VER(rv->sub_id);
    minor_ver = RV_GET_MINOR_VER(rv->sub_id);
    micro_ver = RV_GET_MICRO_VER(rv->sub_id);
471 472 473 474 475

    s->low_delay = 1;
    switch (major_ver) {
    case 1:
        s->rv10_version = micro_ver ? 3 : 1;
476
        s->obmc         = micro_ver == 2;
477 478 479
        break;
    case 2:
        if (minor_ver >= 2) {
480
            s->low_delay           = 0;
481 482 483 484
            s->avctx->has_b_frames = 1;
        }
        break;
    default:
485
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
486
        avpriv_request_sample(avctx, "RV1/2 version");
487 488
        return AVERROR_PATCHWELCOME;
    }
489

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

495
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
496

497 498
    if ((ret = ff_MPV_common_init(s)) < 0)
        return ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
499

500
    ff_h263_decode_init_vlc();
Fabrice Bellard's avatar
Fabrice Bellard committed
501 502 503

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

    return 0;
}

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

520
    ff_MPV_common_end(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
521 522 523
    return 0;
}

524
static int rv10_decode_packet(AVCodecContext *avctx,
525
                              const uint8_t *buf, int buf_size, int buf_size2)
Fabrice Bellard's avatar
Fabrice Bellard committed
526
{
527 528
    RVDecContext  *rv = avctx->priv_data;
    MpegEncContext *s = &rv->m;
529
    int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
530

531 532
    active_bits_size = buf_size * 8;
    init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
533
    if (s->codec_id == AV_CODEC_ID_RV10)
Michael Niedermayer's avatar
Michael Niedermayer committed
534 535
        mb_count = rv10_decode_picture_header(s);
    else
536
        mb_count = rv20_decode_picture_header(rv);
Fabrice Bellard's avatar
Fabrice Bellard committed
537
    if (mb_count < 0) {
538 539
        if (mb_count != ERROR_SKIP_FRAME)
            av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
540
        return AVERROR_INVALIDDATA;
Fabrice Bellard's avatar
Fabrice Bellard committed
541
    }
542

Fabrice Bellard's avatar
Fabrice Bellard committed
543 544
    if (s->mb_x >= s->mb_width ||
        s->mb_y >= s->mb_height) {
545
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
546
        return AVERROR_INVALIDDATA;
Fabrice Bellard's avatar
Fabrice Bellard committed
547 548 549 550
    }
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
    left = s->mb_width * s->mb_height - mb_pos;
    if (mb_count > left) {
551
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
552
        return AVERROR_INVALIDDATA;
Fabrice Bellard's avatar
Fabrice Bellard committed
553 554
    }

555 556
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
        if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?
557
            ff_er_frame_end(&s->er);
558
            ff_MPV_frame_end(s);
559
            s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
560
        }
561 562
        if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
            return ret;
563
        ff_mpeg_er_frame_start(s);
564
    } else {
565 566
        if (s->current_picture_ptr->f.pict_type != s->pict_type) {
            av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
567
            return AVERROR_INVALIDDATA;
568
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
569 570
    }

571

572
    av_dlog(avctx, "qscale=%d\n", s->qscale);
Fabrice Bellard's avatar
Fabrice Bellard committed
573 574

    /* default quantization values */
575 576 577 578 579 580
    if (s->codec_id == AV_CODEC_ID_RV10) {
        if (s->mb_y == 0)
            s->first_slice_line = 1;
    } else {
        s->first_slice_line = 1;
        s->resync_mb_x      = s->mb_x;
Michael Niedermayer's avatar
Michael Niedermayer committed
581
    }
582 583 584 585 586 587
    start_mb_x     = s->mb_x;
    s->resync_mb_y = s->mb_y;
    if (s->h263_aic) {
        s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;
    } else {
        s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
Michael Niedermayer's avatar
Michael Niedermayer committed
588
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
589

590 591
    if (s->modified_quant)
        s->chroma_qscale_table = ff_h263_chroma_qscale_table;
592

Michael Niedermayer's avatar
Michael Niedermayer committed
593
    ff_set_qscale(s, s->qscale);
Michael Niedermayer's avatar
Michael Niedermayer committed
594

Fabrice Bellard's avatar
Fabrice Bellard committed
595 596 597
    s->rv10_first_dc_coded[0] = 0;
    s->rv10_first_dc_coded[1] = 0;
    s->rv10_first_dc_coded[2] = 0;
598 599 600 601 602 603
    s->block_wrap[0] =
    s->block_wrap[1] =
    s->block_wrap[2] =
    s->block_wrap[3] = s->b8_stride;
    s->block_wrap[4] =
    s->block_wrap[5] = s->mb_stride;
604
    ff_init_block_index(s);
Michael Niedermayer's avatar
Michael Niedermayer committed
605

606 607
    /* decode each macroblock */
    for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
Michael Niedermayer's avatar
Michael Niedermayer committed
608
        int ret;
609
        ff_update_block_index(s);
610
        av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
Michael Niedermayer's avatar
Michael Niedermayer committed
611

612
        s->mv_dir  = MV_DIR_FORWARD;
613
        s->mv_type = MV_TYPE_16X16;
614
        ret = ff_h263_decode_mb(s, s->block);
Michael Niedermayer's avatar
Michael Niedermayer committed
615

616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
        // Repeat the slice end check from ff_h263_decode_mb with our active
        // bitstream size
        if (ret != SLICE_ERROR) {
            int v = show_bits(&s->gb, 16);

            if (get_bits_count(&s->gb) + 16 > active_bits_size)
                v >>= get_bits_count(&s->gb) + 16 - active_bits_size;

            if (!v)
                ret = SLICE_END;
        }
        if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
            8 * buf_size2 >= get_bits_count(&s->gb)) {
            active_bits_size = buf_size2 * 8;
            av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
                   8 * buf_size, active_bits_size);
632
            ret = SLICE_OK;
633 634
        }

635
        if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
636
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
637
            return AVERROR_INVALIDDATA;
Fabrice Bellard's avatar
Fabrice Bellard committed
638
        }
639
        if (s->pict_type != AV_PICTURE_TYPE_B)
640
            ff_h263_update_motion_val(s);
641
        ff_MPV_decode_mb(s, s->block);
642
        if (s->loop_filter)
Michael Niedermayer's avatar
Michael Niedermayer committed
643 644
            ff_h263_loop_filter(s);

Fabrice Bellard's avatar
Fabrice Bellard committed
645 646 647
        if (++s->mb_x == s->mb_width) {
            s->mb_x = 0;
            s->mb_y++;
648
            ff_init_block_index(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
649
        }
650 651 652 653
        if (s->mb_x == s->resync_mb_x)
            s->first_slice_line = 0;
        if (ret == SLICE_END)
            break;
Fabrice Bellard's avatar
Fabrice Bellard committed
654 655
    }

656 657
    ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,
                    ER_MB_END);
658

659
    return active_bits_size;
660 661
}

Michael Niedermayer's avatar
Michael Niedermayer committed
662
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
663
{
664 665 666 667
    if (avctx->slice_count)
        return avctx->slice_offset[n];
    else
        return AV_RL32(buf + n * 8);
668 669
}

670
static int rv10_decode_frame(AVCodecContext *avctx,
671
                             void *data, int *got_frame,
672
                             AVPacket *avpkt)
673
{
674
    const uint8_t *buf = avpkt->data;
675 676 677
    int buf_size       = avpkt->size;
    MpegEncContext *s  = avctx->priv_data;
    AVFrame *pict      = data;
678
    int i, ret;
679
    int slice_count;
Michael Niedermayer's avatar
Michael Niedermayer committed
680
    const uint8_t *slices_hdr = NULL;
681

682
    av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
683 684
    s->flags  = avctx->flags;
    s->flags2 = avctx->flags2;
685 686 687 688 689

    /* no supplementary picture */
    if (buf_size == 0) {
        return 0;
    }
690

691
    if (!avctx->slice_count) {
692
        slice_count = (*buf++) + 1;
693
        buf_size--;
694 695 696 697 698 699

        if (!slice_count || buf_size <= 8 * slice_count) {
            av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
            return AVERROR_INVALIDDATA;
        }

700
        slices_hdr = buf + 4;
701 702 703
        buf       += 8 * slice_count;
        buf_size  -= 8 * slice_count;
    } else
704 705
        slice_count = avctx->slice_count;

706
    for (i = 0; i < slice_count; i++) {
707
        unsigned offset = get_slice_offset(avctx, slices_hdr, i);
708
        int size, size2;
709

710 711 712
        if (offset >= buf_size)
            return AVERROR_INVALIDDATA;

713 714
        if (i + 1 == slice_count)
            size = buf_size - offset;
715
        else
716
            size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
717

718 719
        if (i + 2 >= slice_count)
            size2 = buf_size - offset;
720
        else
721
            size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
722

723 724 725 726
        if (size <= 0 || size2 <= 0 ||
            offset + FFMAX(size, size2) > buf_size)
            return AVERROR_INVALIDDATA;

727
        if (rv10_decode_packet(avctx, buf + offset, size, size2) > 8 * size)
728
            i++;
729
    }
730

731
    if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
732
        ff_er_frame_end(&s->er);
733
        ff_MPV_frame_end(s);
734

735
        if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
736 737
            if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
                return ret;
738
            ff_print_debug_info(s, s->current_picture_ptr, pict);
739
            ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
740
        } else if (s->last_picture_ptr != NULL) {
741 742
            if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
                return ret;
743
            ff_print_debug_info(s, s->last_picture_ptr, pict);
744
            ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
745
        }
746

747
        if (s->last_picture_ptr || s->low_delay) {
748
            *got_frame = 1;
749
        }
750 751 752

        // so we can detect if frame_end was not called (find some nicer solution...)
        s->current_picture_ptr = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
753
    }
754

755
    return avpkt->size;
Fabrice Bellard's avatar
Fabrice Bellard committed
756 757
}

758
AVCodec ff_rv10_decoder = {
759
    .name           = "rv10",
760
    .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
761
    .type           = AVMEDIA_TYPE_VIDEO,
762
    .id             = AV_CODEC_ID_RV10,
763
    .priv_data_size = sizeof(RVDecContext),
764 765 766 767
    .init           = rv10_decode_init,
    .close          = rv10_decode_end,
    .decode         = rv10_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
768
    .max_lowres     = 3,
769
    .pix_fmts       = ff_pixfmt_list_420,
Fabrice Bellard's avatar
Fabrice Bellard committed
770
};
Michael Niedermayer's avatar
Michael Niedermayer committed
771

772
AVCodec ff_rv20_decoder = {
773
    .name           = "rv20",
774
    .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
775
    .type           = AVMEDIA_TYPE_VIDEO,
776
    .id             = AV_CODEC_ID_RV20,
777
    .priv_data_size = sizeof(RVDecContext),
778 779 780 781
    .init           = rv10_decode_init,
    .close          = rv10_decode_end,
    .decode         = rv10_decode_frame,
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
782
    .flush          = ff_mpeg_flush,
783
    .max_lowres     = 3,
784
    .pix_fmts       = ff_pixfmt_list_420,
Michael Niedermayer's avatar
Michael Niedermayer committed
785
};