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
 448     s->orig_width  = s->width  = avctx->coded_width;
 449     s->orig_height = s->height = avctx->coded_height;
 450
 451     s->h263_long_vectors = ((uint8_t*)avctx->extradata)[3] & 1;
 452     rv->sub_id           = AV_RB32((uint8_t*)avctx->extradata + 4);
 453
 454     major_ver = RV_GET_MAJOR_VER(rv->sub_id);
 455     minor_ver = RV_GET_MINOR_VER(rv->sub_id);
 456     micro_ver = RV_GET_MICRO_VER(rv->sub_id);
 457
 458     s->low_delay = 1;
 459     switch (major_ver) {
 460     case 1:
 461         s->rv10_version = micro_ver ? 3 : 1;
 462         s->obmc         = micro_ver == 2;
 463         break;
 464     case 2:
 465         if (minor_ver >= 2) {
 466             s->low_delay           = 0;
 467             s->avctx->has_b_frames = 1;
 468         }
 469         break;
 470     default:
 471         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
 472         avpriv_request_sample(avctx, "RV1/2 version");
 473         return AVERROR_PATCHWELCOME;
 474     }
 475
 476     if (avctx->debug & FF_DEBUG_PICT_INFO) {
 477         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
 478                avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
 479     }
 480
 481     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 482
 483     if ((ret = ff_MPV_common_init(s)) < 0)
 484         return ret;
 485
 486     ff_h263dsp_init(&s->h263dsp);
 487     ff_h263_decode_init_vlc();
 488
 489     /* init rv vlc */
 490     if (!done) {
 491         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
 492                         rv_lum_bits, 1, 1,
 493                         rv_lum_code, 2, 2, 16384);
 494         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
 495                         rv_chrom_bits, 1, 1,
 496                         rv_chrom_code, 2, 2, 16388);
 497         done = 1;
 498     }
 499
 500     return 0;
 501 }
 502
 503 static av_cold int rv10_decode_end(AVCodecContext *avctx)
 504 {
 505     MpegEncContext *s = avctx->priv_data;
 506
 507     ff_MPV_common_end(s);
 508     return 0;
 509 }
 510
 511 static int rv10_decode_packet(AVCodecContext *avctx,
 512                               const uint8_t *buf, int buf_size, int buf_size2)
 513 {
 514     RVDecContext  *rv = avctx->priv_data;
 515     MpegEncContext *s = &rv->m;
 516     int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
 517
 518     active_bits_size = buf_size * 8;
 519     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
 520     if (s->codec_id == AV_CODEC_ID_RV10)
 521         mb_count = rv10_decode_picture_header(s);
 522     else
 523         mb_count = rv20_decode_picture_header(rv);
 524     if (mb_count < 0) {
 525         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 526         return AVERROR_INVALIDDATA;
 527     }
 528
 529     if (s->mb_x >= s->mb_width ||
 530         s->mb_y >= s->mb_height) {
 531         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 532         return AVERROR_INVALIDDATA;
 533     }
 534     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 535     left = s->mb_width * s->mb_height - mb_pos;
 536     if (mb_count > left) {
 537         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 538         return AVERROR_INVALIDDATA;
 539     }
 540
 541     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
 542         if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?
 543             ff_er_frame_end(&s->er);
 544             ff_MPV_frame_end(s);
 545             s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
 546         }
 547         if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
 548             return ret;
 549         ff_mpeg_er_frame_start(s);
 550     } else {
 551         if (s->current_picture_ptr->f.pict_type != s->pict_type) {
 552             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
 553             return AVERROR_INVALIDDATA;
 554         }
 555     }
 556
 557     av_dlog(avctx, "qscale=%d\n", s->qscale);
 558
 559     /* default quantization values */
 560     if (s->codec_id == AV_CODEC_ID_RV10) {
 561         if (s->mb_y == 0)
 562             s->first_slice_line = 1;
 563     } else {
 564         s->first_slice_line = 1;
 565         s->resync_mb_x      = s->mb_x;
 566     }
 567     start_mb_x     = s->mb_x;
 568     s->resync_mb_y = s->mb_y;
 569     if (s->h263_aic) {
 570         s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;
 571     } else {
 572         s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
 573     }
 574
 575     if (s->modified_quant)
 576         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
 577
 578     ff_set_qscale(s, s->qscale);
 579
 580     s->rv10_first_dc_coded[0] = 0;
 581     s->rv10_first_dc_coded[1] = 0;
 582     s->rv10_first_dc_coded[2] = 0;
 583     s->block_wrap[0] =
 584     s->block_wrap[1] =
 585     s->block_wrap[2] =
 586     s->block_wrap[3] = s->b8_stride;
 587     s->block_wrap[4] =
 588     s->block_wrap[5] = s->mb_stride;
 589     ff_init_block_index(s);
 590
 591     /* decode each macroblock */
 592     for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
 593         int ret;
 594         ff_update_block_index(s);
 595         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 596
 597         s->mv_dir  = MV_DIR_FORWARD;
 598         s->mv_type = MV_TYPE_16X16;
 599         ret = ff_h263_decode_mb(s, s->block);
 600
 601         // Repeat the slice end check from ff_h263_decode_mb with our active
 602         // bitstream size
 603         if (ret != SLICE_ERROR) {
 604             int v = show_bits(&s->gb, 16);
 605
 606             if (get_bits_count(&s->gb) + 16 > active_bits_size)
 607                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
 608
 609             if (!v)
 610                 ret = SLICE_END;
 611         }
 612         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
 613             8 * buf_size2 >= get_bits_count(&s->gb)) {
 614             active_bits_size = buf_size2 * 8;
 615             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
 616                    8 * buf_size, active_bits_size);
 617             ret = SLICE_OK;
 618         }
 619
 620         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
 621             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 622             return AVERROR_INVALIDDATA;
 623         }
 624         if (s->pict_type != AV_PICTURE_TYPE_B)
 625             ff_h263_update_motion_val(s);
 626         ff_MPV_decode_mb(s, s->block);
 627         if (s->loop_filter)
 628             ff_h263_loop_filter(s);
 629
 630         if (++s->mb_x == s->mb_width) {
 631             s->mb_x = 0;
 632             s->mb_y++;
 633             ff_init_block_index(s);
 634         }
 635         if (s->mb_x == s->resync_mb_x)
 636             s->first_slice_line = 0;
 637         if (ret == SLICE_END)
 638             break;
 639     }
 640
 641     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,
 642                     ER_MB_END);
 643
 644     return active_bits_size;
 645 }
 646
 647 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
 648 {
 649     if (avctx->slice_count)
 650         return avctx->slice_offset[n];
 651     else
 652         return AV_RL32(buf + n * 8);
 653 }
 654
 655 static int rv10_decode_frame(AVCodecContext *avctx,
 656                              void *data, int *got_frame,
 657                              AVPacket *avpkt)
 658 {
 659     const uint8_t *buf = avpkt->data;
 660     int buf_size       = avpkt->size;
 661     MpegEncContext *s  = avctx->priv_data;
 662     AVFrame *pict      = data;
 663     int i, ret;
 664     int slice_count;
 665     const uint8_t *slices_hdr = NULL;
 666
 667     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 668
 669     /* no supplementary picture */
 670     if (buf_size == 0) {
 671         return 0;
 672     }
 673
 674     if (!avctx->slice_count) {
 675         slice_count = (*buf++) + 1;
 676         buf_size--;
 677
 678         if (!slice_count || buf_size <= 8 * slice_count) {
 679             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
 680             return AVERROR_INVALIDDATA;
 681         }
 682
 683         slices_hdr = buf + 4;
 684         buf       += 8 * slice_count;
 685         buf_size  -= 8 * slice_count;
 686     } else
 687         slice_count = avctx->slice_count;
 688
 689     for (i = 0; i < slice_count; i++) {
 690         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
 691         int size, size2;
 692
 693         if (offset >= buf_size)
 694             return AVERROR_INVALIDDATA;
 695
 696         if (i + 1 == slice_count)
 697             size = buf_size - offset;
 698         else
 699             size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
 700
 701         if (i + 2 >= slice_count)
 702             size2 = buf_size - offset;
 703         else
 704             size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
 705
 706         if (size <= 0 || size2 <= 0 ||
 707             offset + FFMAX(size, size2) > buf_size)
 708             return AVERROR_INVALIDDATA;
 709
 710         if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2)) < 0)
 711             return ret;
 712
 713         if (ret > 8 * size)
 714             i++;
 715     }
 716
 717     if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
 718         ff_er_frame_end(&s->er);
 719         ff_MPV_frame_end(s);
 720
 721         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
 722             if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
 723                 return ret;
 724             ff_print_debug_info(s, s->current_picture_ptr);
 725         } else if (s->last_picture_ptr != NULL) {
 726             if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
 727                 return ret;
 728             ff_print_debug_info(s, s->last_picture_ptr);
 729         }
 730
 731         if (s->last_picture_ptr || s->low_delay) {
 732             *got_frame = 1;
 733         }
 734
 735         // so we can detect if frame_end was not called (find some nicer solution...)
 736         s->current_picture_ptr = NULL;
 737     }
 738
 739     return avpkt->size;
 740 }
 741
 742 AVCodec ff_rv10_decoder = {
 743     .name           = "rv10",
 744     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 745     .type           = AVMEDIA_TYPE_VIDEO,
 746     .id             = AV_CODEC_ID_RV10,
 747     .priv_data_size = sizeof(RVDecContext),
 748     .init           = rv10_decode_init,
 749     .close          = rv10_decode_end,
 750     .decode         = rv10_decode_frame,
 751     .capabilities   = CODEC_CAP_DR1,
 752     .pix_fmts       = ff_pixfmt_list_420,
 753 };
 754
 755 AVCodec ff_rv20_decoder = {
 756     .name           = "rv20",
 757     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 758     .type           = AVMEDIA_TYPE_VIDEO,
 759     .id             = AV_CODEC_ID_RV20,
 760     .priv_data_size = sizeof(RVDecContext),
 761     .init           = rv10_decode_init,
 762     .close          = rv10_decode_end,
 763     .decode         = rv10_decode_frame,
 764     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 765     .flush          = ff_mpeg_flush,
 766     .pix_fmts       = ff_pixfmt_list_420,
 767 };