libavcodec/rv10.c

   1 /*
   2  * RV10 codec
   3  * Copyright (c) 2000,2001 Fabrice Bellard
   4  * Copyright (c) 2002-2004 Michael Niedermayer
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  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
  21  */
  22
  23 /**
  24  * @file libavcodec/rv10.c
  25  * RV10 codec.
  26  */
  27
  28 #include "avcodec.h"
  29 #include "dsputil.h"
  30 #include "mpegvideo.h"
  31
  32 //#define DEBUG
  33
  34 #define DC_VLC_BITS 14 //FIXME find a better solution
  35
  36 static const uint16_t rv_lum_code[256] =
  37 {
  38  0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
  39  0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
  40  0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
  41  0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
  42  0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
  43  0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
  44  0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
  45  0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
  46  0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
  47  0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
  48  0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
  49  0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
  50  0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
  51  0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
  52  0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
  53  0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
  54  0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
  55  0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
  56  0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
  57  0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
  58  0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
  59  0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
  60  0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
  61  0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
  62  0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
  63  0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
  64  0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
  65  0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
  66  0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
  67  0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
  68  0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
  69  0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
  70 };
  71
  72 static const uint8_t rv_lum_bits[256] =
  73 {
  74  14, 12, 12, 12, 12, 12, 12, 12,
  75  12, 12, 12, 12, 12, 12, 12, 12,
  76  12, 12, 12, 12, 12, 12, 12, 12,
  77  12, 12, 12, 12, 12, 12, 12, 12,
  78  12, 12, 12, 12, 12, 12, 12, 12,
  79  12, 12, 12, 12, 12, 12, 12, 12,
  80  12, 12, 12, 12, 12, 12, 12, 12,
  81  12, 12, 12, 12, 12, 12, 12, 12,
  82  12, 10, 10, 10, 10, 10, 10, 10,
  83  10, 10, 10, 10, 10, 10, 10, 10,
  84  10, 10, 10, 10, 10, 10, 10, 10,
  85  10, 10, 10, 10, 10, 10, 10, 10,
  86  10,  8,  8,  8,  8,  8,  8,  8,
  87   8,  8,  8,  8,  8,  8,  8,  8,
  88   8,  7,  7,  7,  7,  7,  7,  7,
  89   7,  6,  6,  6,  6,  5,  5,  4,
  90   2,  4,  5,  5,  6,  6,  6,  6,
  91   7,  7,  7,  7,  7,  7,  7,  7,
  92   8,  8,  8,  8,  8,  8,  8,  8,
  93   8,  8,  8,  8,  8,  8,  8,  8,
  94  10, 10, 10, 10, 10, 10, 10, 10,
  95  10, 10, 10, 10, 10, 10, 10, 10,
  96  10, 10, 10, 10, 10, 10, 10, 10,
  97  10, 10, 10, 10, 10, 10, 10, 10,
  98  12, 12, 12, 12, 12, 12, 12, 12,
  99  12, 12, 12, 12, 12, 12, 12, 12,
 100  12, 12, 12, 12, 12, 12, 12, 12,
 101  12, 12, 12, 12, 12, 12, 12, 12,
 102  12, 12, 12, 12, 12, 12, 12, 12,
 103  12, 12, 12, 12, 12, 12, 12, 12,
 104  12, 12, 12, 12, 12, 12, 12, 12,
 105  12, 12, 12, 12, 12, 12, 12, 12,
 106 };
 107
 108 static const uint16_t rv_chrom_code[256] =
 109 {
 110  0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
 111  0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
 112  0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
 113  0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
 114  0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
 115  0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
 116  0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
 117  0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
 118  0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
 119  0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
 120  0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
 121  0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
 122  0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
 123  0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
 124  0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
 125  0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
 126  0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
 127  0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
 128  0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
 129  0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
 130  0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
 131  0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
 132  0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
 133  0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
 134  0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
 135  0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
 136  0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
 137  0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
 138  0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
 139  0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
 140  0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
 141  0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
 142 };
 143
 144 static const uint8_t rv_chrom_bits[256] =
 145 {
 146  16, 14, 14, 14, 14, 14, 14, 14,
 147  14, 14, 14, 14, 14, 14, 14, 14,
 148  14, 14, 14, 14, 14, 14, 14, 14,
 149  14, 14, 14, 14, 14, 14, 14, 14,
 150  14, 14, 14, 14, 14, 14, 14, 14,
 151  14, 14, 14, 14, 14, 14, 14, 14,
 152  14, 14, 14, 14, 14, 14, 14, 14,
 153  14, 14, 14, 14, 14, 14, 14, 14,
 154  14, 12, 12, 12, 12, 12, 12, 12,
 155  12, 12, 12, 12, 12, 12, 12, 12,
 156  12, 12, 12, 12, 12, 12, 12, 12,
 157  12, 12, 12, 12, 12, 12, 12, 12,
 158  12, 10, 10, 10, 10, 10, 10, 10,
 159  10, 10, 10, 10, 10, 10, 10, 10,
 160  10,  8,  8,  8,  8,  8,  8,  8,
 161   8,  6,  6,  6,  6,  4,  4,  3,
 162   2,  3,  4,  4,  6,  6,  6,  6,
 163   8,  8,  8,  8,  8,  8,  8,  8,
 164  10, 10, 10, 10, 10, 10, 10, 10,
 165  10, 10, 10, 10, 10, 10, 10, 10,
 166  12, 12, 12, 12, 12, 12, 12, 12,
 167  12, 12, 12, 12, 12, 12, 12, 12,
 168  12, 12, 12, 12, 12, 12, 12, 12,
 169  12, 12, 12, 12, 12, 12, 12, 12,
 170  14, 14, 14, 14, 14, 14, 14, 14,
 171  14, 14, 14, 14, 14, 14, 14, 14,
 172  14, 14, 14, 14, 14, 14, 14, 14,
 173  14, 14, 14, 14, 14, 14, 14, 14,
 174  14, 14, 14, 14, 14, 14, 14, 14,
 175  14, 14, 14, 14, 14, 14, 14, 14,
 176  14, 14, 14, 14, 14, 14, 14, 14,
 177  14, 14, 14, 14, 14, 14, 14, 14,
 178 };
 179
 180 static VLC rv_dc_lum, rv_dc_chrom;
 181
 182 int rv_decode_dc(MpegEncContext *s, int n)
 183 {
 184     int code;
 185
 186     if (n < 4) {
 187         code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
 188         if (code < 0) {
 189             /* XXX: I don't understand why they use LONGER codes than
 190                necessary. The following code would be completely useless
 191                if they had thought about it !!! */
 192             code = get_bits(&s->gb, 7);
 193             if (code == 0x7c) {
 194                 code = (int8_t)(get_bits(&s->gb, 7) + 1);
 195             } else if (code == 0x7d) {
 196                 code = -128 + get_bits(&s->gb, 7);
 197             } else if (code == 0x7e) {
 198                 if (get_bits1(&s->gb) == 0)
 199                     code = (int8_t)(get_bits(&s->gb, 8) + 1);
 200                 else
 201                     code = (int8_t)(get_bits(&s->gb, 8));
 202             } else if (code == 0x7f) {
 203                 skip_bits(&s->gb, 11);
 204                 code = 1;
 205             }
 206         } else {
 207             code -= 128;
 208         }
 209     } else {
 210         code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
 211         /* same remark */
 212         if (code < 0) {
 213             code = get_bits(&s->gb, 9);
 214             if (code == 0x1fc) {
 215                 code = (int8_t)(get_bits(&s->gb, 7) + 1);
 216             } else if (code == 0x1fd) {
 217                 code = -128 + get_bits(&s->gb, 7);
 218             } else if (code == 0x1fe) {
 219                 skip_bits(&s->gb, 9);
 220                 code = 1;
 221             } else {
 222                 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
 223                 return 0xffff;
 224             }
 225         } else {
 226             code -= 128;
 227         }
 228     }
 229     return -code;
 230 }
 231
 232
 233 #if CONFIG_RV10_ENCODER || CONFIG_RV20_ENCODER
 234 /* write RV 1.0 compatible frame header */
 235 void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
 236 {
 237     int full_frame= 0;
 238
 239     align_put_bits(&s->pb);
 240
 241     put_bits(&s->pb, 1, 1);     /* marker */
 242
 243     put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE));
 244
 245     put_bits(&s->pb, 1, 0);     /* not PB frame */
 246
 247     put_bits(&s->pb, 5, s->qscale);
 248
 249     if (s->pict_type == FF_I_TYPE) {
 250         /* specific MPEG like DC coding not used */
 251     }
 252     /* if multiple packets per frame are sent, the position at which
 253        to display the macroblocks is coded here */
 254     if(!full_frame){
 255         put_bits(&s->pb, 6, 0); /* mb_x */
 256         put_bits(&s->pb, 6, 0); /* mb_y */
 257         put_bits(&s->pb, 12, s->mb_width * s->mb_height);
 258     }
 259
 260     put_bits(&s->pb, 3, 0);     /* ignored */
 261 }
 262
 263 void rv20_encode_picture_header(MpegEncContext *s, int picture_number){
 264     put_bits(&s->pb, 2, s->pict_type); //I 0 vs. 1 ?
 265     put_bits(&s->pb, 1, 0);     /* unknown bit */
 266     put_bits(&s->pb, 5, s->qscale);
 267
 268     put_sbits(&s->pb, 8, picture_number); //FIXME wrong, but correct is not known
 269     s->mb_x= s->mb_y= 0;
 270     ff_h263_encode_mba(s);
 271
 272     put_bits(&s->pb, 1, s->no_rounding);
 273
 274     assert(s->f_code == 1);
 275     assert(s->unrestricted_mv == 1);
 276     assert(s->alt_inter_vlc == 0);
 277     assert(s->umvplus == 0);
 278     assert(s->modified_quant==1);
 279     assert(s->loop_filter==1);
 280
 281     s->h263_aic= s->pict_type == FF_I_TYPE;
 282     if(s->h263_aic){
 283         s->y_dc_scale_table=
 284         s->c_dc_scale_table= ff_aic_dc_scale_table;
 285     }else{
 286         s->y_dc_scale_table=
 287         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 288     }
 289 }
 290
 291 #endif /* CONFIG_RV10_ENCODER || CONFIG_RV20_ENCODER */
 292
 293 /* read RV 1.0 compatible frame header */
 294 static int rv10_decode_picture_header(MpegEncContext *s)
 295 {
 296     int mb_count, pb_frame, marker, unk, mb_xy;
 297
 298     marker = get_bits1(&s->gb);
 299
 300     if (get_bits1(&s->gb))
 301         s->pict_type = FF_P_TYPE;
 302     else
 303         s->pict_type = FF_I_TYPE;
 304     if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
 305     pb_frame = get_bits1(&s->gb);
 306
 307     dprintf(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
 308
 309     if (pb_frame){
 310         av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
 311         return -1;
 312     }
 313
 314     s->qscale = get_bits(&s->gb, 5);
 315     if(s->qscale==0){
 316         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 317         return -1;
 318     }
 319
 320     if (s->pict_type == FF_I_TYPE) {
 321         if (s->rv10_version == 3) {
 322             /* specific MPEG like DC coding not used */
 323             s->last_dc[0] = get_bits(&s->gb, 8);
 324             s->last_dc[1] = get_bits(&s->gb, 8);
 325             s->last_dc[2] = get_bits(&s->gb, 8);
 326             dprintf(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
 327                     s->last_dc[1], s->last_dc[2]);
 328         }
 329     }
 330     /* if multiple packets per frame are sent, the position at which
 331        to display the macroblocks is coded here */
 332
 333     mb_xy= s->mb_x + s->mb_y*s->mb_width;
 334     if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
 335         s->mb_x = get_bits(&s->gb, 6); /* mb_x */
 336         s->mb_y = get_bits(&s->gb, 6); /* mb_y */
 337         mb_count = get_bits(&s->gb, 12);
 338     } else {
 339         s->mb_x = 0;
 340         s->mb_y = 0;
 341         mb_count = s->mb_width * s->mb_height;
 342     }
 343     unk= get_bits(&s->gb, 3);   /* ignored */
 344     s->f_code = 1;
 345     s->unrestricted_mv = 1;
 346
 347     return mb_count;
 348 }
 349
 350 static int rv20_decode_picture_header(MpegEncContext *s)
 351 {
 352     int seq, mb_pos, i;
 353
 354 #if 0
 355     GetBitContext gb= s->gb;
 356     for(i=0; i<64; i++){
 357         av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
 358         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
 359     }
 360     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 361 #endif
 362 #if 0
 363     av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
 364     for(i=0; i<s->avctx->extradata_size; i++){
 365         av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
 366         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
 367     }
 368     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 369 #endif
 370
 371     if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
 372         if (get_bits(&s->gb, 3)){
 373             av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
 374             return -1;
 375         }
 376     }
 377
 378     i= get_bits(&s->gb, 2);
 379     switch(i){
 380     case 0: s->pict_type= FF_I_TYPE; break;
 381     case 1: s->pict_type= FF_I_TYPE; break; //hmm ...
 382     case 2: s->pict_type= FF_P_TYPE; break;
 383     case 3: s->pict_type= FF_B_TYPE; break;
 384     default:
 385         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
 386         return -1;
 387     }
 388
 389     if(s->last_picture_ptr==NULL && s->pict_type==FF_B_TYPE){
 390         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
 391         return -1;
 392     }
 393
 394     if (get_bits1(&s->gb)){
 395         av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
 396         return -1;
 397     }
 398
 399     s->qscale = get_bits(&s->gb, 5);
 400     if(s->qscale==0){
 401         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 402         return -1;
 403     }
 404     if(s->avctx->sub_id == 0x30203002){
 405         if (get_bits1(&s->gb)){
 406             av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
 407             return -1;
 408         }
 409     }
 410
 411     if(s->avctx->has_b_frames){
 412         int f, new_w, new_h;
 413         int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
 414
 415         if (get_bits1(&s->gb)){
 416             av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
 417         }
 418         seq= get_bits(&s->gb, 13)<<2;
 419
 420         f= get_bits(&s->gb, av_log2(v)+1);
 421
 422         if(f){
 423             new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
 424             new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
 425         }else{
 426             new_w= s->width; //FIXME wrong we of course must save the original in the context
 427             new_h= s->height;
 428         }
 429         if(new_w != s->width || new_h != s->height){
 430             av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
 431             if (avcodec_check_dimensions(s->avctx, new_h, new_w) < 0)
 432                 return -1;
 433             MPV_common_end(s);
 434             s->width  = s->avctx->width = new_w;
 435             s->height = s->avctx->height= new_h;
 436             if (MPV_common_init(s) < 0)
 437                 return -1;
 438         }
 439
 440         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 441             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
 442         }
 443     }else{
 444         seq= get_bits(&s->gb, 8)*128;
 445     }
 446
 447 //     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
 448     mb_pos= ff_h263_decode_mba(s);
 449 /*    }else{
 450         mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
 451         s->mb_x= mb_pos % s->mb_width;
 452         s->mb_y= mb_pos / s->mb_width;
 453     }*/
 454 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
 455     seq |= s->time &~0x7FFF;
 456     if(seq - s->time >  0x4000) seq -= 0x8000;
 457     if(seq - s->time < -0x4000) seq += 0x8000;
 458     if(seq != s->time){
 459         if(s->pict_type!=FF_B_TYPE){
 460             s->time= seq;
 461             s->pp_time= s->time - s->last_non_b_time;
 462             s->last_non_b_time= s->time;
 463         }else{
 464             s->time= seq;
 465             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
 466             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
 467                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
 468                 return FRAME_SKIPPED;
 469             }
 470             ff_mpeg4_init_direct_mv(s);
 471         }
 472     }
 473 //    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
 474 /*for(i=0; i<32; i++){
 475     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
 476 }
 477 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
 478     s->no_rounding= get_bits1(&s->gb);
 479
 480     s->f_code = 1;
 481     s->unrestricted_mv = 1;
 482     s->h263_aic= s->pict_type == FF_I_TYPE;
 483 //    s->alt_inter_vlc=1;
 484 //    s->obmc=1;
 485 //    s->umvplus=1;
 486     s->modified_quant=1;
 487     if(!s->avctx->lowres)
 488         s->loop_filter=1;
 489
 490     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 491             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
 492                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
 493     }
 494
 495     assert(s->pict_type != FF_B_TYPE || !s->low_delay);
 496
 497     return s->mb_width*s->mb_height - mb_pos;
 498 }
 499
 500 static av_cold int rv10_decode_init(AVCodecContext *avctx)
 501 {
 502     MpegEncContext *s = avctx->priv_data;
 503     static int done=0;
 504
 505     if (avctx->extradata_size < 8) {
 506         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
 507         return -1;
 508     }
 509
 510     MPV_decode_defaults(s);
 511
 512     s->avctx= avctx;
 513     s->out_format = FMT_H263;
 514     s->codec_id= avctx->codec_id;
 515
 516     s->width = avctx->coded_width;
 517     s->height = avctx->coded_height;
 518
 519     s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
 520     avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
 521
 522     if (avctx->sub_id == 0x10000000) {
 523         s->rv10_version= 0;
 524         s->low_delay=1;
 525     } else if (avctx->sub_id == 0x10001000) {
 526         s->rv10_version= 3;
 527         s->low_delay=1;
 528     } else if (avctx->sub_id == 0x10002000) {
 529         s->rv10_version= 3;
 530         s->low_delay=1;
 531         s->obmc=1;
 532     } else if (avctx->sub_id == 0x10003000) {
 533         s->rv10_version= 3;
 534         s->low_delay=1;
 535     } else if (avctx->sub_id == 0x10003001) {
 536         s->rv10_version= 3;
 537         s->low_delay=1;
 538     } else if (    avctx->sub_id == 0x20001000
 539                || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
 540         s->low_delay=1;
 541     } else if (    avctx->sub_id == 0x30202002
 542                ||  avctx->sub_id == 0x30203002
 543                || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
 544         s->low_delay=0;
 545         s->avctx->has_b_frames=1;
 546     } else
 547         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
 548
 549     if(avctx->debug & FF_DEBUG_PICT_INFO){
 550         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
 551     }
 552
 553     avctx->pix_fmt = PIX_FMT_YUV420P;
 554
 555     if (MPV_common_init(s) < 0)
 556         return -1;
 557
 558     h263_decode_init_vlc(s);
 559
 560     /* init rv vlc */
 561     if (!done) {
 562         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
 563                  rv_lum_bits, 1, 1,
 564                  rv_lum_code, 2, 2, 16384);
 565         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
 566                  rv_chrom_bits, 1, 1,
 567                  rv_chrom_code, 2, 2, 16388);
 568         done = 1;
 569     }
 570
 571     return 0;
 572 }
 573
 574 static av_cold int rv10_decode_end(AVCodecContext *avctx)
 575 {
 576     MpegEncContext *s = avctx->priv_data;
 577
 578     MPV_common_end(s);
 579     return 0;
 580 }
 581
 582 static int rv10_decode_packet(AVCodecContext *avctx,
 583                              const uint8_t *buf, int buf_size)
 584 {
 585     MpegEncContext *s = avctx->priv_data;
 586     int mb_count, mb_pos, left, start_mb_x;
 587
 588     init_get_bits(&s->gb, buf, buf_size*8);
 589     if(s->codec_id ==CODEC_ID_RV10)
 590         mb_count = rv10_decode_picture_header(s);
 591     else
 592         mb_count = rv20_decode_picture_header(s);
 593     if (mb_count < 0) {
 594         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 595         return -1;
 596     }
 597
 598     if (s->mb_x >= s->mb_width ||
 599         s->mb_y >= s->mb_height) {
 600         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 601         return -1;
 602     }
 603     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 604     left = s->mb_width * s->mb_height - mb_pos;
 605     if (mb_count > left) {
 606         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 607         return -1;
 608     }
 609
 610     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
 611         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
 612             ff_er_frame_end(s);
 613             MPV_frame_end(s);
 614             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
 615         }
 616         if(MPV_frame_start(s, avctx) < 0)
 617             return -1;
 618         ff_er_frame_start(s);
 619     }
 620
 621     dprintf(avctx, "qscale=%d\n", s->qscale);
 622
 623     /* default quantization values */
 624     if(s->codec_id== CODEC_ID_RV10){
 625         if(s->mb_y==0) s->first_slice_line=1;
 626     }else{
 627         s->first_slice_line=1;
 628         s->resync_mb_x= s->mb_x;
 629     }
 630     start_mb_x= s->mb_x;
 631     s->resync_mb_y= s->mb_y;
 632     if(s->h263_aic){
 633         s->y_dc_scale_table=
 634         s->c_dc_scale_table= ff_aic_dc_scale_table;
 635     }else{
 636         s->y_dc_scale_table=
 637         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 638     }
 639
 640     if(s->modified_quant)
 641         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
 642
 643     ff_set_qscale(s, s->qscale);
 644
 645     s->rv10_first_dc_coded[0] = 0;
 646     s->rv10_first_dc_coded[1] = 0;
 647     s->rv10_first_dc_coded[2] = 0;
 648     s->block_wrap[0]=
 649     s->block_wrap[1]=
 650     s->block_wrap[2]=
 651     s->block_wrap[3]= s->b8_stride;
 652     s->block_wrap[4]=
 653     s->block_wrap[5]= s->mb_stride;
 654     ff_init_block_index(s);
 655     /* decode each macroblock */
 656
 657     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
 658         int ret;
 659         ff_update_block_index(s);
 660         dprintf(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 661
 662         s->mv_dir = MV_DIR_FORWARD;
 663         s->mv_type = MV_TYPE_16X16;
 664         ret=ff_h263_decode_mb(s, s->block);
 665
 666         if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
 667             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 668             return -1;
 669         }
 670         if(s->pict_type != FF_B_TYPE)
 671             ff_h263_update_motion_val(s);
 672         MPV_decode_mb(s, s->block);
 673         if(s->loop_filter)
 674             ff_h263_loop_filter(s);
 675
 676         if (++s->mb_x == s->mb_width) {
 677             s->mb_x = 0;
 678             s->mb_y++;
 679             ff_init_block_index(s);
 680         }
 681         if(s->mb_x == s->resync_mb_x)
 682             s->first_slice_line=0;
 683         if(ret == SLICE_END) break;
 684     }
 685
 686     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);
 687
 688     return buf_size;
 689 }
 690
 691 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
 692 {
 693     if(avctx->slice_count) return avctx->slice_offset[n];
 694     else                   return AV_RL32(buf + n*8);
 695 }
 696
 697 static int rv10_decode_frame(AVCodecContext *avctx,
 698                              void *data, int *data_size,
 699                              AVPacket *avpkt)
 700 {
 701     const uint8_t *buf = avpkt->data;
 702     int buf_size = avpkt->size;
 703     MpegEncContext *s = avctx->priv_data;
 704     int i;
 705     AVFrame *pict = data;
 706     int slice_count;
 707     const uint8_t *slices_hdr = NULL;
 708
 709     dprintf(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 710
 711     /* no supplementary picture */
 712     if (buf_size == 0) {
 713         return 0;
 714     }
 715
 716     if(!avctx->slice_count){
 717         slice_count = (*buf++) + 1;
 718         slices_hdr = buf + 4;
 719         buf += 8 * slice_count;
 720     }else
 721         slice_count = avctx->slice_count;
 722
 723     for(i=0; i<slice_count; i++){
 724         int offset= get_slice_offset(avctx, slices_hdr, i);
 725         int size;
 726
 727         if(i+1 == slice_count)
 728             size= buf_size - offset;
 729         else
 730             size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
 731
 732         rv10_decode_packet(avctx, buf+offset, size);
 733     }
 734
 735     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
 736         ff_er_frame_end(s);
 737         MPV_frame_end(s);
 738
 739         if (s->pict_type == FF_B_TYPE || s->low_delay) {
 740             *pict= *(AVFrame*)s->current_picture_ptr;
 741         } else if (s->last_picture_ptr != NULL) {
 742             *pict= *(AVFrame*)s->last_picture_ptr;
 743         }
 744
 745         if(s->last_picture_ptr || s->low_delay){
 746             *data_size = sizeof(AVFrame);
 747             ff_print_debug_info(s, pict);
 748         }
 749         s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
 750     }
 751
 752     return buf_size;
 753 }
 754
 755 AVCodec rv10_decoder = {
 756     "rv10",
 757     CODEC_TYPE_VIDEO,
 758     CODEC_ID_RV10,
 759     sizeof(MpegEncContext),
 760     rv10_decode_init,
 761     NULL,
 762     rv10_decode_end,
 763     rv10_decode_frame,
 764     CODEC_CAP_DR1,
 765     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 766     .pix_fmts= ff_pixfmt_list_420,
 767 };
 768
 769 AVCodec rv20_decoder = {
 770     "rv20",
 771     CODEC_TYPE_VIDEO,
 772     CODEC_ID_RV20,
 773     sizeof(MpegEncContext),
 774     rv10_decode_init,
 775     NULL,
 776     rv10_decode_end,
 777     rv10_decode_frame,
 778     CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 779     .flush= ff_mpeg_flush,
 780     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 781     .pix_fmts= ff_pixfmt_list_420,
 782 };
 783