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

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