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_h263dsp_init(&s->h263dsp);
 504     ff_h263_decode_init_vlc();
 505
 506     /* init rv vlc */
 507     if (!done) {
 508         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
 509                         rv_lum_bits, 1, 1,
 510                         rv_lum_code, 2, 2, 16384);
 511         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
 512                         rv_chrom_bits, 1, 1,
 513                         rv_chrom_code, 2, 2, 16388);
 514         done = 1;
 515     }
 516
 517     return 0;
 518 }
 519
 520 static av_cold int rv10_decode_end(AVCodecContext *avctx)
 521 {
 522     MpegEncContext *s = avctx->priv_data;
 523
 524     ff_MPV_common_end(s);
 525     return 0;
 526 }
 527
 528 static int rv10_decode_packet(AVCodecContext *avctx,
 529                               const uint8_t *buf, int buf_size, int buf_size2)
 530 {
 531     RVDecContext  *rv = avctx->priv_data;
 532     MpegEncContext *s = &rv->m;
 533     int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
 534
 535     active_bits_size = buf_size * 8;
 536     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
 537     if (s->codec_id == AV_CODEC_ID_RV10)
 538         mb_count = rv10_decode_picture_header(s);
 539     else
 540         mb_count = rv20_decode_picture_header(rv);
 541     if (mb_count < 0) {
 542         if (mb_count != ERROR_SKIP_FRAME)
 543             av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 544         return AVERROR_INVALIDDATA;
 545     }
 546
 547     if (s->mb_x >= s->mb_width ||
 548         s->mb_y >= s->mb_height) {
 549         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 550         return AVERROR_INVALIDDATA;
 551     }
 552     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 553     left = s->mb_width * s->mb_height - mb_pos;
 554     if (mb_count > left) {
 555         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 556         return AVERROR_INVALIDDATA;
 557     }
 558
 559     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
 560         if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?
 561             ff_er_frame_end(&s->er);
 562             ff_MPV_frame_end(s);
 563             s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
 564         }
 565         if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
 566             return ret;
 567         ff_mpeg_er_frame_start(s);
 568     } else {
 569         if (s->current_picture_ptr->f.pict_type != s->pict_type) {
 570             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
 571             return AVERROR_INVALIDDATA;
 572         }
 573     }
 574
 575
 576     av_dlog(avctx, "qscale=%d\n", s->qscale);
 577
 578     /* default quantization values */
 579     if (s->codec_id == AV_CODEC_ID_RV10) {
 580         if (s->mb_y == 0)
 581             s->first_slice_line = 1;
 582     } else {
 583         s->first_slice_line = 1;
 584         s->resync_mb_x      = s->mb_x;
 585     }
 586     start_mb_x     = s->mb_x;
 587     s->resync_mb_y = s->mb_y;
 588     if (s->h263_aic) {
 589         s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;
 590     } else {
 591         s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
 592     }
 593
 594     if (s->modified_quant)
 595         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
 596
 597     ff_set_qscale(s, s->qscale);
 598
 599     s->rv10_first_dc_coded[0] = 0;
 600     s->rv10_first_dc_coded[1] = 0;
 601     s->rv10_first_dc_coded[2] = 0;
 602     s->block_wrap[0] =
 603     s->block_wrap[1] =
 604     s->block_wrap[2] =
 605     s->block_wrap[3] = s->b8_stride;
 606     s->block_wrap[4] =
 607     s->block_wrap[5] = s->mb_stride;
 608     ff_init_block_index(s);
 609
 610     /* decode each macroblock */
 611     for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
 612         int ret;
 613         ff_update_block_index(s);
 614         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 615
 616         s->mv_dir  = MV_DIR_FORWARD;
 617         s->mv_type = MV_TYPE_16X16;
 618         ret = ff_h263_decode_mb(s, s->block);
 619
 620         // Repeat the slice end check from ff_h263_decode_mb with our active
 621         // bitstream size
 622         if (ret != SLICE_ERROR) {
 623             int v = show_bits(&s->gb, 16);
 624
 625             if (get_bits_count(&s->gb) + 16 > active_bits_size)
 626                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
 627
 628             if (!v)
 629                 ret = SLICE_END;
 630         }
 631         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
 632             8 * buf_size2 >= get_bits_count(&s->gb)) {
 633             active_bits_size = buf_size2 * 8;
 634             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
 635                    8 * buf_size, active_bits_size);
 636             ret = SLICE_OK;
 637         }
 638
 639         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
 640             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 641             return AVERROR_INVALIDDATA;
 642         }
 643         if (s->pict_type != AV_PICTURE_TYPE_B)
 644             ff_h263_update_motion_val(s);
 645         ff_MPV_decode_mb(s, s->block);
 646         if (s->loop_filter)
 647             ff_h263_loop_filter(s);
 648
 649         if (++s->mb_x == s->mb_width) {
 650             s->mb_x = 0;
 651             s->mb_y++;
 652             ff_init_block_index(s);
 653         }
 654         if (s->mb_x == s->resync_mb_x)
 655             s->first_slice_line = 0;
 656         if (ret == SLICE_END)
 657             break;
 658     }
 659
 660     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,
 661                     ER_MB_END);
 662
 663     return active_bits_size;
 664 }
 665
 666 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
 667 {
 668     if (avctx->slice_count)
 669         return avctx->slice_offset[n];
 670     else
 671         return AV_RL32(buf + n * 8);
 672 }
 673
 674 static int rv10_decode_frame(AVCodecContext *avctx,
 675                              void *data, int *got_frame,
 676                              AVPacket *avpkt)
 677 {
 678     const uint8_t *buf = avpkt->data;
 679     int buf_size       = avpkt->size;
 680     MpegEncContext *s  = avctx->priv_data;
 681     AVFrame *pict      = data;
 682     int i, ret;
 683     int slice_count;
 684     const uint8_t *slices_hdr = NULL;
 685
 686     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 687     s->flags  = avctx->flags;
 688     s->flags2 = avctx->flags2;
 689
 690     /* no supplementary picture */
 691     if (buf_size == 0) {
 692         return 0;
 693     }
 694
 695     if (!avctx->slice_count) {
 696         slice_count = (*buf++) + 1;
 697         buf_size--;
 698
 699         if (!slice_count || buf_size <= 8 * slice_count) {
 700             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
 701             return AVERROR_INVALIDDATA;
 702         }
 703
 704         slices_hdr = buf + 4;
 705         buf       += 8 * slice_count;
 706         buf_size  -= 8 * slice_count;
 707     } else
 708         slice_count = avctx->slice_count;
 709
 710     for (i = 0; i < slice_count; i++) {
 711         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
 712         int size, size2;
 713
 714         if (offset >= buf_size)
 715             return AVERROR_INVALIDDATA;
 716
 717         if (i + 1 == slice_count)
 718             size = buf_size - offset;
 719         else
 720             size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
 721
 722         if (i + 2 >= slice_count)
 723             size2 = buf_size - offset;
 724         else
 725             size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
 726
 727         if (size <= 0 || size2 <= 0 ||
 728             offset + FFMAX(size, size2) > buf_size)
 729             return AVERROR_INVALIDDATA;
 730
 731         if (rv10_decode_packet(avctx, buf + offset, size, size2) > 8 * size)
 732             i++;
 733     }
 734
 735     if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
 736         ff_er_frame_end(&s->er);
 737         ff_MPV_frame_end(s);
 738
 739         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
 740             if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
 741                 return ret;
 742             ff_print_debug_info(s, s->current_picture_ptr, pict);
 743             ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
 744         } else if (s->last_picture_ptr != NULL) {
 745             if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
 746                 return ret;
 747             ff_print_debug_info(s, s->last_picture_ptr, pict);
 748             ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
 749         }
 750
 751         if (s->last_picture_ptr || s->low_delay) {
 752             *got_frame = 1;
 753         }
 754
 755         // so we can detect if frame_end was not called (find some nicer solution...)
 756         s->current_picture_ptr = NULL;
 757     }
 758
 759     return avpkt->size;
 760 }
 761
 762 AVCodec ff_rv10_decoder = {
 763     .name           = "rv10",
 764     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 765     .type           = AVMEDIA_TYPE_VIDEO,
 766     .id             = AV_CODEC_ID_RV10,
 767     .priv_data_size = sizeof(RVDecContext),
 768     .init           = rv10_decode_init,
 769     .close          = rv10_decode_end,
 770     .decode         = rv10_decode_frame,
 771     .capabilities   = CODEC_CAP_DR1,
 772     .max_lowres     = 3,
 773     .pix_fmts       = ff_pixfmt_list_420,
 774 };
 775
 776 AVCodec ff_rv20_decoder = {
 777     .name           = "rv20",
 778     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 779     .type           = AVMEDIA_TYPE_VIDEO,
 780     .id             = AV_CODEC_ID_RV20,
 781     .priv_data_size = sizeof(RVDecContext),
 782     .init           = rv10_decode_init,
 783     .close          = rv10_decode_end,
 784     .decode         = rv10_decode_frame,
 785     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 786     .flush          = ff_mpeg_flush,
 787     .max_lowres     = 3,
 788     .pix_fmts       = ff_pixfmt_list_420,
 789 };