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