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