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