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 * new_w * s->height == new_h * s->width)
 392                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
 393             if (new_w * s->height == 2 * 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)
 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 ((s->mb_x == 0 && s->mb_y == 0) || !s->current_picture_ptr) {
 584         // FIXME write parser so we always have complete frames?
 585         if (s->current_picture_ptr) {
 586             ff_er_frame_end(&s->er);
 587             ff_mpv_frame_end(s);
 588             s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
 589         }
 590         if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
 591             return ret;
 592         ff_mpeg_er_frame_start(s);
 593     } else {
 594         if (s->current_picture_ptr->f->pict_type != s->pict_type) {
 595             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
 596             return AVERROR_INVALIDDATA;
 597         }
 598     }
 599
 600
 601     ff_dlog(avctx, "qscale=%d\n", s->qscale);
 602
 603     /* default quantization values */
 604     if (s->codec_id == AV_CODEC_ID_RV10) {
 605         if (s->mb_y == 0)
 606             s->first_slice_line = 1;
 607     } else {
 608         s->first_slice_line = 1;
 609         s->resync_mb_x      = s->mb_x;
 610     }
 611     start_mb_x     = s->mb_x;
 612     s->resync_mb_y = s->mb_y;
 613     if (s->h263_aic) {
 614         s->y_dc_scale_table =
 615         s->c_dc_scale_table = ff_aic_dc_scale_table;
 616     } else {
 617         s->y_dc_scale_table =
 618         s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
 619     }
 620
 621     if (s->modified_quant)
 622         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
 623
 624     ff_set_qscale(s, s->qscale);
 625
 626     s->rv10_first_dc_coded[0] = 0;
 627     s->rv10_first_dc_coded[1] = 0;
 628     s->rv10_first_dc_coded[2] = 0;
 629     s->block_wrap[0] =
 630     s->block_wrap[1] =
 631     s->block_wrap[2] =
 632     s->block_wrap[3] = s->b8_stride;
 633     s->block_wrap[4] =
 634     s->block_wrap[5] = s->mb_stride;
 635     ff_init_block_index(s);
 636
 637     /* decode each macroblock */
 638     for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
 639         int ret;
 640         ff_update_block_index(s);
 641         ff_tlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 642
 643         s->mv_dir  = MV_DIR_FORWARD;
 644         s->mv_type = MV_TYPE_16X16;
 645         ret = ff_h263_decode_mb(s, s->block);
 646
 647         // Repeat the slice end check from ff_h263_decode_mb with our active
 648         // bitstream size
 649         if (ret != SLICE_ERROR) {
 650             int v = show_bits(&s->gb, 16);
 651
 652             if (get_bits_count(&s->gb) + 16 > active_bits_size)
 653                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
 654
 655             if (!v)
 656                 ret = SLICE_END;
 657         }
 658         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
 659             8 * buf_size2 >= get_bits_count(&s->gb)) {
 660             active_bits_size = buf_size2 * 8;
 661             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
 662                    8 * buf_size, active_bits_size);
 663             ret = SLICE_OK;
 664         }
 665
 666         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
 667             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
 668                    s->mb_y);
 669             return AVERROR_INVALIDDATA;
 670         }
 671         if (s->pict_type != AV_PICTURE_TYPE_B)
 672             ff_h263_update_motion_val(s);
 673         ff_mpv_reconstruct_mb(s, s->block);
 674         if (s->loop_filter)
 675             ff_h263_loop_filter(s);
 676
 677         if (++s->mb_x == s->mb_width) {
 678             s->mb_x = 0;
 679             s->mb_y++;
 680             ff_init_block_index(s);
 681         }
 682         if (s->mb_x == s->resync_mb_x)
 683             s->first_slice_line = 0;
 684         if (ret == SLICE_END)
 685             break;
 686     }
 687
 688     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
 689                     ER_MB_END);
 690
 691     return active_bits_size;
 692 }
 693
 694 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
 695 {
 696     if (avctx->slice_count)
 697         return avctx->slice_offset[n];
 698     else
 699         return AV_RL32(buf + n * 8);
 700 }
 701
 702 static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 703                              AVPacket *avpkt)
 704 {
 705     const uint8_t *buf = avpkt->data;
 706     int buf_size       = avpkt->size;
 707     MpegEncContext *s = avctx->priv_data;
 708     AVFrame *pict = data;
 709     int i, ret;
 710     int slice_count;
 711     const uint8_t *slices_hdr = NULL;
 712
 713     ff_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 714
 715     /* no supplementary picture */
 716     if (buf_size == 0) {
 717         return 0;
 718     }
 719
 720     if (!avctx->slice_count) {
 721         slice_count = (*buf++) + 1;
 722         buf_size--;
 723
 724         if (!slice_count || buf_size <= 8 * slice_count) {
 725             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",
 726                    slice_count);
 727             return AVERROR_INVALIDDATA;
 728         }
 729
 730         slices_hdr = buf + 4;
 731         buf       += 8 * slice_count;
 732         buf_size  -= 8 * slice_count;
 733     } else
 734         slice_count = avctx->slice_count;
 735
 736     for (i = 0; i < slice_count; i++) {
 737         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
 738         int size, size2;
 739
 740         if (offset >= buf_size)
 741             return AVERROR_INVALIDDATA;
 742
 743         if (i + 1 == slice_count)
 744             size = buf_size - offset;
 745         else
 746             size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
 747
 748         if (i + 2 >= slice_count)
 749             size2 = buf_size - offset;
 750         else
 751             size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
 752
 753         if (size <= 0 || size2 <= 0 ||
 754             offset + FFMAX(size, size2) > buf_size)
 755             return AVERROR_INVALIDDATA;
 756
 757         if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2)) < 0)
 758             return ret;
 759
 760         if (ret > 8 * size)
 761             i++;
 762     }
 763
 764     if (s->current_picture_ptr && s->mb_y >= s->mb_height) {
 765         ff_er_frame_end(&s->er);
 766         ff_mpv_frame_end(s);
 767
 768         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
 769             if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
 770                 return ret;
 771             ff_print_debug_info(s, s->current_picture_ptr, pict);
 772             ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
 773         } else if (s->last_picture_ptr) {
 774             if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
 775                 return ret;
 776             ff_print_debug_info(s, s->last_picture_ptr, pict);
 777             ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
 778         }
 779
 780         if (s->last_picture_ptr || s->low_delay) {
 781             *got_frame = 1;
 782         }
 783
 784         // so we can detect if frame_end was not called (find some nicer solution...)
 785         s->current_picture_ptr = NULL;
 786     }
 787
 788     return avpkt->size;
 789 }
 790
 791 AVCodec ff_rv10_decoder = {
 792     .name           = "rv10",
 793     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 794     .type           = AVMEDIA_TYPE_VIDEO,
 795     .id             = AV_CODEC_ID_RV10,
 796     .priv_data_size = sizeof(RVDecContext),
 797     .init           = rv10_decode_init,
 798     .close          = rv10_decode_end,
 799     .decode         = rv10_decode_frame,
 800     .capabilities   = AV_CODEC_CAP_DR1,
 801     .max_lowres     = 3,
 802     .pix_fmts       = (const enum AVPixelFormat[]) {
 803         AV_PIX_FMT_YUV420P,
 804         AV_PIX_FMT_NONE
 805     },
 806 };
 807
 808 AVCodec ff_rv20_decoder = {
 809     .name           = "rv20",
 810     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 811     .type           = AVMEDIA_TYPE_VIDEO,
 812     .id             = AV_CODEC_ID_RV20,
 813     .priv_data_size = sizeof(RVDecContext),
 814     .init           = rv10_decode_init,
 815     .close          = rv10_decode_end,
 816     .decode         = rv10_decode_frame,
 817     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
 818     .flush          = ff_mpeg_flush,
 819     .max_lowres     = 3,
 820     .pix_fmts       = (const enum AVPixelFormat[]) {
 821         AV_PIX_FMT_YUV420P,
 822         AV_PIX_FMT_NONE
 823     },
 824 };