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