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