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