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 "mpegvideo.h"
  31 #include "mpeg4video.h"
  32 #include "h263.h"
  33
  34 //#define DEBUG
  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 {
  49  0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
  50  0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
  51  0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
  52  0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
  53  0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
  54  0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
  55  0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
  56  0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
  57  0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
  58  0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
  59  0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
  60  0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
  61  0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
  62  0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
  63  0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
  64  0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
  65  0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
  66  0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
  67  0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
  68  0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
  69  0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
  70  0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
  71  0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
  72  0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
  73  0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
  74  0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
  75  0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
  76  0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
  77  0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
  78  0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
  79  0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
  80  0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
  81 };
  82
  83 static const uint8_t rv_lum_bits[256] =
  84 {
  85  14, 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, 12, 12, 12, 12, 12, 12, 12,
  92  12, 12, 12, 12, 12, 12, 12, 12,
  93  12, 10, 10, 10, 10, 10, 10, 10,
  94  10, 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,  8,  8,  8,  8,  8,  8,  8,
  98   8,  8,  8,  8,  8,  8,  8,  8,
  99   8,  7,  7,  7,  7,  7,  7,  7,
 100   7,  6,  6,  6,  6,  5,  5,  4,
 101   2,  4,  5,  5,  6,  6,  6,  6,
 102   7,  7,  7,  7,  7,  7,  7,  7,
 103   8,  8,  8,  8,  8,  8,  8,  8,
 104   8,  8,  8,  8,  8,  8,  8,  8,
 105  10, 10, 10, 10, 10, 10, 10, 10,
 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  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  12, 12, 12, 12, 12, 12, 12, 12,
 116  12, 12, 12, 12, 12, 12, 12, 12,
 117 };
 118
 119 static const uint16_t rv_chrom_code[256] =
 120 {
 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 {
 157  16, 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, 14, 14, 14, 14, 14, 14, 14,
 165  14, 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, 12, 12, 12, 12, 12, 12, 12,
 169  12, 10, 10, 10, 10, 10, 10, 10,
 170  10, 10, 10, 10, 10, 10, 10, 10,
 171  10,  8,  8,  8,  8,  8,  8,  8,
 172   8,  6,  6,  6,  6,  4,  4,  3,
 173   2,  3,  4,  4,  6,  6,  6,  6,
 174   8,  8,  8,  8,  8,  8,  8,  8,
 175  10, 10, 10, 10, 10, 10, 10, 10,
 176  10, 10, 10, 10, 10, 10, 10, 10,
 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  12, 12, 12, 12, 12, 12, 12, 12,
 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  14, 14, 14, 14, 14, 14, 14, 14,
 189 };
 190
 191 static VLC rv_dc_lum, rv_dc_chrom;
 192
 193 int ff_rv_decode_dc(MpegEncContext *s, int n)
 194 {
 195     int code;
 196
 197     if (n < 4) {
 198         code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
 199         if (code < 0) {
 200             /* XXX: I don't understand why they use LONGER codes than
 201                necessary. The following code would be completely useless
 202                if they had thought about it !!! */
 203             code = get_bits(&s->gb, 7);
 204             if (code == 0x7c) {
 205                 code = (int8_t)(get_bits(&s->gb, 7) + 1);
 206             } else if (code == 0x7d) {
 207                 code = -128 + get_bits(&s->gb, 7);
 208             } else if (code == 0x7e) {
 209                 if (get_bits1(&s->gb) == 0)
 210                     code = (int8_t)(get_bits(&s->gb, 8) + 1);
 211                 else
 212                     code = (int8_t)(get_bits(&s->gb, 8));
 213             } else if (code == 0x7f) {
 214                 skip_bits(&s->gb, 11);
 215                 code = 1;
 216             }
 217         } else {
 218             code -= 128;
 219         }
 220     } else {
 221         code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
 222         /* same remark */
 223         if (code < 0) {
 224             code = get_bits(&s->gb, 9);
 225             if (code == 0x1fc) {
 226                 code = (int8_t)(get_bits(&s->gb, 7) + 1);
 227             } else if (code == 0x1fd) {
 228                 code = -128 + get_bits(&s->gb, 7);
 229             } else if (code == 0x1fe) {
 230                 skip_bits(&s->gb, 9);
 231                 code = 1;
 232             } else {
 233                 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
 234                 return 0xffff;
 235             }
 236         } else {
 237             code -= 128;
 238         }
 239     }
 240     return -code;
 241 }
 242
 243 /* read RV 1.0 compatible frame header */
 244 static int rv10_decode_picture_header(MpegEncContext *s)
 245 {
 246     int mb_count, pb_frame, marker, mb_xy;
 247
 248     marker = get_bits1(&s->gb);
 249
 250     if (get_bits1(&s->gb))
 251         s->pict_type = AV_PICTURE_TYPE_P;
 252     else
 253         s->pict_type = AV_PICTURE_TYPE_I;
 254     if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
 255     pb_frame = get_bits1(&s->gb);
 256
 257     av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
 258
 259     if (pb_frame){
 260         av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
 261         return -1;
 262     }
 263
 264     s->qscale = get_bits(&s->gb, 5);
 265     if(s->qscale==0){
 266         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 267         return -1;
 268     }
 269
 270     if (s->pict_type == AV_PICTURE_TYPE_I) {
 271         if (s->rv10_version == 3) {
 272             /* specific MPEG like DC coding not used */
 273             s->last_dc[0] = get_bits(&s->gb, 8);
 274             s->last_dc[1] = get_bits(&s->gb, 8);
 275             s->last_dc[2] = get_bits(&s->gb, 8);
 276             av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
 277                     s->last_dc[1], s->last_dc[2]);
 278         }
 279     }
 280     /* if multiple packets per frame are sent, the position at which
 281        to display the macroblocks is coded here */
 282
 283     mb_xy= s->mb_x + s->mb_y*s->mb_width;
 284     if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
 285         s->mb_x = get_bits(&s->gb, 6); /* mb_x */
 286         s->mb_y = get_bits(&s->gb, 6); /* mb_y */
 287         mb_count = get_bits(&s->gb, 12);
 288     } else {
 289         s->mb_x = 0;
 290         s->mb_y = 0;
 291         mb_count = s->mb_width * s->mb_height;
 292     }
 293     skip_bits(&s->gb, 3);   /* ignored */
 294     s->f_code = 1;
 295     s->unrestricted_mv = 1;
 296
 297     return mb_count;
 298 }
 299
 300 static int rv20_decode_picture_header(RVDecContext *rv)
 301 {
 302     MpegEncContext *s = &rv->m;
 303     int seq, mb_pos, i;
 304     int rpr_bits;
 305
 306 #if 0
 307     GetBitContext gb= s->gb;
 308     for(i=0; i<64; i++){
 309         av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
 310         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
 311     }
 312     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 313 #endif
 314 #if 0
 315     av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
 316     for(i=0; i<s->avctx->extradata_size; i++){
 317         av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
 318         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
 319     }
 320     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 321 #endif
 322
 323     i= get_bits(&s->gb, 2);
 324     switch(i){
 325     case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
 326     case 1: s->pict_type= AV_PICTURE_TYPE_I; break; //hmm ...
 327     case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
 328     case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
 329     default:
 330         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
 331         return -1;
 332     }
 333
 334     if(s->low_delay && s->pict_type==AV_PICTURE_TYPE_B){
 335         av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
 336         return -1;
 337     }
 338     if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
 339         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
 340         return -1;
 341     }
 342
 343     if (get_bits1(&s->gb)){
 344         av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
 345         return -1;
 346     }
 347
 348     s->qscale = get_bits(&s->gb, 5);
 349     if(s->qscale==0){
 350         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 351         return -1;
 352     }
 353
 354     if(RV_GET_MINOR_VER(rv->sub_id) >= 2)
 355         s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
 356
 357     if(RV_GET_MINOR_VER(rv->sub_id) <= 1)
 358         seq = get_bits(&s->gb, 8) << 7;
 359     else
 360         seq = get_bits(&s->gb, 13) << 2;
 361
 362     rpr_bits = s->avctx->extradata[1] & 7;
 363     if(rpr_bits){
 364         int f, new_w, new_h;
 365         rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
 366
 367         f = get_bits(&s->gb, rpr_bits);
 368
 369         if(f){
 370             new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
 371             new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
 372         }else{
 373             new_w= s->orig_width ;
 374             new_h= s->orig_height;
 375         }
 376         if(new_w != s->width || new_h != s->height){
 377             AVRational old_aspect = s->avctx->sample_aspect_ratio;
 378             av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
 379             if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
 380                 return -1;
 381             ff_MPV_common_end(s);
 382
 383             // attempt to keep aspect during typical resolution switches
 384             if (!old_aspect.num)
 385                 old_aspect = (AVRational){1, 1};
 386             if (2 * new_w * s->height == new_h * s->width)
 387                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
 388             if (new_w * s->height == 2 * new_h * s->width)
 389                 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
 390             avcodec_set_dimensions(s->avctx, new_w, new_h);
 391             s->width  = new_w;
 392             s->height = new_h;
 393             if (ff_MPV_common_init(s) < 0)
 394                 return -1;
 395         }
 396
 397         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 398             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
 399         }
 400     }
 401     if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
 402         return AVERROR_INVALIDDATA;
 403
 404     mb_pos = ff_h263_decode_mba(s);
 405
 406     seq |= s->time &~0x7FFF;
 407     if(seq - s->time >  0x4000) seq -= 0x8000;
 408     if(seq - s->time < -0x4000) seq += 0x8000;
 409     if(seq != s->time){
 410         if(s->pict_type!=AV_PICTURE_TYPE_B){
 411             s->time= seq;
 412             s->pp_time= s->time - s->last_non_b_time;
 413             s->last_non_b_time= s->time;
 414         }else{
 415             s->time= seq;
 416             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
 417         }
 418     }
 419     if (s->pict_type==AV_PICTURE_TYPE_B) {
 420         if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
 421             av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
 422             return FRAME_SKIPPED;
 423         }
 424         ff_mpeg4_init_direct_mv(s);
 425     }
 426
 427     s->no_rounding= get_bits1(&s->gb);
 428
 429     if(RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
 430         skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
 431
 432     s->f_code = 1;
 433     s->unrestricted_mv = 1;
 434     s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
 435 //    s->alt_inter_vlc=1;
 436 //    s->obmc=1;
 437 //    s->umvplus=1;
 438     s->modified_quant=1;
 439     if(!s->avctx->lowres)
 440         s->loop_filter=1;
 441
 442     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 443             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
 444                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
 445     }
 446
 447     av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
 448
 449     return s->mb_width*s->mb_height - mb_pos;
 450 }
 451
 452 static av_cold int rv10_decode_init(AVCodecContext *avctx)
 453 {
 454     RVDecContext  *rv = avctx->priv_data;
 455     MpegEncContext *s = &rv->m;
 456     static int done=0;
 457     int major_ver, minor_ver, micro_ver;
 458
 459     if (avctx->extradata_size < 8) {
 460         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
 461         return -1;
 462     }
 463
 464     ff_MPV_decode_defaults(s);
 465
 466     s->avctx= avctx;
 467     s->out_format = FMT_H263;
 468     s->codec_id= avctx->codec_id;
 469
 470     s->orig_width = s->width  = avctx->coded_width;
 471     s->orig_height= s->height = avctx->coded_height;
 472
 473     s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
 474     rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
 475
 476     major_ver = RV_GET_MAJOR_VER(rv->sub_id);
 477     minor_ver = RV_GET_MINOR_VER(rv->sub_id);
 478     micro_ver = RV_GET_MICRO_VER(rv->sub_id);
 479
 480     s->low_delay = 1;
 481     switch (major_ver) {
 482     case 1:
 483         s->rv10_version = micro_ver ? 3 : 1;
 484         s->obmc = micro_ver == 2;
 485         break;
 486     case 2:
 487         if (minor_ver >= 2) {
 488             s->low_delay = 0;
 489             s->avctx->has_b_frames = 1;
 490         }
 491         break;
 492     default:
 493         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
 494         av_log_missing_feature(avctx, "RV1/2 version", 1);
 495         return AVERROR_PATCHWELCOME;
 496     }
 497
 498     if(avctx->debug & FF_DEBUG_PICT_INFO){
 499         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id, ((uint32_t*)avctx->extradata)[0]);
 500     }
 501
 502     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 503
 504     if (ff_MPV_common_init(s) < 0)
 505         return -1;
 506
 507     ff_h263_decode_init_vlc();
 508
 509     /* init rv vlc */
 510     if (!done) {
 511         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
 512                  rv_lum_bits, 1, 1,
 513                  rv_lum_code, 2, 2, 16384);
 514         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
 515                  rv_chrom_bits, 1, 1,
 516                  rv_chrom_code, 2, 2, 16388);
 517         done = 1;
 518     }
 519
 520     return 0;
 521 }
 522
 523 static av_cold int rv10_decode_end(AVCodecContext *avctx)
 524 {
 525     MpegEncContext *s = avctx->priv_data;
 526
 527     ff_MPV_common_end(s);
 528     return 0;
 529 }
 530
 531 static int rv10_decode_packet(AVCodecContext *avctx,
 532                              const uint8_t *buf, int buf_size, int buf_size2)
 533 {
 534     RVDecContext  *rv = avctx->priv_data;
 535     MpegEncContext *s = &rv->m;
 536     int mb_count, mb_pos, left, start_mb_x, active_bits_size;
 537
 538     active_bits_size = buf_size * 8;
 539     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
 540     if(s->codec_id ==AV_CODEC_ID_RV10)
 541         mb_count = rv10_decode_picture_header(s);
 542     else
 543         mb_count = rv20_decode_picture_header(rv);
 544     if (mb_count < 0) {
 545         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 546         return -1;
 547     }
 548
 549     if (s->mb_x >= s->mb_width ||
 550         s->mb_y >= s->mb_height) {
 551         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 552         return -1;
 553     }
 554     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 555     left = s->mb_width * s->mb_height - mb_pos;
 556     if (mb_count > left) {
 557         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 558         return -1;
 559     }
 560
 561     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
 562         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
 563             ff_er_frame_end(&s->er);
 564             ff_MPV_frame_end(s);
 565             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
 566         }
 567         if(ff_MPV_frame_start(s, avctx) < 0)
 568             return -1;
 569         ff_mpeg_er_frame_start(s);
 570     } else {
 571         if (s->current_picture_ptr->f.pict_type != s->pict_type) {
 572             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
 573             return -1;
 574         }
 575     }
 576
 577
 578     av_dlog(avctx, "qscale=%d\n", s->qscale);
 579
 580     /* default quantization values */
 581     if(s->codec_id== AV_CODEC_ID_RV10){
 582         if(s->mb_y==0) s->first_slice_line=1;
 583     }else{
 584         s->first_slice_line=1;
 585         s->resync_mb_x= s->mb_x;
 586     }
 587     start_mb_x= s->mb_x;
 588     s->resync_mb_y= s->mb_y;
 589     if(s->h263_aic){
 590         s->y_dc_scale_table=
 591         s->c_dc_scale_table= ff_aic_dc_scale_table;
 592     }else{
 593         s->y_dc_scale_table=
 594         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 595     }
 596
 597     if(s->modified_quant)
 598         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
 599
 600     ff_set_qscale(s, s->qscale);
 601
 602     s->rv10_first_dc_coded[0] = 0;
 603     s->rv10_first_dc_coded[1] = 0;
 604     s->rv10_first_dc_coded[2] = 0;
 605     s->block_wrap[0]=
 606     s->block_wrap[1]=
 607     s->block_wrap[2]=
 608     s->block_wrap[3]= s->b8_stride;
 609     s->block_wrap[4]=
 610     s->block_wrap[5]= s->mb_stride;
 611     ff_init_block_index(s);
 612     /* decode each macroblock */
 613
 614     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
 615         int ret;
 616         ff_update_block_index(s);
 617         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 618
 619         s->mv_dir = MV_DIR_FORWARD;
 620         s->mv_type = MV_TYPE_16X16;
 621         ret=ff_h263_decode_mb(s, s->block);
 622
 623         // Repeat the slice end check from ff_h263_decode_mb with our active
 624         // bitstream size
 625         if (ret != SLICE_ERROR) {
 626             int v = show_bits(&s->gb, 16);
 627
 628             if (get_bits_count(&s->gb) + 16 > active_bits_size)
 629                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
 630
 631             if (!v)
 632                 ret = SLICE_END;
 633         }
 634         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
 635             8 * buf_size2 >= get_bits_count(&s->gb)) {
 636             active_bits_size = buf_size2 * 8;
 637             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
 638                    8 * buf_size, active_bits_size);
 639             ret= SLICE_OK;
 640         }
 641
 642         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
 643             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 644             return -1;
 645         }
 646         if(s->pict_type != AV_PICTURE_TYPE_B)
 647             ff_h263_update_motion_val(s);
 648         ff_MPV_decode_mb(s, s->block);
 649         if(s->loop_filter)
 650             ff_h263_loop_filter(s);
 651
 652         if (++s->mb_x == s->mb_width) {
 653             s->mb_x = 0;
 654             s->mb_y++;
 655             ff_init_block_index(s);
 656         }
 657         if(s->mb_x == s->resync_mb_x)
 658             s->first_slice_line=0;
 659         if(ret == SLICE_END) break;
 660     }
 661
 662     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, 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) return avctx->slice_offset[n];
 670     else                   return AV_RL32(buf + n*8);
 671 }
 672
 673 static int rv10_decode_frame(AVCodecContext *avctx,
 674                              void *data, int *got_frame,
 675                              AVPacket *avpkt)
 676 {
 677     const uint8_t *buf = avpkt->data;
 678     int buf_size = avpkt->size;
 679     MpegEncContext *s = avctx->priv_data;
 680     int i;
 681     AVFrame *pict = data;
 682     int slice_count;
 683     const uint8_t *slices_hdr = NULL;
 684
 685     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 686     s->flags  = avctx->flags;
 687     s->flags2 = avctx->flags2;
 688
 689     /* no supplementary picture */
 690     if (buf_size == 0) {
 691         return 0;
 692     }
 693
 694     if(!avctx->slice_count){
 695         slice_count = (*buf++) + 1;
 696         buf_size--;
 697
 698         if (!slice_count || buf_size <= 8 * slice_count) {
 699             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", 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(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
 731             i++;
 732     }
 733
 734     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
 735         ff_er_frame_end(&s->er);
 736         ff_MPV_frame_end(s);
 737
 738         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
 739             *pict = s->current_picture_ptr->f;
 740         } else if (s->last_picture_ptr != NULL) {
 741             *pict = s->last_picture_ptr->f;
 742         }
 743
 744         if(s->last_picture_ptr || s->low_delay){
 745             *got_frame = 1;
 746             ff_print_debug_info(s, pict);
 747         }
 748         s->current_picture_ptr= NULL; // so we can detect if frame_end was not called (find some nicer solution...)
 749     }
 750
 751     return avpkt->size;
 752 }
 753
 754 AVCodec ff_rv10_decoder = {
 755     .name           = "rv10",
 756     .type           = AVMEDIA_TYPE_VIDEO,
 757     .id             = AV_CODEC_ID_RV10,
 758     .priv_data_size = sizeof(RVDecContext),
 759     .init           = rv10_decode_init,
 760     .close          = rv10_decode_end,
 761     .decode         = rv10_decode_frame,
 762     .capabilities   = CODEC_CAP_DR1,
 763     .max_lowres     = 3,
 764     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 765     .pix_fmts       = ff_pixfmt_list_420,
 766 };
 767
 768 AVCodec ff_rv20_decoder = {
 769     .name           = "rv20",
 770     .type           = AVMEDIA_TYPE_VIDEO,
 771     .id             = AV_CODEC_ID_RV20,
 772     .priv_data_size = sizeof(RVDecContext),
 773     .init           = rv10_decode_init,
 774     .close          = rv10_decode_end,
 775     .decode         = rv10_decode_frame,
 776     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 777     .flush          = ff_mpeg_flush,
 778     .max_lowres     = 3,
 779     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 780     .pix_fmts       = ff_pixfmt_list_420,
 781 };