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 "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->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
 316         av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
 317         return AVERROR_INVALIDDATA;
 318     }
 319
 320     if (get_bits1(&s->gb)) {
 321         av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
 322         return AVERROR_INVALIDDATA;
 323     }
 324
 325     s->qscale = get_bits(&s->gb, 5);
 326     if (s->qscale == 0) {
 327         av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
 328         return AVERROR_INVALIDDATA;
 329     }
 330
 331     if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
 332         s->loop_filter = get_bits1(&s->gb);
 333
 334     if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
 335         seq = get_bits(&s->gb, 8) << 7;
 336     else
 337         seq = get_bits(&s->gb, 13) << 2;
 338
 339     rpr_bits = s->avctx->extradata[1] & 7;
 340     if (rpr_bits) {
 341         int f, new_w, new_h;
 342         rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
 343
 344         f = get_bits(&s->gb, rpr_bits);
 345
 346         if (f) {
 347             if (s->avctx->extradata_size < 8 + 2 * f) {
 348                 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
 349                 return AVERROR_INVALIDDATA;
 350             }
 351
 352             new_w = 4 * ((uint8_t*)s->avctx->extradata)[6 + 2 * f];
 353             new_h = 4 * ((uint8_t*)s->avctx->extradata)[7 + 2 * f];
 354         } else {
 355             new_w = s->orig_width ;
 356             new_h = s->orig_height;
 357         }
 358         if (new_w != s->width || new_h != s->height) {
 359             av_log(s->avctx, AV_LOG_DEBUG,
 360                    "attempting to change resolution to %dx%d\n", new_w, new_h);
 361             if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
 362                 return AVERROR_INVALIDDATA;
 363             ff_MPV_common_end(s);
 364             avcodec_set_dimensions(s->avctx, new_w, new_h);
 365             s->width  = new_w;
 366             s->height = new_h;
 367             if ((ret = ff_MPV_common_init(s)) < 0)
 368                 return ret;
 369         }
 370
 371         if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
 372             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
 373         }
 374     } else if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
 375         return AVERROR_INVALIDDATA;
 376
 377     mb_pos = ff_h263_decode_mba(s);
 378
 379     seq |= s->time & ~0x7FFF;
 380     if (seq - s->time >  0x4000)
 381         seq -= 0x8000;
 382     if (seq - s->time < -0x4000)
 383         seq += 0x8000;
 384
 385     if (seq != s->time) {
 386         if (s->pict_type != AV_PICTURE_TYPE_B) {
 387             s->time            = seq;
 388             s->pp_time         = s->time - s->last_non_b_time;
 389             s->last_non_b_time = s->time;
 390         } else {
 391             s->time    = seq;
 392             s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
 393             if (s->pp_time <= s->pb_time ||
 394                 s->pp_time <= s->pp_time - s->pb_time || s->pp_time <= 0) {
 395                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible "
 396                        "from seeking? skipping current b frame\n");
 397                 return FRAME_SKIPPED;
 398             }
 399             ff_mpeg4_init_direct_mv(s);
 400         }
 401     }
 402
 403     s->no_rounding = get_bits1(&s->gb);
 404
 405     if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
 406         skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
 407
 408     s->f_code          = 1;
 409     s->unrestricted_mv = 1;
 410     s->h263_aic        = s->pict_type == AV_PICTURE_TYPE_I;
 411     s->modified_quant  = 1;
 412     s->loop_filter     = 1;
 413
 414     if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
 415         av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
 416                seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
 417     }
 418
 419     assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
 420
 421     return s->mb_width*s->mb_height - mb_pos;
 422 }
 423
 424 static av_cold int rv10_decode_init(AVCodecContext *avctx)
 425 {
 426     RVDecContext  *rv = avctx->priv_data;
 427     MpegEncContext *s = &rv->m;
 428     static int done = 0;
 429     int major_ver, minor_ver, micro_ver, ret;
 430
 431     if (avctx->extradata_size < 8) {
 432         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
 433         return AVERROR_INVALIDDATA;
 434     }
 435
 436     ff_MPV_decode_defaults(s);
 437
 438     s->avctx      = avctx;
 439     s->out_format = FMT_H263;
 440     s->codec_id   = avctx->codec_id;
 441     avctx->flags |= CODEC_FLAG_EMU_EDGE;
 442
 443     s->orig_width  = s->width  = avctx->coded_width;
 444     s->orig_height = s->height = avctx->coded_height;
 445
 446     s->h263_long_vectors = ((uint8_t*)avctx->extradata)[3] & 1;
 447     rv->sub_id           = AV_RB32((uint8_t*)avctx->extradata + 4);
 448
 449     major_ver = RV_GET_MAJOR_VER(rv->sub_id);
 450     minor_ver = RV_GET_MINOR_VER(rv->sub_id);
 451     micro_ver = RV_GET_MICRO_VER(rv->sub_id);
 452
 453     s->low_delay = 1;
 454     switch (major_ver) {
 455     case 1:
 456         s->rv10_version = micro_ver ? 3 : 1;
 457         s->obmc         = micro_ver == 2;
 458         break;
 459     case 2:
 460         if (minor_ver >= 2) {
 461             s->low_delay           = 0;
 462             s->avctx->has_b_frames = 1;
 463         }
 464         break;
 465     default:
 466         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
 467         avpriv_request_sample(avctx, "RV1/2 version");
 468         return AVERROR_PATCHWELCOME;
 469     }
 470
 471     if (avctx->debug & FF_DEBUG_PICT_INFO) {
 472         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
 473                avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
 474     }
 475
 476     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 477
 478     if ((ret = ff_MPV_common_init(s)) < 0)
 479         return ret;
 480
 481     ff_h263_decode_init_vlc();
 482
 483     /* init rv vlc */
 484     if (!done) {
 485         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
 486                         rv_lum_bits, 1, 1,
 487                         rv_lum_code, 2, 2, 16384);
 488         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
 489                         rv_chrom_bits, 1, 1,
 490                         rv_chrom_code, 2, 2, 16388);
 491         done = 1;
 492     }
 493
 494     return 0;
 495 }
 496
 497 static av_cold int rv10_decode_end(AVCodecContext *avctx)
 498 {
 499     MpegEncContext *s = avctx->priv_data;
 500
 501     ff_MPV_common_end(s);
 502     return 0;
 503 }
 504
 505 static int rv10_decode_packet(AVCodecContext *avctx,
 506                               const uint8_t *buf, int buf_size, int buf_size2)
 507 {
 508     RVDecContext  *rv = avctx->priv_data;
 509     MpegEncContext *s = &rv->m;
 510     int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
 511
 512     active_bits_size = buf_size * 8;
 513     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
 514     if (s->codec_id == AV_CODEC_ID_RV10)
 515         mb_count = rv10_decode_picture_header(s);
 516     else
 517         mb_count = rv20_decode_picture_header(rv);
 518     if (mb_count < 0) {
 519         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 520         return AVERROR_INVALIDDATA;
 521     }
 522
 523     if (s->mb_x >= s->mb_width ||
 524         s->mb_y >= s->mb_height) {
 525         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 526         return AVERROR_INVALIDDATA;
 527     }
 528     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 529     left = s->mb_width * s->mb_height - mb_pos;
 530     if (mb_count > left) {
 531         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 532         return AVERROR_INVALIDDATA;
 533     }
 534
 535     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
 536         if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?
 537             ff_er_frame_end(&s->er);
 538             ff_MPV_frame_end(s);
 539             s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
 540         }
 541         if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
 542             return ret;
 543         ff_mpeg_er_frame_start(s);
 544     } else {
 545         if (s->current_picture_ptr->f.pict_type != s->pict_type) {
 546             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
 547             return AVERROR_INVALIDDATA;
 548         }
 549     }
 550
 551     av_dlog(avctx, "qscale=%d\n", s->qscale);
 552
 553     /* default quantization values */
 554     if (s->codec_id == AV_CODEC_ID_RV10) {
 555         if (s->mb_y == 0)
 556             s->first_slice_line = 1;
 557     } else {
 558         s->first_slice_line = 1;
 559         s->resync_mb_x      = s->mb_x;
 560     }
 561     start_mb_x     = s->mb_x;
 562     s->resync_mb_y = s->mb_y;
 563     if (s->h263_aic) {
 564         s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;
 565     } else {
 566         s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
 567     }
 568
 569     if (s->modified_quant)
 570         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
 571
 572     ff_set_qscale(s, s->qscale);
 573
 574     s->rv10_first_dc_coded[0] = 0;
 575     s->rv10_first_dc_coded[1] = 0;
 576     s->rv10_first_dc_coded[2] = 0;
 577     s->block_wrap[0] =
 578     s->block_wrap[1] =
 579     s->block_wrap[2] =
 580     s->block_wrap[3] = s->b8_stride;
 581     s->block_wrap[4] =
 582     s->block_wrap[5] = s->mb_stride;
 583     ff_init_block_index(s);
 584
 585     /* decode each macroblock */
 586     for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
 587         int ret;
 588         ff_update_block_index(s);
 589         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 590
 591         s->mv_dir  = MV_DIR_FORWARD;
 592         s->mv_type = MV_TYPE_16X16;
 593         ret = ff_h263_decode_mb(s, s->block);
 594
 595         // Repeat the slice end check from ff_h263_decode_mb with our active
 596         // bitstream size
 597         if (ret != SLICE_ERROR) {
 598             int v = show_bits(&s->gb, 16);
 599
 600             if (get_bits_count(&s->gb) + 16 > active_bits_size)
 601                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
 602
 603             if (!v)
 604                 ret = SLICE_END;
 605         }
 606         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
 607             8 * buf_size2 >= get_bits_count(&s->gb)) {
 608             active_bits_size = buf_size2 * 8;
 609             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
 610                    8 * buf_size, active_bits_size);
 611             ret = SLICE_OK;
 612         }
 613
 614         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
 615             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 616             return AVERROR_INVALIDDATA;
 617         }
 618         if (s->pict_type != AV_PICTURE_TYPE_B)
 619             ff_h263_update_motion_val(s);
 620         ff_MPV_decode_mb(s, s->block);
 621         if (s->loop_filter)
 622             ff_h263_loop_filter(s);
 623
 624         if (++s->mb_x == s->mb_width) {
 625             s->mb_x = 0;
 626             s->mb_y++;
 627             ff_init_block_index(s);
 628         }
 629         if (s->mb_x == s->resync_mb_x)
 630             s->first_slice_line = 0;
 631         if (ret == SLICE_END)
 632             break;
 633     }
 634
 635     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,
 636                     ER_MB_END);
 637
 638     return active_bits_size;
 639 }
 640
 641 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
 642 {
 643     if (avctx->slice_count)
 644         return avctx->slice_offset[n];
 645     else
 646         return AV_RL32(buf + n * 8);
 647 }
 648
 649 static int rv10_decode_frame(AVCodecContext *avctx,
 650                              void *data, int *got_frame,
 651                              AVPacket *avpkt)
 652 {
 653     const uint8_t *buf = avpkt->data;
 654     int buf_size       = avpkt->size;
 655     MpegEncContext *s  = avctx->priv_data;
 656     AVFrame *pict      = data;
 657     int i, ret;
 658     int slice_count;
 659     const uint8_t *slices_hdr = NULL;
 660
 661     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 662
 663     /* no supplementary picture */
 664     if (buf_size == 0) {
 665         return 0;
 666     }
 667
 668     if (!avctx->slice_count) {
 669         slice_count = (*buf++) + 1;
 670         buf_size--;
 671
 672         if (!slice_count || buf_size <= 8 * slice_count) {
 673             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
 674             return AVERROR_INVALIDDATA;
 675         }
 676
 677         slices_hdr = buf + 4;
 678         buf       += 8 * slice_count;
 679         buf_size  -= 8 * slice_count;
 680     } else
 681         slice_count = avctx->slice_count;
 682
 683     for (i = 0; i < slice_count; i++) {
 684         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
 685         int size, size2;
 686
 687         if (offset >= buf_size)
 688             return AVERROR_INVALIDDATA;
 689
 690         if (i + 1 == slice_count)
 691             size = buf_size - offset;
 692         else
 693             size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
 694
 695         if (i + 2 >= slice_count)
 696             size2 = buf_size - offset;
 697         else
 698             size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
 699
 700         if (size <= 0 || size2 <= 0 ||
 701             offset + FFMAX(size, size2) > buf_size)
 702             return AVERROR_INVALIDDATA;
 703
 704         if (rv10_decode_packet(avctx, buf + offset, size, size2) > 8 * size)
 705             i++;
 706     }
 707
 708     if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
 709         ff_er_frame_end(&s->er);
 710         ff_MPV_frame_end(s);
 711
 712         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
 713             if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
 714                 return ret;
 715             ff_print_debug_info(s, s->current_picture_ptr);
 716         } else if (s->last_picture_ptr != NULL) {
 717             if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
 718                 return ret;
 719             ff_print_debug_info(s, s->last_picture_ptr);
 720         }
 721
 722         if (s->last_picture_ptr || s->low_delay) {
 723             *got_frame = 1;
 724         }
 725
 726         // so we can detect if frame_end was not called (find some nicer solution...)
 727         s->current_picture_ptr = NULL;
 728     }
 729
 730     return avpkt->size;
 731 }
 732
 733 AVCodec ff_rv10_decoder = {
 734     .name           = "rv10",
 735     .type           = AVMEDIA_TYPE_VIDEO,
 736     .id             = AV_CODEC_ID_RV10,
 737     .priv_data_size = sizeof(RVDecContext),
 738     .init           = rv10_decode_init,
 739     .close          = rv10_decode_end,
 740     .decode         = rv10_decode_frame,
 741     .capabilities   = CODEC_CAP_DR1,
 742     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 743     .pix_fmts       = ff_pixfmt_list_420,
 744 };
 745
 746 AVCodec ff_rv20_decoder = {
 747     .name           = "rv20",
 748     .type           = AVMEDIA_TYPE_VIDEO,
 749     .id             = AV_CODEC_ID_RV20,
 750     .priv_data_size = sizeof(RVDecContext),
 751     .init           = rv10_decode_init,
 752     .close          = rv10_decode_end,
 753     .decode         = rv10_decode_frame,
 754     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 755     .flush          = ff_mpeg_flush,
 756     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 757     .pix_fmts       = ff_pixfmt_list_420,
 758 };