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