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