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 FFmpeg.
   7  *
   8  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 #if 0
 308     GetBitContext gb= s->gb;
 309     for(i=0; i<64; i++){
 310         av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
 311         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
 312     }
 313     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 314 #endif
 315 #if 0
 316     av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
 317     for(i=0; i<s->avctx->extradata_size; i++){
 318         av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
 319         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
 320     }
 321     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 322 #endif
 323
 324     i= get_bits(&s->gb, 2);
 325     switch(i){
 326     case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
 327     case 1: s->pict_type= AV_PICTURE_TYPE_I; break; //hmm ...
 328     case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
 329     case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
 330     default:
 331         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
 332         return -1;
 333     }
 334
 335     if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
 336         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
 337         return -1;
 338     }
 339
 340     if (get_bits1(&s->gb)){
 341         av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
 342         return -1;
 343     }
 344
 345     s->qscale = get_bits(&s->gb, 5);
 346     if(s->qscale==0){
 347         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 348         return -1;
 349     }
 350
 351     if(RV_GET_MINOR_VER(rv->sub_id) >= 2)
 352         s->loop_filter = get_bits1(&s->gb);
 353
 354     if(RV_GET_MINOR_VER(rv->sub_id) <= 1)
 355         seq = get_bits(&s->gb, 8) << 7;
 356     else
 357         seq = get_bits(&s->gb, 13) << 2;
 358
 359     rpr_bits = s->avctx->extradata[1] & 7;
 360     if(rpr_bits){
 361         int f, new_w, new_h;
 362         rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
 363
 364         f = get_bits(&s->gb, rpr_bits);
 365
 366         if(f){
 367             new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
 368             new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
 369         }else{
 370             new_w= s->orig_width ;
 371             new_h= s->orig_height;
 372         }
 373         if(new_w != s->width || new_h != s->height){
 374             AVRational old_aspect = s->avctx->sample_aspect_ratio;
 375             av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
 376             if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
 377                 return -1;
 378             ff_MPV_common_end(s);
 379
 380             // attempt to keep aspect during typical resolution switches
 381             if (!old_aspect.num)
 382                 old_aspect = (AVRational){1, 1};
 383             if (2 * new_w * s->height == new_h * s->width)
 384                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
 385             if (new_w * s->height == 2 * new_h * s->width)
 386                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
 387             avcodec_set_dimensions(s->avctx, new_w, new_h);
 388             s->width  = new_w;
 389             s->height = new_h;
 390             if (ff_MPV_common_init(s) < 0)
 391                 return -1;
 392         }
 393
 394         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 395             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
 396         }
 397     } else if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
 398         return AVERROR_INVALIDDATA;
 399
 400     mb_pos = ff_h263_decode_mba(s);
 401
 402 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
 403     seq |= s->time &~0x7FFF;
 404     if(seq - s->time >  0x4000) seq -= 0x8000;
 405     if(seq - s->time < -0x4000) seq += 0x8000;
 406     if(seq != s->time){
 407         if(s->pict_type!=AV_PICTURE_TYPE_B){
 408             s->time= seq;
 409             s->pp_time= s->time - s->last_non_b_time;
 410             s->last_non_b_time= s->time;
 411         }else{
 412             s->time= seq;
 413             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
 414             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
 415                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
 416                 return FRAME_SKIPPED;
 417             }
 418             ff_mpeg4_init_direct_mv(s);
 419         }
 420     }
 421 //    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
 422 /*for(i=0; i<32; i++){
 423     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
 424 }
 425 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
 426     s->no_rounding= get_bits1(&s->gb);
 427
 428     if(RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
 429         skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
 430
 431     s->f_code = 1;
 432     s->unrestricted_mv = 1;
 433     s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
 434 //    s->alt_inter_vlc=1;
 435 //    s->obmc=1;
 436 //    s->umvplus=1;
 437     s->modified_quant=1;
 438     s->loop_filter=1;
 439
 440     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 441             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
 442                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
 443     }
 444
 445     assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
 446
 447     return s->mb_width*s->mb_height - mb_pos;
 448 }
 449
 450 static av_cold int rv10_decode_init(AVCodecContext *avctx)
 451 {
 452     RVDecContext  *rv = avctx->priv_data;
 453     MpegEncContext *s = &rv->m;
 454     static int done=0;
 455     int major_ver, minor_ver, micro_ver;
 456
 457     if (avctx->extradata_size < 8) {
 458         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
 459         return -1;
 460     }
 461
 462     ff_MPV_decode_defaults(s);
 463
 464     s->avctx= avctx;
 465     s->out_format = FMT_H263;
 466     s->codec_id= avctx->codec_id;
 467
 468     s->orig_width = s->width  = avctx->coded_width;
 469     s->orig_height= s->height = avctx->coded_height;
 470
 471     s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
 472     rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
 473
 474     major_ver = RV_GET_MAJOR_VER(rv->sub_id);
 475     minor_ver = RV_GET_MINOR_VER(rv->sub_id);
 476     micro_ver = RV_GET_MICRO_VER(rv->sub_id);
 477
 478     s->low_delay = 1;
 479     switch (major_ver) {
 480     case 1:
 481         s->rv10_version = micro_ver ? 3 : 1;
 482         s->obmc = micro_ver == 2;
 483         break;
 484     case 2:
 485         if (minor_ver >= 2) {
 486             s->low_delay = 0;
 487             s->avctx->has_b_frames = 1;
 488         }
 489         break;
 490     default:
 491         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
 492         av_log_missing_feature(avctx, "RV1/2 version", 1);
 493         return AVERROR_PATCHWELCOME;
 494     }
 495
 496     if(avctx->debug & FF_DEBUG_PICT_INFO){
 497         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
 498     }
 499
 500     avctx->pix_fmt = PIX_FMT_YUV420P;
 501
 502     if (ff_MPV_common_init(s) < 0)
 503         return -1;
 504
 505     ff_h263_decode_init_vlc(s);
 506
 507     /* init rv vlc */
 508     if (!done) {
 509         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
 510                  rv_lum_bits, 1, 1,
 511                  rv_lum_code, 2, 2, 16384);
 512         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
 513                  rv_chrom_bits, 1, 1,
 514                  rv_chrom_code, 2, 2, 16388);
 515         done = 1;
 516     }
 517
 518     return 0;
 519 }
 520
 521 static av_cold int rv10_decode_end(AVCodecContext *avctx)
 522 {
 523     MpegEncContext *s = avctx->priv_data;
 524
 525     ff_MPV_common_end(s);
 526     return 0;
 527 }
 528
 529 static int rv10_decode_packet(AVCodecContext *avctx,
 530                              const uint8_t *buf, int buf_size, int buf_size2)
 531 {
 532     RVDecContext  *rv = avctx->priv_data;
 533     MpegEncContext *s = &rv->m;
 534     int mb_count, mb_pos, left, start_mb_x, active_bits_size;
 535
 536     active_bits_size = buf_size * 8;
 537     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
 538     if(s->codec_id ==CODEC_ID_RV10)
 539         mb_count = rv10_decode_picture_header(s);
 540     else
 541         mb_count = rv20_decode_picture_header(rv);
 542     if (mb_count < 0) {
 543         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 544         return -1;
 545     }
 546
 547     if (s->mb_x >= s->mb_width ||
 548         s->mb_y >= s->mb_height) {
 549         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 550         return -1;
 551     }
 552     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 553     left = s->mb_width * s->mb_height - mb_pos;
 554     if (mb_count > left) {
 555         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 556         return -1;
 557     }
 558
 559     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
 560         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
 561             ff_er_frame_end(s);
 562             ff_MPV_frame_end(s);
 563             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
 564         }
 565         if(ff_MPV_frame_start(s, avctx) < 0)
 566             return -1;
 567         ff_er_frame_start(s);
 568     } else {
 569         if (s->current_picture_ptr->f.pict_type != s->pict_type) {
 570             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
 571             return -1;
 572         }
 573     }
 574
 575
 576     av_dlog(avctx, "qscale=%d\n", s->qscale);
 577
 578     /* default quantization values */
 579     if(s->codec_id== CODEC_ID_RV10){
 580         if(s->mb_y==0) s->first_slice_line=1;
 581     }else{
 582         s->first_slice_line=1;
 583         s->resync_mb_x= s->mb_x;
 584     }
 585     start_mb_x= s->mb_x;
 586     s->resync_mb_y= s->mb_y;
 587     if(s->h263_aic){
 588         s->y_dc_scale_table=
 589         s->c_dc_scale_table= ff_aic_dc_scale_table;
 590     }else{
 591         s->y_dc_scale_table=
 592         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 593     }
 594
 595     if(s->modified_quant)
 596         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
 597
 598     ff_set_qscale(s, s->qscale);
 599
 600     s->rv10_first_dc_coded[0] = 0;
 601     s->rv10_first_dc_coded[1] = 0;
 602     s->rv10_first_dc_coded[2] = 0;
 603     s->block_wrap[0]=
 604     s->block_wrap[1]=
 605     s->block_wrap[2]=
 606     s->block_wrap[3]= s->b8_stride;
 607     s->block_wrap[4]=
 608     s->block_wrap[5]= s->mb_stride;
 609     ff_init_block_index(s);
 610     /* decode each macroblock */
 611
 612     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
 613         int ret;
 614         ff_update_block_index(s);
 615         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 616
 617         s->mv_dir = MV_DIR_FORWARD;
 618         s->mv_type = MV_TYPE_16X16;
 619         ret=ff_h263_decode_mb(s, s->block);
 620
 621         // Repeat the slice end check from ff_h263_decode_mb with our active
 622         // bitstream size
 623         if (ret != SLICE_ERROR) {
 624             int v = show_bits(&s->gb, 16);
 625
 626             if (get_bits_count(&s->gb) + 16 > active_bits_size)
 627                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
 628
 629             if (!v)
 630                 ret = SLICE_END;
 631         }
 632         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
 633             8 * buf_size2 >= get_bits_count(&s->gb)) {
 634             active_bits_size = buf_size2 * 8;
 635             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
 636                    8 * buf_size, active_bits_size);
 637             ret= SLICE_OK;
 638         }
 639
 640         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
 641             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 642             return -1;
 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) break;
 658     }
 659
 660     ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
 661
 662     return active_bits_size;
 663 }
 664
 665 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
 666 {
 667     if(avctx->slice_count) return avctx->slice_offset[n];
 668     else                   return AV_RL32(buf + n*8);
 669 }
 670
 671 static int rv10_decode_frame(AVCodecContext *avctx,
 672                              void *data, int *data_size,
 673                              AVPacket *avpkt)
 674 {
 675     const uint8_t *buf = avpkt->data;
 676     int buf_size = avpkt->size;
 677     MpegEncContext *s = avctx->priv_data;
 678     int i;
 679     AVFrame *pict = data;
 680     int slice_count;
 681     const uint8_t *slices_hdr = NULL;
 682
 683     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 684     s->flags  = avctx->flags;
 685     s->flags2 = avctx->flags2;
 686
 687     /* no supplementary picture */
 688     if (buf_size == 0) {
 689         return 0;
 690     }
 691
 692     if(!avctx->slice_count){
 693         slice_count = (*buf++) + 1;
 694         buf_size--;
 695         slices_hdr = buf + 4;
 696         buf += 8 * slice_count;
 697         buf_size -= 8 * slice_count;
 698         if (buf_size <= 0)
 699             return AVERROR_INVALIDDATA;
 700     }else
 701         slice_count = avctx->slice_count;
 702
 703     for(i=0; i<slice_count; i++){
 704         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
 705         int size, size2;
 706
 707         if (offset >= buf_size)
 708             return AVERROR_INVALIDDATA;
 709
 710         if(i+1 == slice_count)
 711             size= buf_size - offset;
 712         else
 713             size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
 714
 715         if(i+2 >= slice_count)
 716             size2= buf_size - offset;
 717         else
 718             size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
 719
 720         if (size <= 0 || size2 <= 0 ||
 721             offset + FFMAX(size, size2) > buf_size)
 722             return AVERROR_INVALIDDATA;
 723
 724         if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
 725             i++;
 726     }
 727
 728     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
 729         ff_er_frame_end(s);
 730         ff_MPV_frame_end(s);
 731
 732         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
 733             *pict = s->current_picture_ptr->f;
 734         } else if (s->last_picture_ptr != NULL) {
 735             *pict = s->last_picture_ptr->f;
 736         }
 737
 738         if(s->last_picture_ptr || s->low_delay){
 739             *data_size = sizeof(AVFrame);
 740             ff_print_debug_info(s, pict);
 741         }
 742         s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
 743     }
 744
 745     return avpkt->size;
 746 }
 747
 748 AVCodec ff_rv10_decoder = {
 749     .name           = "rv10",
 750     .type           = AVMEDIA_TYPE_VIDEO,
 751     .id             = CODEC_ID_RV10,
 752     .priv_data_size = sizeof(RVDecContext),
 753     .init           = rv10_decode_init,
 754     .close          = rv10_decode_end,
 755     .decode         = rv10_decode_frame,
 756     .capabilities   = CODEC_CAP_DR1,
 757     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 758     .pix_fmts       = ff_pixfmt_list_420,
 759 };
 760
 761 AVCodec ff_rv20_decoder = {
 762     .name           = "rv20",
 763     .type           = AVMEDIA_TYPE_VIDEO,
 764     .id             = CODEC_ID_RV20,
 765     .priv_data_size = sizeof(RVDecContext),
 766     .init           = rv10_decode_init,
 767     .close          = rv10_decode_end,
 768     .decode         = rv10_decode_frame,
 769     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 770     .flush          = ff_mpeg_flush,
 771     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 772     .pix_fmts       = ff_pixfmt_list_420,
 773 };