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
  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 /* read RV 1.0 compatible frame header */
 233 static int rv10_decode_picture_header(MpegEncContext *s)
 234 {
 235     int mb_count, pb_frame, marker, unk, mb_xy;
 236
 237     marker = get_bits1(&s->gb);
 238
 239     if (get_bits1(&s->gb))
 240         s->pict_type = FF_P_TYPE;
 241     else
 242         s->pict_type = FF_I_TYPE;
 243     if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
 244     pb_frame = get_bits1(&s->gb);
 245
 246     dprintf(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
 247
 248     if (pb_frame){
 249         av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
 250         return -1;
 251     }
 252
 253     s->qscale = get_bits(&s->gb, 5);
 254     if(s->qscale==0){
 255         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 256         return -1;
 257     }
 258
 259     if (s->pict_type == FF_I_TYPE) {
 260         if (s->rv10_version == 3) {
 261             /* specific MPEG like DC coding not used */
 262             s->last_dc[0] = get_bits(&s->gb, 8);
 263             s->last_dc[1] = get_bits(&s->gb, 8);
 264             s->last_dc[2] = get_bits(&s->gb, 8);
 265             dprintf(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
 266                     s->last_dc[1], s->last_dc[2]);
 267         }
 268     }
 269     /* if multiple packets per frame are sent, the position at which
 270        to display the macroblocks is coded here */
 271
 272     mb_xy= s->mb_x + s->mb_y*s->mb_width;
 273     if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
 274         s->mb_x = get_bits(&s->gb, 6); /* mb_x */
 275         s->mb_y = get_bits(&s->gb, 6); /* mb_y */
 276         mb_count = get_bits(&s->gb, 12);
 277     } else {
 278         s->mb_x = 0;
 279         s->mb_y = 0;
 280         mb_count = s->mb_width * s->mb_height;
 281     }
 282     unk= get_bits(&s->gb, 3);   /* ignored */
 283     s->f_code = 1;
 284     s->unrestricted_mv = 1;
 285
 286     return mb_count;
 287 }
 288
 289 static int rv20_decode_picture_header(MpegEncContext *s)
 290 {
 291     int seq, mb_pos, i;
 292
 293 #if 0
 294     GetBitContext gb= s->gb;
 295     for(i=0; i<64; i++){
 296         av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
 297         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
 298     }
 299     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 300 #endif
 301 #if 0
 302     av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
 303     for(i=0; i<s->avctx->extradata_size; i++){
 304         av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
 305         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
 306     }
 307     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 308 #endif
 309
 310     if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
 311         if (get_bits(&s->gb, 3)){
 312             av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
 313             return -1;
 314         }
 315     }
 316
 317     i= get_bits(&s->gb, 2);
 318     switch(i){
 319     case 0: s->pict_type= FF_I_TYPE; break;
 320     case 1: s->pict_type= FF_I_TYPE; break; //hmm ...
 321     case 2: s->pict_type= FF_P_TYPE; break;
 322     case 3: s->pict_type= FF_B_TYPE; break;
 323     default:
 324         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
 325         return -1;
 326     }
 327
 328     if(s->last_picture_ptr==NULL && s->pict_type==FF_B_TYPE){
 329         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
 330         return -1;
 331     }
 332
 333     if (get_bits1(&s->gb)){
 334         av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
 335         return -1;
 336     }
 337
 338     s->qscale = get_bits(&s->gb, 5);
 339     if(s->qscale==0){
 340         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 341         return -1;
 342     }
 343     if(s->avctx->sub_id == 0x30203002){
 344         if (get_bits1(&s->gb)){
 345             av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
 346             return -1;
 347         }
 348     }
 349
 350     if(s->avctx->has_b_frames){
 351         int f, new_w, new_h;
 352         int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
 353
 354         if (get_bits1(&s->gb)){
 355             av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
 356         }
 357         seq= get_bits(&s->gb, 13)<<2;
 358
 359         f= get_bits(&s->gb, av_log2(v)+1);
 360
 361         if(f){
 362             new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
 363             new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
 364         }else{
 365             new_w= s->orig_width ;
 366             new_h= s->orig_height;
 367         }
 368         if(new_w != s->width || new_h != s->height){
 369             av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
 370             if (avcodec_check_dimensions(s->avctx, new_w, new_h) < 0)
 371                 return -1;
 372             MPV_common_end(s);
 373             avcodec_set_dimensions(s->avctx, new_w, new_h);
 374             s->width  = new_w;
 375             s->height = new_h;
 376             if (MPV_common_init(s) < 0)
 377                 return -1;
 378         }
 379
 380         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 381             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
 382         }
 383     }else{
 384         seq= get_bits(&s->gb, 8)*128;
 385     }
 386
 387 //     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
 388     mb_pos= ff_h263_decode_mba(s);
 389 /*    }else{
 390         mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
 391         s->mb_x= mb_pos % s->mb_width;
 392         s->mb_y= mb_pos / s->mb_width;
 393     }*/
 394 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
 395     seq |= s->time &~0x7FFF;
 396     if(seq - s->time >  0x4000) seq -= 0x8000;
 397     if(seq - s->time < -0x4000) seq += 0x8000;
 398     if(seq != s->time){
 399         if(s->pict_type!=FF_B_TYPE){
 400             s->time= seq;
 401             s->pp_time= s->time - s->last_non_b_time;
 402             s->last_non_b_time= s->time;
 403         }else{
 404             s->time= seq;
 405             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
 406             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
 407                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
 408                 return FRAME_SKIPPED;
 409             }
 410             ff_mpeg4_init_direct_mv(s);
 411         }
 412     }
 413 //    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
 414 /*for(i=0; i<32; i++){
 415     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
 416 }
 417 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
 418     s->no_rounding= get_bits1(&s->gb);
 419
 420     s->f_code = 1;
 421     s->unrestricted_mv = 1;
 422     s->h263_aic= s->pict_type == FF_I_TYPE;
 423 //    s->alt_inter_vlc=1;
 424 //    s->obmc=1;
 425 //    s->umvplus=1;
 426     s->modified_quant=1;
 427     if(!s->avctx->lowres)
 428         s->loop_filter=1;
 429
 430     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 431             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
 432                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
 433     }
 434
 435     assert(s->pict_type != FF_B_TYPE || !s->low_delay);
 436
 437     return s->mb_width*s->mb_height - mb_pos;
 438 }
 439
 440 static av_cold int rv10_decode_init(AVCodecContext *avctx)
 441 {
 442     MpegEncContext *s = avctx->priv_data;
 443     static int done=0;
 444
 445     if (avctx->extradata_size < 8) {
 446         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
 447         return -1;
 448     }
 449
 450     MPV_decode_defaults(s);
 451
 452     s->avctx= avctx;
 453     s->out_format = FMT_H263;
 454     s->codec_id= avctx->codec_id;
 455
 456     s->orig_width = s->width  = avctx->coded_width;
 457     s->orig_height= s->height = avctx->coded_height;
 458
 459     s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
 460     avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
 461
 462     if (avctx->sub_id == 0x10000000) {
 463         s->rv10_version= 0;
 464         s->low_delay=1;
 465     } else if (avctx->sub_id == 0x10001000) {
 466         s->rv10_version= 3;
 467         s->low_delay=1;
 468     } else if (avctx->sub_id == 0x10002000) {
 469         s->rv10_version= 3;
 470         s->low_delay=1;
 471         s->obmc=1;
 472     } else if (avctx->sub_id == 0x10003000) {
 473         s->rv10_version= 3;
 474         s->low_delay=1;
 475     } else if (avctx->sub_id == 0x10003001) {
 476         s->rv10_version= 3;
 477         s->low_delay=1;
 478     } else if (    avctx->sub_id == 0x20001000
 479                || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
 480         s->low_delay=1;
 481     } else if (    avctx->sub_id == 0x30202002
 482                ||  avctx->sub_id == 0x30203002
 483                || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
 484         s->low_delay=0;
 485         s->avctx->has_b_frames=1;
 486     } else
 487         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
 488
 489     if(avctx->debug & FF_DEBUG_PICT_INFO){
 490         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
 491     }
 492
 493     avctx->pix_fmt = PIX_FMT_YUV420P;
 494
 495     if (MPV_common_init(s) < 0)
 496         return -1;
 497
 498     h263_decode_init_vlc(s);
 499
 500     /* init rv vlc */
 501     if (!done) {
 502         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
 503                  rv_lum_bits, 1, 1,
 504                  rv_lum_code, 2, 2, 16384);
 505         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
 506                  rv_chrom_bits, 1, 1,
 507                  rv_chrom_code, 2, 2, 16388);
 508         done = 1;
 509     }
 510
 511     return 0;
 512 }
 513
 514 static av_cold int rv10_decode_end(AVCodecContext *avctx)
 515 {
 516     MpegEncContext *s = avctx->priv_data;
 517
 518     MPV_common_end(s);
 519     return 0;
 520 }
 521
 522 static int rv10_decode_packet(AVCodecContext *avctx,
 523                              const uint8_t *buf, int buf_size, int buf_size2)
 524 {
 525     MpegEncContext *s = avctx->priv_data;
 526     int mb_count, mb_pos, left, start_mb_x;
 527
 528     init_get_bits(&s->gb, buf, buf_size*8);
 529     if(s->codec_id ==CODEC_ID_RV10)
 530         mb_count = rv10_decode_picture_header(s);
 531     else
 532         mb_count = rv20_decode_picture_header(s);
 533     if (mb_count < 0) {
 534         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 535         return -1;
 536     }
 537
 538     if (s->mb_x >= s->mb_width ||
 539         s->mb_y >= s->mb_height) {
 540         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 541         return -1;
 542     }
 543     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 544     left = s->mb_width * s->mb_height - mb_pos;
 545     if (mb_count > left) {
 546         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 547         return -1;
 548     }
 549
 550     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
 551         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
 552             ff_er_frame_end(s);
 553             MPV_frame_end(s);
 554             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
 555         }
 556         if(MPV_frame_start(s, avctx) < 0)
 557             return -1;
 558         ff_er_frame_start(s);
 559     }
 560
 561     dprintf(avctx, "qscale=%d\n", s->qscale);
 562
 563     /* default quantization values */
 564     if(s->codec_id== CODEC_ID_RV10){
 565         if(s->mb_y==0) s->first_slice_line=1;
 566     }else{
 567         s->first_slice_line=1;
 568         s->resync_mb_x= s->mb_x;
 569     }
 570     start_mb_x= s->mb_x;
 571     s->resync_mb_y= s->mb_y;
 572     if(s->h263_aic){
 573         s->y_dc_scale_table=
 574         s->c_dc_scale_table= ff_aic_dc_scale_table;
 575     }else{
 576         s->y_dc_scale_table=
 577         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 578     }
 579
 580     if(s->modified_quant)
 581         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
 582
 583     ff_set_qscale(s, s->qscale);
 584
 585     s->rv10_first_dc_coded[0] = 0;
 586     s->rv10_first_dc_coded[1] = 0;
 587     s->rv10_first_dc_coded[2] = 0;
 588     s->block_wrap[0]=
 589     s->block_wrap[1]=
 590     s->block_wrap[2]=
 591     s->block_wrap[3]= s->b8_stride;
 592     s->block_wrap[4]=
 593     s->block_wrap[5]= s->mb_stride;
 594     ff_init_block_index(s);
 595     /* decode each macroblock */
 596
 597     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
 598         int ret;
 599         ff_update_block_index(s);
 600         dprintf(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 601
 602         s->mv_dir = MV_DIR_FORWARD;
 603         s->mv_type = MV_TYPE_16X16;
 604         ret=ff_h263_decode_mb(s, s->block);
 605
 606         if (ret != SLICE_ERROR && s->gb.size_in_bits < get_bits_count(&s->gb) && 8*buf_size2 >= get_bits_count(&s->gb)){
 607             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n", s->gb.size_in_bits, 8*buf_size2);
 608             s->gb.size_in_bits= 8*buf_size2;
 609             ret= SLICE_OK;
 610         }
 611
 612         if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
 613             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 614             return -1;
 615         }
 616         if(s->pict_type != FF_B_TYPE)
 617             ff_h263_update_motion_val(s);
 618         MPV_decode_mb(s, s->block);
 619         if(s->loop_filter)
 620             ff_h263_loop_filter(s);
 621
 622         if (++s->mb_x == s->mb_width) {
 623             s->mb_x = 0;
 624             s->mb_y++;
 625             ff_init_block_index(s);
 626         }
 627         if(s->mb_x == s->resync_mb_x)
 628             s->first_slice_line=0;
 629         if(ret == SLICE_END) break;
 630     }
 631
 632     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);
 633
 634     return s->gb.size_in_bits;
 635 }
 636
 637 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
 638 {
 639     if(avctx->slice_count) return avctx->slice_offset[n];
 640     else                   return AV_RL32(buf + n*8);
 641 }
 642
 643 static int rv10_decode_frame(AVCodecContext *avctx,
 644                              void *data, int *data_size,
 645                              AVPacket *avpkt)
 646 {
 647     const uint8_t *buf = avpkt->data;
 648     int buf_size = avpkt->size;
 649     MpegEncContext *s = avctx->priv_data;
 650     int i;
 651     AVFrame *pict = data;
 652     int slice_count;
 653     const uint8_t *slices_hdr = NULL;
 654
 655     dprintf(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 656
 657     /* no supplementary picture */
 658     if (buf_size == 0) {
 659         return 0;
 660     }
 661
 662     if(!avctx->slice_count){
 663         slice_count = (*buf++) + 1;
 664         slices_hdr = buf + 4;
 665         buf += 8 * slice_count;
 666     }else
 667         slice_count = avctx->slice_count;
 668
 669     for(i=0; i<slice_count; i++){
 670         int offset= get_slice_offset(avctx, slices_hdr, i);
 671         int size, size2;
 672
 673         if(i+1 == slice_count)
 674             size= buf_size - offset;
 675         else
 676             size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
 677
 678         if(i+2 >= slice_count)
 679             size2= buf_size - offset;
 680         else
 681             size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
 682
 683         if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
 684             i++;
 685     }
 686
 687     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
 688         ff_er_frame_end(s);
 689         MPV_frame_end(s);
 690
 691         if (s->pict_type == FF_B_TYPE || s->low_delay) {
 692             *pict= *(AVFrame*)s->current_picture_ptr;
 693         } else if (s->last_picture_ptr != NULL) {
 694             *pict= *(AVFrame*)s->last_picture_ptr;
 695         }
 696
 697         if(s->last_picture_ptr || s->low_delay){
 698             *data_size = sizeof(AVFrame);
 699             ff_print_debug_info(s, pict);
 700         }
 701         s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
 702     }
 703
 704     return buf_size;
 705 }
 706
 707 AVCodec rv10_decoder = {
 708     "rv10",
 709     CODEC_TYPE_VIDEO,
 710     CODEC_ID_RV10,
 711     sizeof(MpegEncContext),
 712     rv10_decode_init,
 713     NULL,
 714     rv10_decode_end,
 715     rv10_decode_frame,
 716     CODEC_CAP_DR1,
 717     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 718     .pix_fmts= ff_pixfmt_list_420,
 719 };
 720
 721 AVCodec rv20_decoder = {
 722     "rv20",
 723     CODEC_TYPE_VIDEO,
 724     CODEC_ID_RV20,
 725     sizeof(MpegEncContext),
 726     rv10_decode_init,
 727     NULL,
 728     rv10_decode_end,
 729     rv10_decode_frame,
 730     CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 731     .flush= ff_mpeg_flush,
 732     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 733     .pix_fmts= ff_pixfmt_list_420,
 734 };