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