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