rv10.c 25.7 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 "dsputil.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

//#define DEBUG

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
static const uint16_t rv_lum_code[256] =
Fabrice Bellard's avatar
Fabrice Bellard committed
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 81 82 83
{
 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,
};

84
static const uint8_t rv_lum_bits[256] =
Fabrice Bellard's avatar
Fabrice Bellard committed
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 116 117 118 119
{
 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,
};

120
static const uint16_t rv_chrom_code[256] =
Fabrice Bellard's avatar
Fabrice Bellard committed
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 151 152 153 154 155
{
 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,
};

156
static const uint8_t rv_chrom_bits[256] =
Fabrice Bellard's avatar
Fabrice Bellard committed
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 186 187 188 189 190 191 192 193
{
 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,
};

static VLC rv_dc_lum, rv_dc_chrom;

194
int ff_rv_decode_dc(MpegEncContext *s, int n)
Fabrice Bellard's avatar
Fabrice Bellard committed
195 196 197 198
{
    int code;

    if (n < 4) {
199
        code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
Fabrice Bellard's avatar
Fabrice Bellard committed
200 201 202 203 204 205
        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) {
206
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
207 208 209
            } else if (code == 0x7d) {
                code = -128 + get_bits(&s->gb, 7);
            } else if (code == 0x7e) {
210
                if (get_bits1(&s->gb) == 0)
211
                    code = (int8_t)(get_bits(&s->gb, 8) + 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
212
                else
213
                    code = (int8_t)(get_bits(&s->gb, 8));
Fabrice Bellard's avatar
Fabrice Bellard committed
214
            } else if (code == 0x7f) {
215
                skip_bits(&s->gb, 11);
Fabrice Bellard's avatar
Fabrice Bellard committed
216 217 218 219 220 221
                code = 1;
            }
        } else {
            code -= 128;
        }
    } else {
222
        code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
Fabrice Bellard's avatar
Fabrice Bellard committed
223 224 225 226
        /* same remark */
        if (code < 0) {
            code = get_bits(&s->gb, 9);
            if (code == 0x1fc) {
227
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
228 229 230
            } else if (code == 0x1fd) {
                code = -128 + get_bits(&s->gb, 7);
            } else if (code == 0x1fe) {
231
                skip_bits(&s->gb, 9);
Fabrice Bellard's avatar
Fabrice Bellard committed
232 233
                code = 1;
            } else {
234
                av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
Fabrice Bellard's avatar
Fabrice Bellard committed
235 236 237 238 239 240 241 242 243 244 245 246
                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
247
    int mb_count, pb_frame, marker, mb_xy;
248

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

251
    if (get_bits1(&s->gb))
252
        s->pict_type = AV_PICTURE_TYPE_P;
Fabrice Bellard's avatar
Fabrice Bellard committed
253
    else
254
        s->pict_type = AV_PICTURE_TYPE_I;
255
    if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
256
    pb_frame = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
257

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

260
    if (pb_frame){
261
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
Fabrice Bellard's avatar
Fabrice Bellard committed
262
        return -1;
263
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
264 265

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

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

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

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

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

Michael Niedermayer's avatar
Michael Niedermayer committed
307 308 309 310 311 312 313 314
#if 0
    GetBitContext gb= s->gb;
    for(i=0; i<64; i++){
        av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
    }
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
#endif
315
#if 0
316
    av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
317
    for(i=0; i<s->avctx->extradata_size; i++){
318
        av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
319 320 321 322
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
    }
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
#endif
323

324 325
    i= get_bits(&s->gb, 2);
    switch(i){
326 327 328 329
    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;
330
    default:
331 332 333
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
        return -1;
    }
334

335 336 337 338
    if(s->low_delay && s->pict_type==AV_PICTURE_TYPE_B){
        av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
        return -1;
    }
339
    if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
340 341 342
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
        return -1;
    }
343

344
    if (get_bits1(&s->gb)){
345
        av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
Michael Niedermayer's avatar
Michael Niedermayer committed
346 347 348 349 350 351 352 353
        return -1;
    }

    s->qscale = get_bits(&s->gb, 5);
    if(s->qscale==0){
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
        return -1;
    }
354

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

358
    if(RV_GET_MINOR_VER(rv->sub_id) <= 1)
359 360 361 362 363 364 365 366
        seq = get_bits(&s->gb, 8) << 7;
    else
        seq = get_bits(&s->gb, 13) << 2;

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

368
        f = get_bits(&s->gb, rpr_bits);
369 370 371 372 373

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

            // 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});
391 392 393
            avcodec_set_dimensions(s->avctx, new_w, new_h);
            s->width  = new_w;
            s->height = new_h;
394
            if (ff_MPV_common_init(s) < 0)
395 396
                return -1;
        }
397

Michael Niedermayer's avatar
Michael Niedermayer committed
398
        if(s->avctx->debug & FF_DEBUG_PICT_INFO){
399
            av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
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
    seq |= s->time &~0x7FFF;
    if(seq - s->time >  0x4000) seq -= 0x8000;
    if(seq - s->time < -0x4000) seq += 0x8000;
410
    if(seq != s->time){
411
        if(s->pict_type!=AV_PICTURE_TYPE_B){
412 413 414 415 416 417 418
            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);
            if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
419 420
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
                return FRAME_SKIPPED;
421
            }
422
            ff_mpeg4_init_direct_mv(s);
423 424
        }
    }
425

Michael Niedermayer's avatar
Michael Niedermayer committed
426
    s->no_rounding= get_bits1(&s->gb);
427

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

Michael Niedermayer's avatar
Michael Niedermayer committed
431 432
    s->f_code = 1;
    s->unrestricted_mv = 1;
433
    s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
Michael Niedermayer's avatar
Michael Niedermayer committed
434 435 436
//    s->alt_inter_vlc=1;
//    s->obmc=1;
//    s->umvplus=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
437
    s->modified_quant=1;
438 439
    if(!s->avctx->lowres)
        s->loop_filter=1;
440

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

446
    av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
447

Michael Niedermayer's avatar
Michael Niedermayer committed
448 449 450
    return s->mb_width*s->mb_height - mb_pos;
}

451
static av_cold int rv10_decode_init(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
452
{
453 454
    RVDecContext  *rv = avctx->priv_data;
    MpegEncContext *s = &rv->m;
455
    static int done=0;
456
    int major_ver, minor_ver, micro_ver;
Fabrice Bellard's avatar
Fabrice Bellard committed
457

458 459 460 461 462
    if (avctx->extradata_size < 8) {
        av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
        return -1;
    }

463
    ff_MPV_decode_defaults(s);
464

Michael Niedermayer's avatar
Michael Niedermayer committed
465
    s->avctx= avctx;
Fabrice Bellard's avatar
Fabrice Bellard committed
466
    s->out_format = FMT_H263;
Michael Niedermayer's avatar
Michael Niedermayer committed
467
    s->codec_id= avctx->codec_id;
Fabrice Bellard's avatar
Fabrice Bellard committed
468

469 470
    s->orig_width = s->width  = avctx->coded_width;
    s->orig_height= s->height = avctx->coded_height;
Fabrice Bellard's avatar
Fabrice Bellard committed
471

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

475 476 477
    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);
478 479 480 481 482 483 484 485 486 487 488 489 490 491

    s->low_delay = 1;
    switch (major_ver) {
    case 1:
        s->rv10_version = micro_ver ? 3 : 1;
        s->obmc = micro_ver == 2;
        break;
    case 2:
        if (minor_ver >= 2) {
            s->low_delay = 0;
            s->avctx->has_b_frames = 1;
        }
        break;
    default:
492
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
493 494 495
        av_log_missing_feature(avctx, "RV1/2 version", 1);
        return AVERROR_PATCHWELCOME;
    }
496

497
    if(avctx->debug & FF_DEBUG_PICT_INFO){
498
        av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
499
    }
500

501
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
502

503
    if (ff_MPV_common_init(s) < 0)
Fabrice Bellard's avatar
Fabrice Bellard committed
504 505
        return -1;

506
    ff_h263_decode_init_vlc(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
507 508 509

    /* init rv vlc */
    if (!done) {
510
        INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
Fabrice Bellard's avatar
Fabrice Bellard committed
511
                 rv_lum_bits, 1, 1,
512 513
                 rv_lum_code, 2, 2, 16384);
        INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
Fabrice Bellard's avatar
Fabrice Bellard committed
514
                 rv_chrom_bits, 1, 1,
515
                 rv_chrom_code, 2, 2, 16388);
Fabrice Bellard's avatar
Fabrice Bellard committed
516 517 518 519 520 521
        done = 1;
    }

    return 0;
}

522
static av_cold int rv10_decode_end(AVCodecContext *avctx)
Fabrice Bellard's avatar
Fabrice Bellard committed
523 524 525
{
    MpegEncContext *s = avctx->priv_data;

526
    ff_MPV_common_end(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
527 528 529
    return 0;
}

530
static int rv10_decode_packet(AVCodecContext *avctx,
531
                             const uint8_t *buf, int buf_size, int buf_size2)
Fabrice Bellard's avatar
Fabrice Bellard committed
532
{
533 534
    RVDecContext  *rv = avctx->priv_data;
    MpegEncContext *s = &rv->m;
535
    int mb_count, mb_pos, left, start_mb_x, active_bits_size;
Fabrice Bellard's avatar
Fabrice Bellard committed
536

537 538
    active_bits_size = buf_size * 8;
    init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
539
    if(s->codec_id ==AV_CODEC_ID_RV10)
Michael Niedermayer's avatar
Michael Niedermayer committed
540 541
        mb_count = rv10_decode_picture_header(s);
    else
542
        mb_count = rv20_decode_picture_header(rv);
Fabrice Bellard's avatar
Fabrice Bellard committed
543
    if (mb_count < 0) {
544
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
Fabrice Bellard's avatar
Fabrice Bellard committed
545 546
        return -1;
    }
547

Fabrice Bellard's avatar
Fabrice Bellard committed
548 549
    if (s->mb_x >= s->mb_width ||
        s->mb_y >= s->mb_height) {
550
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
Fabrice Bellard's avatar
Fabrice Bellard committed
551 552 553 554 555
        return -1;
    }
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
    left = s->mb_width * s->mb_height - mb_pos;
    if (mb_count > left) {
556
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
Fabrice Bellard's avatar
Fabrice Bellard committed
557 558 559
        return -1;
    }

Michael Niedermayer's avatar
Michael Niedermayer committed
560
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
561 562
        if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
            ff_er_frame_end(s);
563
            ff_MPV_frame_end(s);
564 565
            s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
        }
566
        if(ff_MPV_frame_start(s, avctx) < 0)
567
            return -1;
568
        ff_er_frame_start(s);
569
    } else {
570 571
        if (s->current_picture_ptr->f.pict_type != s->pict_type) {
            av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
572
            return -1;
573
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
574 575
    }

576

577
    av_dlog(avctx, "qscale=%d\n", s->qscale);
Fabrice Bellard's avatar
Fabrice Bellard committed
578 579

    /* default quantization values */
580
    if(s->codec_id== AV_CODEC_ID_RV10){
Michael Niedermayer's avatar
Michael Niedermayer committed
581 582
        if(s->mb_y==0) s->first_slice_line=1;
    }else{
583
        s->first_slice_line=1;
584
        s->resync_mb_x= s->mb_x;
Michael Niedermayer's avatar
Michael Niedermayer committed
585
    }
586
    start_mb_x= s->mb_x;
587
    s->resync_mb_y= s->mb_y;
Michael Niedermayer's avatar
Michael Niedermayer committed
588
    if(s->h263_aic){
589
        s->y_dc_scale_table=
Michael Niedermayer's avatar
Michael Niedermayer committed
590 591 592 593 594
        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
595 596 597

    if(s->modified_quant)
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
598

Michael Niedermayer's avatar
Michael Niedermayer committed
599
    ff_set_qscale(s, s->qscale);
Michael Niedermayer's avatar
Michael Niedermayer committed
600

Fabrice Bellard's avatar
Fabrice Bellard committed
601 602 603
    s->rv10_first_dc_coded[0] = 0;
    s->rv10_first_dc_coded[1] = 0;
    s->rv10_first_dc_coded[2] = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
604 605 606
    s->block_wrap[0]=
    s->block_wrap[1]=
    s->block_wrap[2]=
607
    s->block_wrap[3]= s->b8_stride;
Michael Niedermayer's avatar
Michael Niedermayer committed
608
    s->block_wrap[4]=
609
    s->block_wrap[5]= s->mb_stride;
610
    ff_init_block_index(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
611
    /* decode each macroblock */
Michael Niedermayer's avatar
Michael Niedermayer committed
612 613

    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
Michael Niedermayer's avatar
Michael Niedermayer committed
614
        int ret;
615
        ff_update_block_index(s);
616
        av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
Michael Niedermayer's avatar
Michael Niedermayer committed
617

Fabrice Bellard's avatar
Fabrice Bellard committed
618
        s->mv_dir = MV_DIR_FORWARD;
619
        s->mv_type = MV_TYPE_16X16;
Michael Niedermayer's avatar
Michael Niedermayer committed
620 621
        ret=ff_h263_decode_mb(s, s->block);

622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
        // 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);
638 639 640
            ret= SLICE_OK;
        }

641
        if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
642
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
Fabrice Bellard's avatar
Fabrice Bellard committed
643 644
            return -1;
        }
645
        if(s->pict_type != AV_PICTURE_TYPE_B)
646
            ff_h263_update_motion_val(s);
647
        ff_MPV_decode_mb(s, s->block);
Michael Niedermayer's avatar
Michael Niedermayer committed
648 649 650
        if(s->loop_filter)
            ff_h263_loop_filter(s);

Fabrice Bellard's avatar
Fabrice Bellard committed
651 652 653
        if (++s->mb_x == s->mb_width) {
            s->mb_x = 0;
            s->mb_y++;
654
            ff_init_block_index(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
655
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
656 657 658
        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
659 660
    }

661
    ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
662

663
    return active_bits_size;
664 665
}

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

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

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

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

693 694
    if(!avctx->slice_count){
        slice_count = (*buf++) + 1;
695
        buf_size--;
696 697
        slices_hdr = buf + 4;
        buf += 8 * slice_count;
698 699 700
        buf_size -= 8 * slice_count;
        if (buf_size <= 0)
            return AVERROR_INVALIDDATA;
701 702 703
    }else
        slice_count = avctx->slice_count;

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

708 709 710
        if (offset >= buf_size)
            return AVERROR_INVALIDDATA;

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

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

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

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

729
    if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
730
        ff_er_frame_end(s);
731
        ff_MPV_frame_end(s);
732

733
        if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
734
            *pict = s->current_picture_ptr->f;
735
        } else if (s->last_picture_ptr != NULL) {
736
            *pict = s->last_picture_ptr->f;
737
        }
738 739

        if(s->last_picture_ptr || s->low_delay){
Michael Niedermayer's avatar
Michael Niedermayer committed
740
            *data_size = sizeof(AVFrame);
741 742
            ff_print_debug_info(s, pict);
        }
743
        s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
Fabrice Bellard's avatar
Fabrice Bellard committed
744
    }
745

746
    return avpkt->size;
Fabrice Bellard's avatar
Fabrice Bellard committed
747 748
}

749
AVCodec ff_rv10_decoder = {
750 751
    .name           = "rv10",
    .type           = AVMEDIA_TYPE_VIDEO,
752
    .id             = AV_CODEC_ID_RV10,
753
    .priv_data_size = sizeof(RVDecContext),
754 755 756 757
    .init           = rv10_decode_init,
    .close          = rv10_decode_end,
    .decode         = rv10_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
758
    .max_lowres     = 3,
759 760
    .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
    .pix_fmts       = ff_pixfmt_list_420,
Fabrice Bellard's avatar
Fabrice Bellard committed
761
};
Michael Niedermayer's avatar
Michael Niedermayer committed
762

763
AVCodec ff_rv20_decoder = {
764 765
    .name           = "rv20",
    .type           = AVMEDIA_TYPE_VIDEO,
766
    .id             = AV_CODEC_ID_RV20,
767
    .priv_data_size = sizeof(RVDecContext),
768 769 770 771
    .init           = rv10_decode_init,
    .close          = rv10_decode_end,
    .decode         = rv10_decode_frame,
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
772
    .flush          = ff_mpeg_flush,
773
    .max_lowres     = 3,
774 775
    .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
    .pix_fmts       = ff_pixfmt_list_420,
Michael Niedermayer's avatar
Michael Niedermayer committed
776
};