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