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