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