rv10.c 25 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1 2
/*
 * RV10 codec
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 25 26

/**
 * @file rv10.c
 * RV10 codec.
 */
27

Fabrice Bellard's avatar
Fabrice Bellard committed
28
#include "avcodec.h"
29
#include "dsputil.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
30 31 32 33
#include "mpegvideo.h"

//#define DEBUG

34
#define DC_VLC_BITS 14 //FIXME find a better solution
35

36
static const uint16_t rv_lum_code[256] =
Fabrice Bellard's avatar
Fabrice Bellard committed
37 38 39 40 41 42 43 44 45 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
{
 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,
};

72
static const uint8_t rv_lum_bits[256] =
Fabrice Bellard's avatar
Fabrice Bellard committed
73 74 75 76 77 78 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
{
 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,
};

108
static const uint16_t rv_chrom_code[256] =
Fabrice Bellard's avatar
Fabrice Bellard committed
109 110 111 112 113 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
{
 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,
};

144
static const uint8_t rv_chrom_bits[256] =
Fabrice Bellard's avatar
Fabrice Bellard committed
145 146 147 148 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 184 185 186
{
 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;

int rv_decode_dc(MpegEncContext *s, int n)
{
    int code;

    if (n < 4) {
187
        code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
Fabrice Bellard's avatar
Fabrice Bellard committed
188 189 190 191 192 193
        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) {
194
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
195 196 197
            } else if (code == 0x7d) {
                code = -128 + get_bits(&s->gb, 7);
            } else if (code == 0x7e) {
198
                if (get_bits1(&s->gb) == 0)
199
                    code = (int8_t)(get_bits(&s->gb, 8) + 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
200
                else
201
                    code = (int8_t)(get_bits(&s->gb, 8));
Fabrice Bellard's avatar
Fabrice Bellard committed
202
            } else if (code == 0x7f) {
203
                skip_bits(&s->gb, 11);
Fabrice Bellard's avatar
Fabrice Bellard committed
204 205 206 207 208 209
                code = 1;
            }
        } else {
            code -= 128;
        }
    } else {
210
        code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
Fabrice Bellard's avatar
Fabrice Bellard committed
211 212 213 214
        /* same remark */
        if (code < 0) {
            code = get_bits(&s->gb, 9);
            if (code == 0x1fc) {
215
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
216 217 218
            } else if (code == 0x1fd) {
                code = -128 + get_bits(&s->gb, 7);
            } else if (code == 0x1fe) {
219
                skip_bits(&s->gb, 9);
Fabrice Bellard's avatar
Fabrice Bellard committed
220 221
                code = 1;
            } else {
222
                av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
Fabrice Bellard's avatar
Fabrice Bellard committed
223 224 225 226 227 228 229 230 231
                return 0xffff;
            }
        } else {
            code -= 128;
        }
    }
    return -code;
}

232 233
#ifdef CONFIG_ENCODERS

Fabrice Bellard's avatar
Fabrice Bellard committed
234 235 236
/* write RV 1.0 compatible frame header */
void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
{
237
    int full_frame= 0;
238

Fabrice Bellard's avatar
Fabrice Bellard committed
239
    align_put_bits(&s->pb);
240

241
    put_bits(&s->pb, 1, 1);     /* marker */
Fabrice Bellard's avatar
Fabrice Bellard committed
242 243 244

    put_bits(&s->pb, 1, (s->pict_type == P_TYPE));

245
    put_bits(&s->pb, 1, 0);     /* not PB frame */
Fabrice Bellard's avatar
Fabrice Bellard committed
246 247 248 249

    put_bits(&s->pb, 5, s->qscale);

    if (s->pict_type == I_TYPE) {
250
        /* specific MPEG like DC coding not used */
Fabrice Bellard's avatar
Fabrice Bellard committed
251 252 253
    }
    /* if multiple packets per frame are sent, the position at which
       to display the macro blocks is coded here */
254
    if(!full_frame){
255 256
        put_bits(&s->pb, 6, 0); /* mb_x */
        put_bits(&s->pb, 6, 0); /* mb_y */
257 258
        put_bits(&s->pb, 12, s->mb_width * s->mb_height);
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
259

260
    put_bits(&s->pb, 3, 0);     /* ignored */
Fabrice Bellard's avatar
Fabrice Bellard committed
261 262
}

Michael Niedermayer's avatar
Michael Niedermayer committed
263 264
void rv20_encode_picture_header(MpegEncContext *s, int picture_number){
    put_bits(&s->pb, 2, s->pict_type); //I 0 vs. 1 ?
265
    put_bits(&s->pb, 1, 0);     /* unknown bit */
Michael Niedermayer's avatar
Michael Niedermayer committed
266
    put_bits(&s->pb, 5, s->qscale);
267

Michael Niedermayer's avatar
Michael Niedermayer committed
268 269 270
    put_bits(&s->pb, 8, picture_number&0xFF); //FIXME wrong, but correct is not known
    s->mb_x= s->mb_y= 0;
    ff_h263_encode_mba(s);
271

Michael Niedermayer's avatar
Michael Niedermayer committed
272
    put_bits(&s->pb, 1, s->no_rounding);
273

Michael Niedermayer's avatar
Michael Niedermayer committed
274 275 276 277 278 279 280 281 282 283
    assert(s->f_code == 1);
    assert(s->unrestricted_mv == 1);
//    assert(s->h263_aic== (s->pict_type == I_TYPE));
    assert(s->alt_inter_vlc == 0);
    assert(s->umvplus == 0);
    assert(s->modified_quant==1);
    assert(s->loop_filter==1);

    s->h263_aic= s->pict_type == I_TYPE;
    if(s->h263_aic){
284
        s->y_dc_scale_table=
Michael Niedermayer's avatar
Michael Niedermayer committed
285 286 287 288 289 290 291
        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;
    }
}

292
#if 0 /* unused, remove? */
Fabrice Bellard's avatar
Fabrice Bellard committed
293 294 295 296 297 298 299 300 301 302 303 304
static int get_num(GetBitContext *gb)
{
    int n, n1;

    n = get_bits(gb, 16);
    if (n >= 0x4000) {
        return n - 0x4000;
    } else {
        n1 = get_bits(gb, 16);
        return (n << 16) | n1;
    }
}
305
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
306

307 308
#endif //CONFIG_ENCODERS

Fabrice Bellard's avatar
Fabrice Bellard committed
309 310 311
/* read RV 1.0 compatible frame header */
static int rv10_decode_picture_header(MpegEncContext *s)
{
312
    int mb_count, pb_frame, marker, unk, mb_xy;
313

314
//printf("ff:%d\n", full_frame);
315
    marker = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
316

317
    if (get_bits1(&s->gb))
Fabrice Bellard's avatar
Fabrice Bellard committed
318 319 320
        s->pict_type = P_TYPE;
    else
        s->pict_type = I_TYPE;
321
//printf("h:%X ver:%d\n",h,s->rv10_version);
322
    if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
323
    pb_frame = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
324 325

#ifdef DEBUG
326
    av_log(s->avctx, AV_LOG_DEBUG, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
Fabrice Bellard's avatar
Fabrice Bellard committed
327
#endif
328

329
    if (pb_frame){
330
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
Fabrice Bellard's avatar
Fabrice Bellard committed
331
        return -1;
332
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
333 334

    s->qscale = get_bits(&s->gb, 5);
335
    if(s->qscale==0){
336
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
337 338
        return -1;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
339 340 341 342 343 344 345 346

    if (s->pict_type == I_TYPE) {
        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);
#ifdef DEBUG
347
            av_log(s->avctx, AV_LOG_DEBUG, "DC:%d %d %d\n",
Fabrice Bellard's avatar
Fabrice Bellard committed
348 349 350 351 352 353 354 355
                   s->last_dc[0],
                   s->last_dc[1],
                   s->last_dc[2]);
#endif
        }
    }
    /* if multiple packets per frame are sent, the position at which
       to display the macro blocks is coded here */
356 357 358

    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)){
359 360
        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
361 362 363 364 365 366
        mb_count = get_bits(&s->gb, 12);
    } else {
        s->mb_x = 0;
        s->mb_y = 0;
        mb_count = s->mb_width * s->mb_height;
    }
367
    unk= get_bits(&s->gb, 3);   /* ignored */
368
//printf("%d\n", unk);
Fabrice Bellard's avatar
Fabrice Bellard committed
369 370
    s->f_code = 1;
    s->unrestricted_mv = 1;
371

Fabrice Bellard's avatar
Fabrice Bellard committed
372 373 374
    return mb_count;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
375 376
static int rv20_decode_picture_header(MpegEncContext *s)
{
377
    int seq, mb_pos, i;
378

Michael Niedermayer's avatar
Michael Niedermayer committed
379 380 381 382 383 384 385 386
#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
387
#if 0
388
    av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
389
    for(i=0; i<s->avctx->extradata_size; i++){
390
        av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
391 392 393 394
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
    }
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
#endif
395

396 397 398 399
    if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
        if (get_bits(&s->gb, 3)){
            av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
            return -1;
400 401
        }
    }
402 403 404 405

    i= get_bits(&s->gb, 2);
    switch(i){
    case 0: s->pict_type= I_TYPE; break;
Michael Niedermayer's avatar
Michael Niedermayer committed
406
    case 1: s->pict_type= I_TYPE; break; //hmm ...
407 408
    case 2: s->pict_type= P_TYPE; break;
    case 3: s->pict_type= B_TYPE; break;
409
    default:
410 411 412
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
        return -1;
    }
413

414 415 416 417
    if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
        return -1;
    }
418

419
    if (get_bits1(&s->gb)){
420
        av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
Michael Niedermayer's avatar
Michael Niedermayer committed
421 422 423 424 425 426 427 428
        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;
    }
429
    if(s->avctx->sub_id == 0x30203002){
430
        if (get_bits1(&s->gb)){
431 432 433 434
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
            return -1;
        }
    }
435

436
    if(s->avctx->has_b_frames){
437
        int f, new_w, new_h;
438
        int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
439

440
        if (get_bits1(&s->gb)){
Michael Niedermayer's avatar
Michael Niedermayer committed
441
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
Michael Niedermayer's avatar
Michael Niedermayer committed
442
//            return -1;
443
        }
444
        seq= get_bits(&s->gb, 13)<<2;
445

446 447 448 449 450 451 452 453 454 455 456
        f= get_bits(&s->gb, av_log2(v)+1);

        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{
            new_w= s->width; //FIXME wrong we of course must save the original in the context
            new_h= s->height;
        }
        if(new_w != s->width || new_h != s->height){
            av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
457 458
            if (avcodec_check_dimensions(s->avctx, new_h, new_w) < 0)
                return -1;
459 460 461 462 463 464
            MPV_common_end(s);
            s->width  = s->avctx->width = new_w;
            s->height = s->avctx->height= new_h;
            if (MPV_common_init(s) < 0)
                return -1;
        }
465

Michael Niedermayer's avatar
Michael Niedermayer committed
466
        if(s->avctx->debug & FF_DEBUG_PICT_INFO){
467
            av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
Michael Niedermayer's avatar
Michael Niedermayer committed
468
        }
469 470 471
    }else{
        seq= get_bits(&s->gb, 8)*128;
    }
472

473
//     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
474 475
    mb_pos= ff_h263_decode_mba(s);
/*    }else{
476 477 478
        mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
        s->mb_x= mb_pos % s->mb_width;
        s->mb_y= mb_pos / s->mb_width;
479
    }*/
480
//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
481 482 483
    seq |= s->time &~0x7FFF;
    if(seq - s->time >  0x4000) seq -= 0x8000;
    if(seq - s->time < -0x4000) seq += 0x8000;
484
    if(seq != s->time){
485 486 487 488 489 490 491 492
        if(s->pict_type!=B_TYPE){
            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){
493 494
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
                return FRAME_SKIPPED;
495
            }
496
            ff_mpeg4_init_direct_mv(s);
497 498 499
        }
    }
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
500 501 502 503
/*for(i=0; i<32; i++){
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
}
av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
Michael Niedermayer's avatar
Michael Niedermayer committed
504
    s->no_rounding= get_bits1(&s->gb);
505

Michael Niedermayer's avatar
Michael Niedermayer committed
506 507 508 509 510 511
    s->f_code = 1;
    s->unrestricted_mv = 1;
    s->h263_aic= s->pict_type == I_TYPE;
//    s->alt_inter_vlc=1;
//    s->obmc=1;
//    s->umvplus=1;
Michael Niedermayer's avatar
Michael Niedermayer committed
512 513
    s->modified_quant=1;
    s->loop_filter=1;
514

Michael Niedermayer's avatar
Michael Niedermayer committed
515
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
516
            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
517 518 519
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
    }

520
    assert(s->pict_type != B_TYPE || !s->low_delay);
521

Michael Niedermayer's avatar
Michael Niedermayer committed
522 523 524
    return s->mb_width*s->mb_height - mb_pos;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
525 526 527
static int rv10_decode_init(AVCodecContext *avctx)
{
    MpegEncContext *s = avctx->priv_data;
528
    static int done=0;
Fabrice Bellard's avatar
Fabrice Bellard committed
529

Michael Niedermayer's avatar
Michael Niedermayer committed
530
    MPV_decode_defaults(s);
531

Michael Niedermayer's avatar
Michael Niedermayer committed
532
    s->avctx= avctx;
Fabrice Bellard's avatar
Fabrice Bellard committed
533
    s->out_format = FMT_H263;
Michael Niedermayer's avatar
Michael Niedermayer committed
534
    s->codec_id= avctx->codec_id;
Fabrice Bellard's avatar
Fabrice Bellard committed
535 536 537 538

    s->width = avctx->width;
    s->height = avctx->height;

Michael Niedermayer's avatar
Michael Niedermayer committed
539
    s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
540
    avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
Michael Niedermayer's avatar
Michael Niedermayer committed
541

542
    if (avctx->sub_id == 0x10000000) {
543
        s->rv10_version= 0;
544
        s->low_delay=1;
545
    } else if (avctx->sub_id == 0x10002000) {
Michael Niedermayer's avatar
Michael Niedermayer committed
546 547 548
        s->rv10_version= 3;
        s->low_delay=1;
        s->obmc=1;
549
    } else if (avctx->sub_id == 0x10003000) {
550
        s->rv10_version= 3;
551
        s->low_delay=1;
552
    } else if (avctx->sub_id == 0x10003001) {
553
        s->rv10_version= 3;
554
        s->low_delay=1;
555 556
    } else if (    avctx->sub_id == 0x20001000
               || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
557
        s->low_delay=1;
558 559 560
    } else if (    avctx->sub_id == 0x30202002
               ||  avctx->sub_id == 0x30203002
               || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
561 562
        s->low_delay=0;
        s->avctx->has_b_frames=1;
563
    } else
564
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
565

566 567 568
    if(avctx->debug & FF_DEBUG_PICT_INFO){
        av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
    }
569 570 571

    avctx->pix_fmt = PIX_FMT_YUV420P;

Fabrice Bellard's avatar
Fabrice Bellard committed
572 573 574 575 576 577 578
    if (MPV_common_init(s) < 0)
        return -1;

    h263_decode_init_vlc(s);

    /* init rv vlc */
    if (!done) {
579
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
Fabrice Bellard's avatar
Fabrice Bellard committed
580
                 rv_lum_bits, 1, 1,
581
                 rv_lum_code, 2, 2, 1);
582
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
Fabrice Bellard's avatar
Fabrice Bellard committed
583
                 rv_chrom_bits, 1, 1,
584
                 rv_chrom_code, 2, 2, 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
585 586 587 588 589 590 591 592 593 594 595 596 597 598
        done = 1;
    }

    return 0;
}

static int rv10_decode_end(AVCodecContext *avctx)
{
    MpegEncContext *s = avctx->priv_data;

    MPV_common_end(s);
    return 0;
}

599
static int rv10_decode_packet(AVCodecContext *avctx,
600
                             uint8_t *buf, int buf_size)
Fabrice Bellard's avatar
Fabrice Bellard committed
601 602
{
    MpegEncContext *s = avctx->priv_data;
603
    int mb_count, mb_pos, left, start_mb_x;
Fabrice Bellard's avatar
Fabrice Bellard committed
604

605
    init_get_bits(&s->gb, buf, buf_size*8);
Michael Niedermayer's avatar
Michael Niedermayer committed
606 607 608 609
    if(s->codec_id ==CODEC_ID_RV10)
        mb_count = rv10_decode_picture_header(s);
    else
        mb_count = rv20_decode_picture_header(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
610
    if (mb_count < 0) {
611
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
Fabrice Bellard's avatar
Fabrice Bellard committed
612 613
        return -1;
    }
614

Fabrice Bellard's avatar
Fabrice Bellard committed
615 616
    if (s->mb_x >= s->mb_width ||
        s->mb_y >= s->mb_height) {
617
        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
618 619 620 621 622
        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) {
623
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
Fabrice Bellard's avatar
Fabrice Bellard committed
624 625
        return -1;
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
626
//if(s->pict_type == P_TYPE) return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
627

Michael Niedermayer's avatar
Michael Niedermayer committed
628
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
629 630 631 632 633
        if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
            ff_er_frame_end(s);
            MPV_frame_end(s);
            s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
        }
634 635
        if(MPV_frame_start(s, avctx) < 0)
            return -1;
636
        ff_er_frame_start(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
637 638 639
    }

#ifdef DEBUG
640
    av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
Fabrice Bellard's avatar
Fabrice Bellard committed
641 642 643
#endif

    /* default quantization values */
Michael Niedermayer's avatar
Michael Niedermayer committed
644 645 646
    if(s->codec_id== CODEC_ID_RV10){
        if(s->mb_y==0) s->first_slice_line=1;
    }else{
647
        s->first_slice_line=1;
648
        s->resync_mb_x= s->mb_x;
Michael Niedermayer's avatar
Michael Niedermayer committed
649
    }
650
    start_mb_x= s->mb_x;
651
    s->resync_mb_y= s->mb_y;
Michael Niedermayer's avatar
Michael Niedermayer committed
652
    if(s->h263_aic){
653
        s->y_dc_scale_table=
Michael Niedermayer's avatar
Michael Niedermayer committed
654 655 656 657 658
        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
659 660 661

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

Michael Niedermayer's avatar
Michael Niedermayer committed
663
    ff_set_qscale(s, s->qscale);
Michael Niedermayer's avatar
Michael Niedermayer committed
664

Fabrice Bellard's avatar
Fabrice Bellard committed
665 666 667
    s->rv10_first_dc_coded[0] = 0;
    s->rv10_first_dc_coded[1] = 0;
    s->rv10_first_dc_coded[2] = 0;
668
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
Michael Niedermayer's avatar
Michael Niedermayer committed
669 670 671
    s->block_wrap[0]=
    s->block_wrap[1]=
    s->block_wrap[2]=
672
    s->block_wrap[3]= s->b8_stride;
Michael Niedermayer's avatar
Michael Niedermayer committed
673
    s->block_wrap[4]=
674
    s->block_wrap[5]= s->mb_stride;
675
    ff_init_block_index(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
676
    /* decode each macroblock */
Michael Niedermayer's avatar
Michael Niedermayer committed
677 678

    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
Michael Niedermayer's avatar
Michael Niedermayer committed
679
        int ret;
680
        ff_update_block_index(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
681
#ifdef DEBUG
682
        av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
Fabrice Bellard's avatar
Fabrice Bellard committed
683
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
684

Fabrice Bellard's avatar
Fabrice Bellard committed
685
        s->mv_dir = MV_DIR_FORWARD;
686
        s->mv_type = MV_TYPE_16X16;
Michael Niedermayer's avatar
Michael Niedermayer committed
687 688
        ret=ff_h263_decode_mb(s, s->block);

689
        if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
690
            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
691 692
            return -1;
        }
693 694
        if(s->pict_type != B_TYPE)
            ff_h263_update_motion_val(s);
695
        MPV_decode_mb(s, s->block);
Michael Niedermayer's avatar
Michael Niedermayer committed
696 697 698
        if(s->loop_filter)
            ff_h263_loop_filter(s);

Fabrice Bellard's avatar
Fabrice Bellard committed
699 700 701
        if (++s->mb_x == s->mb_width) {
            s->mb_x = 0;
            s->mb_y++;
702
            ff_init_block_index(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
703
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
704 705 706
        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
707 708
    }

709
    ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
710

711 712 713
    return buf_size;
}

714
static int rv10_decode_frame(AVCodecContext *avctx,
715
                             void *data, int *data_size,
716
                             uint8_t *buf, int buf_size)
717 718 719
{
    MpegEncContext *s = avctx->priv_data;
    int i;
720
    AVFrame *pict = data;
721 722

#ifdef DEBUG
723
    av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
724 725 726 727 728 729
#endif

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

731 732 733 734
    if(avctx->slice_count){
        for(i=0; i<avctx->slice_count; i++){
            int offset= avctx->slice_offset[i];
            int size;
735

736 737 738 739 740
            if(i+1 == avctx->slice_count)
                size= buf_size - offset;
            else
                size= avctx->slice_offset[i+1] - offset;

741
            rv10_decode_packet(avctx, buf+offset, size);
742 743
        }
    }else{
744
        rv10_decode_packet(avctx, buf, buf_size);
745
    }
746

747
    if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
748
        ff_er_frame_end(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
749
        MPV_frame_end(s);
750

751 752 753 754
        if (s->pict_type == B_TYPE || s->low_delay) {
            *pict= *(AVFrame*)s->current_picture_ptr;
        } else if (s->last_picture_ptr != NULL) {
            *pict= *(AVFrame*)s->last_picture_ptr;
755
        }
756 757

        if(s->last_picture_ptr || s->low_delay){
Michael Niedermayer's avatar
Michael Niedermayer committed
758
            *data_size = sizeof(AVFrame);
759 760
            ff_print_debug_info(s, pict);
        }
761
        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
762
    }
763

Fabrice Bellard's avatar
Fabrice Bellard committed
764 765 766 767 768 769 770 771 772 773 774 775
    return buf_size;
}

AVCodec rv10_decoder = {
    "rv10",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV10,
    sizeof(MpegEncContext),
    rv10_decode_init,
    NULL,
    rv10_decode_end,
    rv10_decode_frame,
Michael Niedermayer's avatar
Michael Niedermayer committed
776
    CODEC_CAP_DR1
Fabrice Bellard's avatar
Fabrice Bellard committed
777
};
Michael Niedermayer's avatar
Michael Niedermayer committed
778 779 780 781 782 783 784 785 786 787

AVCodec rv20_decoder = {
    "rv20",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV20,
    sizeof(MpegEncContext),
    rv10_decode_init,
    NULL,
    rv10_decode_end,
    rv10_decode_frame,
788
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
Michael Niedermayer's avatar
Michael Niedermayer committed
789
    .flush= ff_mpeg_flush,
Michael Niedermayer's avatar
Michael Niedermayer committed
790
};
791