rv10.c 24.1 KB
Newer Older
glantau's avatar
glantau committed
1 2
/*
 * RV10 codec
glantau's avatar
glantau committed
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
4
 * Copyright (c) 2002-2004 Michael Niedermayer
glantau's avatar
glantau committed
5
 *
glantau's avatar
glantau committed
6 7 8 9
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
glantau's avatar
glantau committed
10
 *
glantau's avatar
glantau committed
11
 * This library is distributed in the hope that it will be useful,
glantau's avatar
glantau committed
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
glantau's avatar
glantau committed
13 14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
glantau's avatar
glantau committed
15
 *
glantau's avatar
glantau committed
16 17
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
glantau's avatar
glantau committed
19
 */
michaelni's avatar
michaelni committed
20 21 22 23 24

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

glantau's avatar
glantau committed
26
#include "avcodec.h"
27
#include "dsputil.h"
glantau's avatar
glantau committed
28 29 30 31
#include "mpegvideo.h"

//#define DEBUG

32
#define DC_VLC_BITS 14 //FIXME find a better solution
michaelni's avatar
michaelni committed
33

kabi's avatar
kabi committed
34
static const uint16_t rv_lum_code[256] =
glantau's avatar
glantau committed
35 36 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
{
 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,
};

70
static const uint8_t rv_lum_bits[256] =
glantau's avatar
glantau committed
71 72 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
{
 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,
};

kabi's avatar
kabi committed
106
static const uint16_t rv_chrom_code[256] =
glantau's avatar
glantau committed
107 108 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
{
 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,
};

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

230 231
#ifdef CONFIG_ENCODERS

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

glantau's avatar
glantau committed
237
    align_put_bits(&s->pb);
238

239
    put_bits(&s->pb, 1, 1);     /* marker */
glantau's avatar
glantau committed
240 241 242

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

243
    put_bits(&s->pb, 1, 0);     /* not PB frame */
glantau's avatar
glantau committed
244 245 246 247

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

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

258
    put_bits(&s->pb, 3, 0);     /* ignored */
glantau's avatar
glantau committed
259 260
}

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

michael's avatar
michael committed
266 267 268
    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);
269

michael's avatar
michael committed
270
    put_bits(&s->pb, 1, s->no_rounding);
271

michael's avatar
michael committed
272 273 274 275 276 277 278 279 280 281
    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){
282
        s->y_dc_scale_table=
michael's avatar
michael committed
283 284 285 286 287 288 289
        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;
    }
}

290
#if 0 /* unused, remove? */
glantau's avatar
glantau committed
291 292 293 294 295 296 297 298 299 300 301 302
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;
    }
}
303
#endif
glantau's avatar
glantau committed
304

305 306
#endif //CONFIG_ENCODERS

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

312
//printf("ff:%d\n", full_frame);
glantau's avatar
glantau committed
313 314 315 316 317 318
    marker = get_bits(&s->gb, 1);

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

#ifdef DEBUG
diego's avatar
diego committed
324
    av_log(s->avctx, AV_LOG_DEBUG, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
glantau's avatar
glantau committed
325
#endif
326

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

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

    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
diego's avatar
diego committed
345
            av_log(s->avctx, AV_LOG_DEBUG, "DC:%d %d %d\n",
glantau's avatar
glantau committed
346 347 348 349 350 351 352 353
                   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 */
354 355 356

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

glantau's avatar
glantau committed
370 371 372
    return mb_count;
}

michael's avatar
michael committed
373 374
static int rv20_decode_picture_header(MpegEncContext *s)
{
michael's avatar
michael committed
375
    int seq, mb_pos, i;
376

michael's avatar
michael committed
377 378 379 380 381 382 383 384
#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
michael's avatar
michael committed
385 386 387 388 389 390 391
#if 0
    for(i=0; i<s->avctx->extradata_size; i++){
        av_log(s->avctx, AV_LOG_DEBUG, "%2X ", ((uint8_t*)s->avctx->extradata)[i]);
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
    }
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
#endif
392

393 394 395 396
    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;
397 398
        }
    }
michael's avatar
michael committed
399 400 401 402

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

michael's avatar
michael committed
411 412 413 414
    if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
        return -1;
    }
415

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

433
    if(s->avctx->has_b_frames){
michael's avatar
michael committed
434 435
        int f=9;
        int v= s->avctx->extradata_size >= 4 ? ((uint8_t*)s->avctx->extradata)[1] : 0;
michael's avatar
michael committed
436

437
        if (get_bits(&s->gb, 1)){
michael's avatar
michael committed
438
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
michael's avatar
 
michael committed
439
//            return -1;
440
        }
michael's avatar
michael committed
441
        seq= get_bits(&s->gb, 14)<<1;
michael's avatar
michael committed
442

443
        if(v)
michael's avatar
michael committed
444 445
            f= get_bits(&s->gb, av_log2(v));

michael's avatar
michael committed
446
        if(s->avctx->debug & FF_DEBUG_PICT_INFO){
447
            av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
michael's avatar
michael committed
448
        }
michael's avatar
michael committed
449 450 451
    }else{
        seq= get_bits(&s->gb, 8)*128;
    }
michael's avatar
michael committed
452

453
//     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
michael's avatar
michael committed
454 455
    mb_pos= ff_h263_decode_mba(s);
/*    }else{
michael's avatar
michael committed
456 457 458
        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;
michael's avatar
michael committed
459
    }*/
michael's avatar
michael committed
460
//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
461 462 463
    seq |= s->time &~0x7FFF;
    if(seq - s->time >  0x4000) seq -= 0x8000;
    if(seq - s->time < -0x4000) seq += 0x8000;
464
    if(seq != s->time){
465 466 467 468 469 470 471 472
        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){
473 474
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
                return FRAME_SKIPPED;
475
            }
476
            ff_mpeg4_init_direct_mv(s);
477 478 479
        }
    }
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
michael's avatar
michael committed
480 481 482 483
/*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's avatar
michael committed
484
    s->no_rounding= get_bits1(&s->gb);
485

michael's avatar
michael committed
486 487 488 489 490 491
    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's avatar
michael committed
492 493
    s->modified_quant=1;
    s->loop_filter=1;
494

michael's avatar
michael committed
495
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
496
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
michael's avatar
michael committed
497 498 499
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
    }

500
    assert(s->pict_type != B_TYPE || !s->low_delay);
michael's avatar
michael committed
501

michael's avatar
michael committed
502 503 504
    return s->mb_width*s->mb_height - mb_pos;
}

glantau's avatar
glantau committed
505 506 507
static int rv10_decode_init(AVCodecContext *avctx)
{
    MpegEncContext *s = avctx->priv_data;
508
    static int done=0;
glantau's avatar
glantau committed
509

michael's avatar
michael committed
510
    MPV_decode_defaults(s);
511

michaelni's avatar
michaelni committed
512
    s->avctx= avctx;
glantau's avatar
glantau committed
513
    s->out_format = FMT_H263;
michael's avatar
michael committed
514
    s->codec_id= avctx->codec_id;
glantau's avatar
glantau committed
515 516 517 518

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

michael's avatar
michael committed
519 520
    s->h263_long_vectors= !!(*(uint32_t*)avctx->extradata & 0x1000000);

521 522 523
    switch(avctx->sub_id){
    case 0x10000000:
        s->rv10_version= 0;
524
        s->low_delay=1;
525
        break;
michael's avatar
michael committed
526 527 528 529 530
    case 0x10002000:
        s->rv10_version= 3;
        s->low_delay=1;
        s->obmc=1;
        break;
531 532
    case 0x10003000:
        s->rv10_version= 3;
533
        s->low_delay=1;
534 535 536
        break;
    case 0x10003001:
        s->rv10_version= 3;
537
        s->low_delay=1;
538
        break;
michael's avatar
michael committed
539 540
    case 0x20001000: /* real rv20 decoder fail on this id */
    /*case 0x20100001:
541
    case 0x20101001:
michael's avatar
michael committed
542 543
    case 0x20103001:*/
    case 0x20100000 ... 0x2019ffff:
544 545
        s->low_delay=1;
        break;
michael's avatar
michael committed
546
    /*case 0x20200002:
michael's avatar
michael committed
547
    case 0x20201002:
michael's avatar
michael committed
548 549
    case 0x20203002:*/
    case 0x20200002 ... 0x202fffff:
550 551 552 553 554
    case 0x30202002:
    case 0x30203002:
        s->low_delay=0;
        s->avctx->has_b_frames=1;
        break;
555
    default:
556
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
557
    }
558

michael's avatar
michael committed
559 560 561
    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);
    }
michael's avatar
michael committed
562 563 564

    avctx->pix_fmt = PIX_FMT_YUV420P;

glantau's avatar
glantau committed
565 566 567 568 569 570 571
    if (MPV_common_init(s) < 0)
        return -1;

    h263_decode_init_vlc(s);

    /* init rv vlc */
    if (!done) {
572
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
glantau's avatar
glantau committed
573
                 rv_lum_bits, 1, 1,
574
                 rv_lum_code, 2, 2, 1);
575
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
glantau's avatar
glantau committed
576
                 rv_chrom_bits, 1, 1,
577
                 rv_chrom_code, 2, 2, 1);
glantau's avatar
glantau committed
578 579 580 581 582 583 584 585 586 587 588 589 590 591
        done = 1;
    }

    return 0;
}

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

    MPV_common_end(s);
    return 0;
}

592
static int rv10_decode_packet(AVCodecContext *avctx,
kabi's avatar
kabi committed
593
                             uint8_t *buf, int buf_size)
glantau's avatar
glantau committed
594 595
{
    MpegEncContext *s = avctx->priv_data;
596
    int mb_count, mb_pos, left, start_mb_x;
glantau's avatar
glantau committed
597

598
    init_get_bits(&s->gb, buf, buf_size*8);
michael's avatar
michael committed
599 600 601 602
    if(s->codec_id ==CODEC_ID_RV10)
        mb_count = rv10_decode_picture_header(s);
    else
        mb_count = rv20_decode_picture_header(s);
glantau's avatar
glantau committed
603
    if (mb_count < 0) {
604
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
glantau's avatar
glantau committed
605 606
        return -1;
    }
607

glantau's avatar
glantau committed
608 609
    if (s->mb_x >= s->mb_width ||
        s->mb_y >= s->mb_height) {
610
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
glantau's avatar
glantau committed
611 612 613 614 615
        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) {
616
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
glantau's avatar
glantau committed
617 618
        return -1;
    }
michael's avatar
michael committed
619
//if(s->pict_type == P_TYPE) return 0;
glantau's avatar
glantau committed
620

michael's avatar
 
michael committed
621
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
michael's avatar
michael committed
622 623 624 625 626
        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;
        }
627 628
        if(MPV_frame_start(s, avctx) < 0)
            return -1;
michael's avatar
michael committed
629
        ff_er_frame_start(s);
glantau's avatar
glantau committed
630 631 632
    }

#ifdef DEBUG
diego's avatar
diego committed
633
    av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
glantau's avatar
glantau committed
634 635 636
#endif

    /* default quantization values */
michael's avatar
michael committed
637 638 639
    if(s->codec_id== CODEC_ID_RV10){
        if(s->mb_y==0) s->first_slice_line=1;
    }else{
640
        s->first_slice_line=1;
641
        s->resync_mb_x= s->mb_x;
michael's avatar
michael committed
642
    }
643
    start_mb_x= s->mb_x;
644
    s->resync_mb_y= s->mb_y;
michael's avatar
michael committed
645
    if(s->h263_aic){
646
        s->y_dc_scale_table=
michael's avatar
michael committed
647 648 649 650 651
        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's avatar
michael committed
652 653 654

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

michael's avatar
michael committed
656
    ff_set_qscale(s, s->qscale);
michael's avatar
michael committed
657

glantau's avatar
glantau committed
658 659 660
    s->rv10_first_dc_coded[0] = 0;
    s->rv10_first_dc_coded[1] = 0;
    s->rv10_first_dc_coded[2] = 0;
michael's avatar
michael committed
661
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
michaelni's avatar
 
michaelni committed
662 663 664
    s->block_wrap[0]=
    s->block_wrap[1]=
    s->block_wrap[2]=
665
    s->block_wrap[3]= s->b8_stride;
michaelni's avatar
 
michaelni committed
666
    s->block_wrap[4]=
667
    s->block_wrap[5]= s->mb_stride;
668
    ff_init_block_index(s);
glantau's avatar
glantau committed
669
    /* decode each macroblock */
michael's avatar
michael committed
670 671

    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
michael's avatar
michael committed
672
        int ret;
673
        ff_update_block_index(s);
glantau's avatar
glantau committed
674
#ifdef DEBUG
diego's avatar
diego committed
675
        av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
glantau's avatar
glantau committed
676
#endif
michael's avatar
michael committed
677

glantau's avatar
glantau committed
678
        s->mv_dir = MV_DIR_FORWARD;
679
        s->mv_type = MV_TYPE_16X16;
michael's avatar
michael committed
680 681
        ret=ff_h263_decode_mb(s, s->block);

michael's avatar
michael committed
682
        if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
683
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
glantau's avatar
glantau committed
684 685
            return -1;
        }
michael's avatar
michael committed
686 687
        if(s->pict_type != B_TYPE)
            ff_h263_update_motion_val(s);
688
        MPV_decode_mb(s, s->block);
michael's avatar
michael committed
689 690 691
        if(s->loop_filter)
            ff_h263_loop_filter(s);

glantau's avatar
glantau committed
692 693 694
        if (++s->mb_x == s->mb_width) {
            s->mb_x = 0;
            s->mb_y++;
695
            ff_init_block_index(s);
glantau's avatar
glantau committed
696
        }
michael's avatar
michael committed
697 698 699
        if(s->mb_x == s->resync_mb_x)
            s->first_slice_line=0;
        if(ret == SLICE_END) break;
glantau's avatar
glantau committed
700 701
    }

702
    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);
michael's avatar
michael committed
703

704 705 706
    return buf_size;
}

707
static int rv10_decode_frame(AVCodecContext *avctx,
708
                             void *data, int *data_size,
kabi's avatar
kabi committed
709
                             uint8_t *buf, int buf_size)
710 711 712
{
    MpegEncContext *s = avctx->priv_data;
    int i;
713
    AVFrame *pict = data;
714 715

#ifdef DEBUG
diego's avatar
diego committed
716
    av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
717 718 719 720 721 722
#endif

    /* no supplementary picture */
    if (buf_size == 0) {
        return 0;
    }
michael's avatar
michael committed
723

724 725 726 727
    if(avctx->slice_count){
        for(i=0; i<avctx->slice_count; i++){
            int offset= avctx->slice_offset[i];
            int size;
728

729 730 731 732 733
            if(i+1 == avctx->slice_count)
                size= buf_size - offset;
            else
                size= avctx->slice_offset[i+1] - offset;

michael's avatar
michael committed
734
            rv10_decode_packet(avctx, buf+offset, size);
735 736
        }
    }else{
michael's avatar
michael committed
737
        rv10_decode_packet(avctx, buf, buf_size);
738
    }
739

740
    if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
michael's avatar
michael committed
741
        ff_er_frame_end(s);
glantau's avatar
glantau committed
742
        MPV_frame_end(s);
743

744 745 746 747
        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;
748
        }
749 750

        if(s->last_picture_ptr || s->low_delay){
michael's avatar
michael committed
751
            *data_size = sizeof(AVFrame);
752 753
            ff_print_debug_info(s, pict);
        }
michael's avatar
michael committed
754
        s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
glantau's avatar
glantau committed
755
    }
756

glantau's avatar
glantau committed
757 758 759 760 761 762 763 764 765 766 767 768
    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,
michaelni's avatar
dr1  
michaelni committed
769
    CODEC_CAP_DR1
glantau's avatar
glantau committed
770
};
michael's avatar
michael committed
771 772 773 774 775 776 777 778 779 780

AVCodec rv20_decoder = {
    "rv20",
    CODEC_TYPE_VIDEO,
    CODEC_ID_RV20,
    sizeof(MpegEncContext),
    rv10_decode_init,
    NULL,
    rv10_decode_end,
    rv10_decode_frame,
781
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
michael's avatar
michael committed
782
    .flush= ff_mpeg_flush,
michael's avatar
michael committed
783
};
784