git.sesse.net Git - ffmpeg/blob - libavcodec/rv10.c

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