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