rv10.c 27.4 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"
29

Fabrice Bellard's avatar
Fabrice Bellard committed
30
#include "avcodec.h"
31
#include "error_resilience.h"
32
#include "h263.h"
33
#include "internal.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
34
#include "mpegvideo.h"
35
#include "mpeg4video.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
36

37 38 39 40
#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)

41
#define DC_VLC_BITS 14 // FIXME find a better solution
42

43 44 45 46 47
typedef struct RVDecContext {
    MpegEncContext m;
    int sub_id;
} RVDecContext;

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 79 80
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
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 114 115
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
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 149 150
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
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 184 185
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
186 187 188 189
};

static VLC rv_dc_lum, rv_dc_chrom;

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

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

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

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

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

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

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

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

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

270
    if (s->pict_type == AV_PICTURE_TYPE_I) {
Fabrice Bellard's avatar
Fabrice Bellard committed
271 272 273 274 275
        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);
276
            av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
277
                    s->last_dc[1], s->last_dc[2]);
Fabrice Bellard's avatar
Fabrice Bellard committed
278 279 280
        }
    }
    /* if multiple packets per frame are sent, the position at which
281
     * to display the macroblocks is coded here */
282

283 284 285 286
    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
287 288
        mb_count = get_bits(&s->gb, 12);
    } else {
289 290
        s->mb_x  = 0;
        s->mb_y  = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
291 292
        mb_count = s->mb_width * s->mb_height;
    }
Mans Rullgard's avatar
Mans Rullgard committed
293
    skip_bits(&s->gb, 3);   /* ignored */
294
    s->f_code          = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
295
    s->unrestricted_mv = 1;
296

Fabrice Bellard's avatar
Fabrice Bellard committed
297 298 299
    return mb_count;
}

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

306 307
    i = get_bits(&s->gb, 2);
    switch (i) {
308 309 310 311 312 313 314 315 316 317 318 319
    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;
320
    default:
321
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
322
        return AVERROR_INVALIDDATA;
323
    }
324

325
    if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
326 327 328
        av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
        return -1;
    }
329
    if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
330 331
        av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
        return AVERROR_INVALIDDATA;
332
    }
333

334
    if (get_bits1(&s->gb)) {
335
        av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
336
        return AVERROR_INVALIDDATA;
Michael Niedermayer's avatar
Michael Niedermayer committed
337 338 339
    }

    s->qscale = get_bits(&s->gb, 5);
340
    if (s->qscale == 0) {
341 342
        av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
        return AVERROR_INVALIDDATA;
Michael Niedermayer's avatar
Michael Niedermayer committed
343
    }
344

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

348
    if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
349 350 351 352
        seq = get_bits(&s->gb, 8) << 7;
    else
        seq = get_bits(&s->gb, 13) << 2;

353 354
    rpr_max = s->avctx->extradata[1] & 7;
    if (rpr_max) {
355
        int f, new_w, new_h;
356
        int rpr_bits = av_log2(rpr_max) + 1;
357

358
        f = get_bits(&s->gb, rpr_bits);
359

360
        if (f) {
361 362 363 364 365
            if (s->avctx->extradata_size < 8 + 2 * f) {
                av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
                return AVERROR_INVALIDDATA;
            }

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

            // 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});
387

388 389 390 391
            ret = ff_set_dimensions(s->avctx, new_w, new_h);
            if (ret < 0)
                return ret;

392 393
            s->width  = new_w;
            s->height = new_h;
394 395
            if ((ret = ff_MPV_common_init(s)) < 0)
                return ret;
396
        }
397

398
        if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
399
            av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max);
Michael Niedermayer's avatar
Michael Niedermayer committed
400
        }
401 402
    }
    if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
403
        return AVERROR_INVALIDDATA;
404

405 406
    mb_pos = ff_h263_decode_mba(s);

407 408 409 410 411 412 413 414 415 416 417 418 419 420
    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);
421 422
        }
    }
423 424 425 426
    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");
427 428
#define ERROR_SKIP_FRAME -123
            return ERROR_SKIP_FRAME;
429 430 431
        }
        ff_mpeg4_init_direct_mv(s);
    }
432

433
    s->no_rounding = get_bits1(&s->gb);
434

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

439
    s->f_code          = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
440
    s->unrestricted_mv = 1;
441 442
    s->h263_aic        = s->pict_type == AV_PICTURE_TYPE_I;
    s->modified_quant  = 1;
443 444
    if (!s->avctx->lowres)
        s->loop_filter = 1;
445 446

    if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
447 448 449 450
        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
451 452
    }

453
    av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
454

455
    return s->mb_width * s->mb_height - mb_pos;
Michael Niedermayer's avatar
Michael Niedermayer committed
456 457
}

458
static av_cold int rv10_decode_init(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
459
{
460
    RVDecContext *rv = avctx->priv_data;
461
    MpegEncContext *s = &rv->m;
462
    static int done = 0;
463
    int major_ver, minor_ver, micro_ver, ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
464

465 466
    if (avctx->extradata_size < 8) {
        av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
467
        return AVERROR_INVALIDDATA;
468
    }
469 470 471
    if ((ret = av_image_check_size(avctx->coded_width,
                                   avctx->coded_height, 0, avctx)) < 0)
        return ret;
472

473
    ff_MPV_decode_defaults(s);
474

475 476 477
    s->avctx       = avctx;
    s->out_format  = FMT_H263;
    s->codec_id    = avctx->codec_id;
Fabrice Bellard's avatar
Fabrice Bellard committed
478

479 480 481 482
    s->orig_width  =
    s->width       = avctx->coded_width;
    s->orig_height =
    s->height      = avctx->coded_height;
Fabrice Bellard's avatar
Fabrice Bellard committed
483

484 485
    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
486

487 488 489
    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);
490 491 492 493 494

    s->low_delay = 1;
    switch (major_ver) {
    case 1:
        s->rv10_version = micro_ver ? 3 : 1;
495
        s->obmc         = micro_ver == 2;
496 497 498
        break;
    case 2:
        if (minor_ver >= 2) {
499
            s->low_delay           = 0;
500 501 502 503
            s->avctx->has_b_frames = 1;
        }
        break;
    default:
504
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
505
        avpriv_request_sample(avctx, "RV1/2 version");
506 507
        return AVERROR_PATCHWELCOME;
    }
508

509 510
    if (avctx->debug & FF_DEBUG_PICT_INFO) {
        av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
511
               ((uint32_t *) avctx->extradata)[0]);
512
    }
513

514
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
515

516 517
    if ((ret = ff_MPV_common_init(s)) < 0)
        return ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
518

519
    ff_h263dsp_init(&s->h263dsp);
520
    ff_h263_decode_init_vlc();
Fabrice Bellard's avatar
Fabrice Bellard committed
521 522 523

    /* init rv vlc */
    if (!done) {
524
        INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
525 526
                        rv_lum_bits, 1, 1,
                        rv_lum_code, 2, 2, 16384);
527
        INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
528 529
                        rv_chrom_bits, 1, 1,
                        rv_chrom_code, 2, 2, 16388);
Fabrice Bellard's avatar
Fabrice Bellard committed
530 531 532 533 534 535
        done = 1;
    }

    return 0;
}

536
static av_cold int rv10_decode_end(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
537 538 539
{
    MpegEncContext *s = avctx->priv_data;

540
    ff_MPV_common_end(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
541 542 543
    return 0;
}

544 545
static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
                              int buf_size, int buf_size2)
Fabrice Bellard's avatar
Fabrice Bellard committed
546
{
547
    RVDecContext *rv = avctx->priv_data;
548
    MpegEncContext *s = &rv->m;
549
    int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
550

551 552
    active_bits_size = buf_size * 8;
    init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
553
    if (s->codec_id == AV_CODEC_ID_RV10)
Michael Niedermayer's avatar
Michael Niedermayer committed
554 555
        mb_count = rv10_decode_picture_header(s);
    else
556
        mb_count = rv20_decode_picture_header(rv);
Fabrice Bellard's avatar
Fabrice Bellard committed
557
    if (mb_count < 0) {
558 559
        if (mb_count != ERROR_SKIP_FRAME)
            av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
560
        return AVERROR_INVALIDDATA;
Fabrice Bellard's avatar
Fabrice Bellard committed
561
    }
562

Fabrice Bellard's avatar
Fabrice Bellard committed
563 564
    if (s->mb_x >= s->mb_width ||
        s->mb_y >= s->mb_height) {
565
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
566
        return AVERROR_INVALIDDATA;
Fabrice Bellard's avatar
Fabrice Bellard committed
567 568
    }
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
569
    left   = s->mb_width * s->mb_height - mb_pos;
Fabrice Bellard's avatar
Fabrice Bellard committed
570
    if (mb_count > left) {
571
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
572
        return AVERROR_INVALIDDATA;
Fabrice Bellard's avatar
Fabrice Bellard committed
573 574
    }

575
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
576 577
        // FIXME write parser so we always have complete frames?
        if (s->current_picture_ptr) {
578
            ff_er_frame_end(&s->er);
579
            ff_MPV_frame_end(s);
580
            s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
581
        }
582 583
        if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
            return ret;
584
        ff_mpeg_er_frame_start(s);
585
    } else {
586 587
        if (s->current_picture_ptr->f.pict_type != s->pict_type) {
            av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
588
            return AVERROR_INVALIDDATA;
589
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
590 591
    }

592

593
    av_dlog(avctx, "qscale=%d\n", s->qscale);
Fabrice Bellard's avatar
Fabrice Bellard committed
594 595

    /* default quantization values */
596 597 598 599 600 601
    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
602
    }
603 604 605
    start_mb_x     = s->mb_x;
    s->resync_mb_y = s->mb_y;
    if (s->h263_aic) {
606 607
        s->y_dc_scale_table =
        s->c_dc_scale_table = ff_aic_dc_scale_table;
608
    } else {
609 610
        s->y_dc_scale_table =
        s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
Michael Niedermayer's avatar
Michael Niedermayer committed
611
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
612

613 614
    if (s->modified_quant)
        s->chroma_qscale_table = ff_h263_chroma_qscale_table;
615

Michael Niedermayer's avatar
Michael Niedermayer committed
616
    ff_set_qscale(s, s->qscale);
Michael Niedermayer's avatar
Michael Niedermayer committed
617

Fabrice Bellard's avatar
Fabrice Bellard committed
618 619 620
    s->rv10_first_dc_coded[0] = 0;
    s->rv10_first_dc_coded[1] = 0;
    s->rv10_first_dc_coded[2] = 0;
621 622 623 624 625 626
    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;
627
    ff_init_block_index(s);
Michael Niedermayer's avatar
Michael Niedermayer committed
628

629 630
    /* 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
631
        int ret;
632
        ff_update_block_index(s);
633
        av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
Michael Niedermayer's avatar
Michael Niedermayer committed
634

635
        s->mv_dir  = MV_DIR_FORWARD;
636
        s->mv_type = MV_TYPE_16X16;
637
        ret = ff_h263_decode_mb(s, s->block);
Michael Niedermayer's avatar
Michael Niedermayer committed
638

639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
        // 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);
655
            ret = SLICE_OK;
656 657
        }

658
        if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
659 660
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
                   s->mb_y);
661
            return AVERROR_INVALIDDATA;
Fabrice Bellard's avatar
Fabrice Bellard committed
662
        }
663
        if (s->pict_type != AV_PICTURE_TYPE_B)
664
            ff_h263_update_motion_val(s);
665
        ff_MPV_decode_mb(s, s->block);
666
        if (s->loop_filter)
Michael Niedermayer's avatar
Michael Niedermayer committed
667 668
            ff_h263_loop_filter(s);

Fabrice Bellard's avatar
Fabrice Bellard committed
669 670 671
        if (++s->mb_x == s->mb_width) {
            s->mb_x = 0;
            s->mb_y++;
672
            ff_init_block_index(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
673
        }
674 675 676 677
        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
678 679
    }

680
    ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
681
                    ER_MB_END);
682

683
    return active_bits_size;
684 685
}

Michael Niedermayer's avatar
Michael Niedermayer committed
686
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
687
{
688 689 690 691
    if (avctx->slice_count)
        return avctx->slice_offset[n];
    else
        return AV_RL32(buf + n * 8);
692 693
}

694
static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
695
                             AVPacket *avpkt)
696
{
697
    const uint8_t *buf = avpkt->data;
698
    int buf_size       = avpkt->size;
699 700
    MpegEncContext *s = avctx->priv_data;
    AVFrame *pict = data;
701
    int i, ret;
702
    int slice_count;
Michael Niedermayer's avatar
Michael Niedermayer committed
703
    const uint8_t *slices_hdr = NULL;
704

705
    av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
706 707
    s->flags  = avctx->flags;
    s->flags2 = avctx->flags2;
708 709 710 711 712

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

714
    if (!avctx->slice_count) {
715
        slice_count = (*buf++) + 1;
716
        buf_size--;
717 718

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

724
        slices_hdr = buf + 4;
725 726 727
        buf       += 8 * slice_count;
        buf_size  -= 8 * slice_count;
    } else
728 729
        slice_count = avctx->slice_count;

730
    for (i = 0; i < slice_count; i++) {
731
        unsigned offset = get_slice_offset(avctx, slices_hdr, i);
732
        int size, size2;
733

734 735 736
        if (offset >= buf_size)
            return AVERROR_INVALIDDATA;

737 738
        if (i + 1 == slice_count)
            size = buf_size - offset;
739
        else
740
            size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
741

742 743
        if (i + 2 >= slice_count)
            size2 = buf_size - offset;
744
        else
745
            size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
746

747 748 749 750
        if (size <= 0 || size2 <= 0 ||
            offset + FFMAX(size, size2) > buf_size)
            return AVERROR_INVALIDDATA;

751 752 753 754
        if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2)) < 0)
            return ret;

        if (ret > 8 * size)
755
            i++;
756
    }
757

758
    if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
759
        ff_er_frame_end(&s->er);
760
        ff_MPV_frame_end(s);
761

762
        if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
763 764
            if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
                return ret;
765
            ff_print_debug_info(s, s->current_picture_ptr, pict);
766
            ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
767
        } else if (s->last_picture_ptr != NULL) {
768 769
            if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
                return ret;
770
            ff_print_debug_info(s, s->last_picture_ptr, pict);
771
            ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
772
        }
773

774
        if (s->last_picture_ptr || s->low_delay) {
775
            *got_frame = 1;
776
        }
777 778 779

        // 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
780
    }
781

782
    return avpkt->size;
Fabrice Bellard's avatar
Fabrice Bellard committed
783 784
}

785
AVCodec ff_rv10_decoder = {
786
    .name           = "rv10",
787
    .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
788
    .type           = AVMEDIA_TYPE_VIDEO,
789
    .id             = AV_CODEC_ID_RV10,
790
    .priv_data_size = sizeof(RVDecContext),
791 792 793 794
    .init           = rv10_decode_init,
    .close          = rv10_decode_end,
    .decode         = rv10_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
795
    .max_lowres     = 3,
796
    .pix_fmts       = ff_pixfmt_list_420,
Fabrice Bellard's avatar
Fabrice Bellard committed
797
};
Michael Niedermayer's avatar
Michael Niedermayer committed
798

799
AVCodec ff_rv20_decoder = {
800
    .name           = "rv20",
801
    .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
802
    .type           = AVMEDIA_TYPE_VIDEO,
803
    .id             = AV_CODEC_ID_RV20,
804
    .priv_data_size = sizeof(RVDecContext),
805 806 807 808
    .init           = rv10_decode_init,
    .close          = rv10_decode_end,
    .decode         = rv10_decode_frame,
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
809
    .flush          = ff_mpeg_flush,
810
    .max_lowres     = 3,
811
    .pix_fmts       = ff_pixfmt_list_420,
Michael Niedermayer's avatar
Michael Niedermayer committed
812
};