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