git.sesse.net Git - ffmpeg/blob - libavcodec/rv10.c

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