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     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_max;
 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->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
 330         av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
 331         return -1;
 332     }
 333     if (!s->last_picture_ptr && s->pict_type == AV_PICTURE_TYPE_B) {
 334         av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
 335         return AVERROR_INVALIDDATA;
 336     }
 337
 338     if (get_bits1(&s->gb)) {
 339         av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
 340         return AVERROR_INVALIDDATA;
 341     }
 342
 343     s->qscale = get_bits(&s->gb, 5);
 344     if (s->qscale == 0) {
 345         av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
 346         return AVERROR_INVALIDDATA;
 347     }
 348
 349     if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
 350         s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
 351
 352     if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
 353         seq = get_bits(&s->gb, 8) << 7;
 354     else
 355         seq = get_bits(&s->gb, 13) << 2;
 356
 357     rpr_max = s->avctx->extradata[1] & 7;
 358     if (rpr_max) {
 359         int f, new_w, new_h;
 360         int rpr_bits = av_log2(rpr_max) + 1;
 361
 362         f = get_bits(&s->gb, rpr_bits);
 363
 364         if (f) {
 365             if (s->avctx->extradata_size < 8 + 2 * f) {
 366                 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
 367                 return AVERROR_INVALIDDATA;
 368             }
 369
 370             new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];
 371             new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];
 372         } else {
 373             new_w = rv->orig_width;
 374             new_h = rv->orig_height;
 375         }
 376         if (new_w != s->width || new_h != s->height) {
 377             AVRational old_aspect = s->avctx->sample_aspect_ratio;
 378             av_log(s->avctx, AV_LOG_DEBUG,
 379                    "attempting to change resolution to %dx%d\n", new_w, new_h);
 380             if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
 381                 return AVERROR_INVALIDDATA;
 382             ff_mpv_common_end(s);
 383
 384             // attempt to keep aspect during typical resolution switches
 385             if (!old_aspect.num)
 386                 old_aspect = (AVRational){1, 1};
 387             if (2 * new_w * s->height == new_h * s->width)
 388                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
 389             if (new_w * s->height == 2 * new_h * s->width)
 390                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
 391
 392             ret = ff_set_dimensions(s->avctx, new_w, new_h);
 393             if (ret < 0)
 394                 return ret;
 395
 396             s->width  = new_w;
 397             s->height = new_h;
 398             if ((ret = ff_mpv_common_init(s)) < 0)
 399                 return ret;
 400         }
 401
 402         if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
 403             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max);
 404         }
 405     }
 406     if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
 407         return AVERROR_INVALIDDATA;
 408
 409     mb_pos = ff_h263_decode_mba(s);
 410
 411     seq |= s->time & ~0x7FFF;
 412     if (seq - s->time >  0x4000)
 413         seq -= 0x8000;
 414     if (seq - s->time < -0x4000)
 415         seq += 0x8000;
 416
 417     if (seq != s->time) {
 418         if (s->pict_type != AV_PICTURE_TYPE_B) {
 419             s->time            = seq;
 420             s->pp_time         = s->time - s->last_non_b_time;
 421             s->last_non_b_time = s->time;
 422         } else {
 423             s->time    = seq;
 424             s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
 425         }
 426     }
 427     if (s->pict_type == AV_PICTURE_TYPE_B) {
 428         if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
 429             av_log(s->avctx, AV_LOG_DEBUG,
 430                    "messed up order, possible from seeking? skipping current b frame\n");
 431 #define ERROR_SKIP_FRAME -123
 432             return ERROR_SKIP_FRAME;
 433         }
 434         ff_mpeg4_init_direct_mv(s);
 435     }
 436
 437     s->no_rounding = get_bits1(&s->gb);
 438
 439     if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
 440         // binary decoder reads 3+2 bits here but they don't seem to be used
 441         skip_bits(&s->gb, 5);
 442
 443     s->f_code          = 1;
 444     s->unrestricted_mv = 1;
 445     s->h263_aic        = s->pict_type == AV_PICTURE_TYPE_I;
 446     s->modified_quant  = 1;
 447     if (!s->avctx->lowres)
 448         s->loop_filter = 1;
 449
 450     if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
 451         av_log(s->avctx, AV_LOG_INFO,
 452                "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
 453                seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,
 454                s->no_rounding);
 455     }
 456
 457     av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
 458
 459     return s->mb_width * s->mb_height - mb_pos;
 460 }
 461
 462 static av_cold int rv10_decode_init(AVCodecContext *avctx)
 463 {
 464     RVDecContext *rv = avctx->priv_data;
 465     MpegEncContext *s = &rv->m;
 466     static int done = 0;
 467     int major_ver, minor_ver, micro_ver, ret;
 468
 469     if (avctx->extradata_size < 8) {
 470         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
 471         return AVERROR_INVALIDDATA;
 472     }
 473     if ((ret = av_image_check_size(avctx->coded_width,
 474                                    avctx->coded_height, 0, avctx)) < 0)
 475         return ret;
 476
 477     ff_mpv_decode_defaults(s);
 478
 479     s->avctx       = avctx;
 480     s->out_format  = FMT_H263;
 481     s->codec_id    = avctx->codec_id;
 482
 483     rv->orig_width  =
 484     s->width        = avctx->coded_width;
 485     rv->orig_height =
 486     s->height       = avctx->coded_height;
 487
 488     s->h263_long_vectors = ((uint8_t *) avctx->extradata)[3] & 1;
 489     rv->sub_id           = AV_RB32((uint8_t *) avctx->extradata + 4);
 490
 491     major_ver = RV_GET_MAJOR_VER(rv->sub_id);
 492     minor_ver = RV_GET_MINOR_VER(rv->sub_id);
 493     micro_ver = RV_GET_MICRO_VER(rv->sub_id);
 494
 495     s->low_delay = 1;
 496     switch (major_ver) {
 497     case 1:
 498         s->rv10_version = micro_ver ? 3 : 1;
 499         s->obmc         = micro_ver == 2;
 500         break;
 501     case 2:
 502         if (minor_ver >= 2) {
 503             s->low_delay           = 0;
 504             s->avctx->has_b_frames = 1;
 505         }
 506         break;
 507     default:
 508         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
 509         avpriv_request_sample(avctx, "RV1/2 version");
 510         return AVERROR_PATCHWELCOME;
 511     }
 512
 513     if (avctx->debug & FF_DEBUG_PICT_INFO) {
 514         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%"PRIX32"\n", rv->sub_id,
 515                ((uint32_t *) avctx->extradata)[0]);
 516     }
 517
 518     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 519
 520     ff_mpv_idct_init(s);
 521     if ((ret = ff_mpv_common_init(s)) < 0)
 522         return ret;
 523
 524     ff_h263dsp_init(&s->h263dsp);
 525     ff_h263_decode_init_vlc();
 526
 527     /* init rv vlc */
 528     if (!done) {
 529         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
 530                         rv_lum_bits, 1, 1,
 531                         rv_lum_code, 2, 2, 16384);
 532         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
 533                         rv_chrom_bits, 1, 1,
 534                         rv_chrom_code, 2, 2, 16388);
 535         done = 1;
 536     }
 537
 538     return 0;
 539 }
 540
 541 static av_cold int rv10_decode_end(AVCodecContext *avctx)
 542 {
 543     MpegEncContext *s = avctx->priv_data;
 544
 545     ff_mpv_common_end(s);
 546     return 0;
 547 }
 548
 549 static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
 550                               int buf_size, int buf_size2)
 551 {
 552     RVDecContext *rv = avctx->priv_data;
 553     MpegEncContext *s = &rv->m;
 554     int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
 555
 556     active_bits_size = buf_size * 8;
 557     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
 558     if (s->codec_id == AV_CODEC_ID_RV10)
 559         mb_count = rv10_decode_picture_header(s);
 560     else
 561         mb_count = rv20_decode_picture_header(rv);
 562     if (mb_count < 0) {
 563         if (mb_count != ERROR_SKIP_FRAME)
 564             av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 565         return AVERROR_INVALIDDATA;
 566     }
 567
 568     if (s->mb_x >= s->mb_width ||
 569         s->mb_y >= s->mb_height) {
 570         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 571         return AVERROR_INVALIDDATA;
 572     }
 573     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 574     left   = s->mb_width * s->mb_height - mb_pos;
 575     if (mb_count > left) {
 576         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 577         return AVERROR_INVALIDDATA;
 578     }
 579
 580     if ((s->mb_x == 0 && s->mb_y == 0) || !s->current_picture_ptr) {
 581         // FIXME write parser so we always have complete frames?
 582         if (s->current_picture_ptr) {
 583             ff_er_frame_end(&s->er);
 584             ff_mpv_frame_end(s);
 585             s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
 586         }
 587         if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
 588             return ret;
 589         ff_mpeg_er_frame_start(s);
 590     } else {
 591         if (s->current_picture_ptr->f->pict_type != s->pict_type) {
 592             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
 593             return AVERROR_INVALIDDATA;
 594         }
 595     }
 596
 597
 598     av_dlog(avctx, "qscale=%d\n", s->qscale);
 599
 600     /* default quantization values */
 601     if (s->codec_id == AV_CODEC_ID_RV10) {
 602         if (s->mb_y == 0)
 603             s->first_slice_line = 1;
 604     } else {
 605         s->first_slice_line = 1;
 606         s->resync_mb_x      = s->mb_x;
 607     }
 608     start_mb_x     = s->mb_x;
 609     s->resync_mb_y = s->mb_y;
 610     if (s->h263_aic) {
 611         s->y_dc_scale_table =
 612         s->c_dc_scale_table = ff_aic_dc_scale_table;
 613     } else {
 614         s->y_dc_scale_table =
 615         s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
 616     }
 617
 618     if (s->modified_quant)
 619         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
 620
 621     ff_set_qscale(s, s->qscale);
 622
 623     s->rv10_first_dc_coded[0] = 0;
 624     s->rv10_first_dc_coded[1] = 0;
 625     s->rv10_first_dc_coded[2] = 0;
 626     s->block_wrap[0] =
 627     s->block_wrap[1] =
 628     s->block_wrap[2] =
 629     s->block_wrap[3] = s->b8_stride;
 630     s->block_wrap[4] =
 631     s->block_wrap[5] = s->mb_stride;
 632     ff_init_block_index(s);
 633
 634     /* decode each macroblock */
 635     for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
 636         int ret;
 637         ff_update_block_index(s);
 638         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 639
 640         s->mv_dir  = MV_DIR_FORWARD;
 641         s->mv_type = MV_TYPE_16X16;
 642         ret = ff_h263_decode_mb(s, s->block);
 643
 644         // Repeat the slice end check from ff_h263_decode_mb with our active
 645         // bitstream size
 646         if (ret != SLICE_ERROR) {
 647             int v = show_bits(&s->gb, 16);
 648
 649             if (get_bits_count(&s->gb) + 16 > active_bits_size)
 650                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
 651
 652             if (!v)
 653                 ret = SLICE_END;
 654         }
 655         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
 656             8 * buf_size2 >= get_bits_count(&s->gb)) {
 657             active_bits_size = buf_size2 * 8;
 658             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
 659                    8 * buf_size, active_bits_size);
 660             ret = SLICE_OK;
 661         }
 662
 663         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
 664             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
 665                    s->mb_y);
 666             return AVERROR_INVALIDDATA;
 667         }
 668         if (s->pict_type != AV_PICTURE_TYPE_B)
 669             ff_h263_update_motion_val(s);
 670         ff_mpv_decode_mb(s, s->block);
 671         if (s->loop_filter)
 672             ff_h263_loop_filter(s);
 673
 674         if (++s->mb_x == s->mb_width) {
 675             s->mb_x = 0;
 676             s->mb_y++;
 677             ff_init_block_index(s);
 678         }
 679         if (s->mb_x == s->resync_mb_x)
 680             s->first_slice_line = 0;
 681         if (ret == SLICE_END)
 682             break;
 683     }
 684
 685     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
 686                     ER_MB_END);
 687
 688     return active_bits_size;
 689 }
 690
 691 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
 692 {
 693     if (avctx->slice_count)
 694         return avctx->slice_offset[n];
 695     else
 696         return AV_RL32(buf + n * 8);
 697 }
 698
 699 static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 700                              AVPacket *avpkt)
 701 {
 702     const uint8_t *buf = avpkt->data;
 703     int buf_size       = avpkt->size;
 704     MpegEncContext *s = avctx->priv_data;
 705     AVFrame *pict = data;
 706     int i, ret;
 707     int slice_count;
 708     const uint8_t *slices_hdr = NULL;
 709
 710     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 711     s->flags  = avctx->flags;
 712     s->flags2 = avctx->flags2;
 713
 714     /* no supplementary picture */
 715     if (buf_size == 0) {
 716         return 0;
 717     }
 718
 719     if (!avctx->slice_count) {
 720         slice_count = (*buf++) + 1;
 721         buf_size--;
 722
 723         if (!slice_count || buf_size <= 8 * slice_count) {
 724             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",
 725                    slice_count);
 726             return AVERROR_INVALIDDATA;
 727         }
 728
 729         slices_hdr = buf + 4;
 730         buf       += 8 * slice_count;
 731         buf_size  -= 8 * slice_count;
 732     } else
 733         slice_count = avctx->slice_count;
 734
 735     for (i = 0; i < slice_count; i++) {
 736         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
 737         int size, size2;
 738
 739         if (offset >= buf_size)
 740             return AVERROR_INVALIDDATA;
 741
 742         if (i + 1 == slice_count)
 743             size = buf_size - offset;
 744         else
 745             size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
 746
 747         if (i + 2 >= slice_count)
 748             size2 = buf_size - offset;
 749         else
 750             size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
 751
 752         if (size <= 0 || size2 <= 0 ||
 753             offset + FFMAX(size, size2) > buf_size)
 754             return AVERROR_INVALIDDATA;
 755
 756         if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2)) < 0)
 757             return ret;
 758
 759         if (ret > 8 * size)
 760             i++;
 761     }
 762
 763     if (s->current_picture_ptr && s->mb_y >= s->mb_height) {
 764         ff_er_frame_end(&s->er);
 765         ff_mpv_frame_end(s);
 766
 767         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
 768             if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
 769                 return ret;
 770             ff_print_debug_info(s, s->current_picture_ptr, pict);
 771             ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
 772         } else if (s->last_picture_ptr) {
 773             if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
 774                 return ret;
 775             ff_print_debug_info(s, s->last_picture_ptr, pict);
 776             ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
 777         }
 778
 779         if (s->last_picture_ptr || s->low_delay) {
 780             *got_frame = 1;
 781         }
 782
 783         // so we can detect if frame_end was not called (find some nicer solution...)
 784         s->current_picture_ptr = NULL;
 785     }
 786
 787     return avpkt->size;
 788 }
 789
 790 AVCodec ff_rv10_decoder = {
 791     .name           = "rv10",
 792     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 793     .type           = AVMEDIA_TYPE_VIDEO,
 794     .id             = AV_CODEC_ID_RV10,
 795     .priv_data_size = sizeof(RVDecContext),
 796     .init           = rv10_decode_init,
 797     .close          = rv10_decode_end,
 798     .decode         = rv10_decode_frame,
 799     .capabilities   = CODEC_CAP_DR1,
 800     .max_lowres     = 3,
 801     .pix_fmts       = (const enum AVPixelFormat[]) {
 802         AV_PIX_FMT_YUV420P,
 803         AV_PIX_FMT_NONE
 804     },
 805 };
 806
 807 AVCodec ff_rv20_decoder = {
 808     .name           = "rv20",
 809     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 810     .type           = AVMEDIA_TYPE_VIDEO,
 811     .id             = AV_CODEC_ID_RV20,
 812     .priv_data_size = sizeof(RVDecContext),
 813     .init           = rv10_decode_init,
 814     .close          = rv10_decode_end,
 815     .decode         = rv10_decode_frame,
 816     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 817     .flush          = ff_mpeg_flush,
 818     .max_lowres     = 3,
 819     .pix_fmts       = (const enum AVPixelFormat[]) {
 820         AV_PIX_FMT_YUV420P,
 821         AV_PIX_FMT_NONE
 822     },
 823 };