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