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 "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     i= get_bits(&s->gb, 2);
 307     switch(i){
 308     case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
 309     case 1: s->pict_type= AV_PICTURE_TYPE_I; break; //hmm ...
 310     case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
 311     case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
 312     default:
 313         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
 314         return -1;
 315     }
 316
 317     if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
 318         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
 319         return -1;
 320     }
 321
 322     if (get_bits1(&s->gb)){
 323         av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
 324         return -1;
 325     }
 326
 327     s->qscale = get_bits(&s->gb, 5);
 328     if(s->qscale==0){
 329         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 330         return -1;
 331     }
 332
 333     if(RV_GET_MINOR_VER(rv->sub_id) >= 2)
 334         s->loop_filter = get_bits1(&s->gb);
 335
 336     if(RV_GET_MINOR_VER(rv->sub_id) <= 1)
 337         seq = get_bits(&s->gb, 8) << 7;
 338     else
 339         seq = get_bits(&s->gb, 13) << 2;
 340
 341     rpr_bits = s->avctx->extradata[1] & 7;
 342     if(rpr_bits){
 343         int f, new_w, new_h;
 344         rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
 345
 346         f = get_bits(&s->gb, rpr_bits);
 347
 348         if(f){
 349             new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
 350             new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
 351         }else{
 352             new_w= s->orig_width ;
 353             new_h= s->orig_height;
 354         }
 355         if(new_w != s->width || new_h != s->height){
 356             av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
 357             if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
 358                 return -1;
 359             ff_MPV_common_end(s);
 360             avcodec_set_dimensions(s->avctx, new_w, new_h);
 361             s->width  = new_w;
 362             s->height = new_h;
 363             if (ff_MPV_common_init(s) < 0)
 364                 return -1;
 365         }
 366
 367         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 368             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
 369         }
 370     } else if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
 371         return AVERROR_INVALIDDATA;
 372
 373     mb_pos = ff_h263_decode_mba(s);
 374
 375     seq |= s->time &~0x7FFF;
 376     if(seq - s->time >  0x4000) seq -= 0x8000;
 377     if(seq - s->time < -0x4000) seq += 0x8000;
 378     if(seq != s->time){
 379         if(s->pict_type!=AV_PICTURE_TYPE_B){
 380             s->time= seq;
 381             s->pp_time= s->time - s->last_non_b_time;
 382             s->last_non_b_time= s->time;
 383         }else{
 384             s->time= seq;
 385             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
 386             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
 387                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
 388                 return FRAME_SKIPPED;
 389             }
 390             ff_mpeg4_init_direct_mv(s);
 391         }
 392     }
 393
 394     s->no_rounding= get_bits1(&s->gb);
 395
 396     if(RV_GET_MINOR_VER(rv->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     s->loop_filter=1;
 407
 408     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 409             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
 410                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
 411     }
 412
 413     assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
 414
 415     return s->mb_width*s->mb_height - mb_pos;
 416 }
 417
 418 static av_cold int rv10_decode_init(AVCodecContext *avctx)
 419 {
 420     RVDecContext  *rv = avctx->priv_data;
 421     MpegEncContext *s = &rv->m;
 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     rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
 442
 443     major_ver = RV_GET_MAJOR_VER(rv->sub_id);
 444     minor_ver = RV_GET_MINOR_VER(rv->sub_id);
 445     micro_ver = RV_GET_MICRO_VER(rv->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", rv->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", rv->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
 467     }
 468
 469     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 470
 471     if (ff_MPV_common_init(s) < 0)
 472         return -1;
 473
 474     ff_h263_decode_init_vlc();
 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     RVDecContext  *rv = avctx->priv_data;
 502     MpegEncContext *s = &rv->m;
 503     int mb_count, mb_pos, left, start_mb_x, active_bits_size;
 504
 505     active_bits_size = buf_size * 8;
 506     init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
 507     if(s->codec_id ==AV_CODEC_ID_RV10)
 508         mb_count = rv10_decode_picture_header(s);
 509     else
 510         mb_count = rv20_decode_picture_header(rv);
 511     if (mb_count < 0) {
 512         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 513         return -1;
 514     }
 515
 516     if (s->mb_x >= s->mb_width ||
 517         s->mb_y >= s->mb_height) {
 518         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 519         return -1;
 520     }
 521     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 522     left = s->mb_width * s->mb_height - mb_pos;
 523     if (mb_count > left) {
 524         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 525         return -1;
 526     }
 527
 528     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
 529         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
 530             ff_er_frame_end(&s->er);
 531             ff_MPV_frame_end(s);
 532             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
 533         }
 534         if(ff_MPV_frame_start(s, avctx) < 0)
 535             return -1;
 536         ff_mpeg_er_frame_start(s);
 537     } else {
 538         if (s->current_picture_ptr->f.pict_type != s->pict_type) {
 539             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
 540             return -1;
 541         }
 542     }
 543
 544     av_dlog(avctx, "qscale=%d\n", s->qscale);
 545
 546     /* default quantization values */
 547     if(s->codec_id== AV_CODEC_ID_RV10){
 548         if(s->mb_y==0) s->first_slice_line=1;
 549     }else{
 550         s->first_slice_line=1;
 551         s->resync_mb_x= s->mb_x;
 552     }
 553     start_mb_x= s->mb_x;
 554     s->resync_mb_y= s->mb_y;
 555     if(s->h263_aic){
 556         s->y_dc_scale_table=
 557         s->c_dc_scale_table= ff_aic_dc_scale_table;
 558     }else{
 559         s->y_dc_scale_table=
 560         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 561     }
 562
 563     if(s->modified_quant)
 564         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
 565
 566     ff_set_qscale(s, s->qscale);
 567
 568     s->rv10_first_dc_coded[0] = 0;
 569     s->rv10_first_dc_coded[1] = 0;
 570     s->rv10_first_dc_coded[2] = 0;
 571     s->block_wrap[0]=
 572     s->block_wrap[1]=
 573     s->block_wrap[2]=
 574     s->block_wrap[3]= s->b8_stride;
 575     s->block_wrap[4]=
 576     s->block_wrap[5]= s->mb_stride;
 577     ff_init_block_index(s);
 578     /* decode each macroblock */
 579
 580     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
 581         int ret;
 582         ff_update_block_index(s);
 583         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 584
 585         s->mv_dir = MV_DIR_FORWARD;
 586         s->mv_type = MV_TYPE_16X16;
 587         ret=ff_h263_decode_mb(s, s->block);
 588
 589         // Repeat the slice end check from ff_h263_decode_mb with our active
 590         // bitstream size
 591         if (ret != SLICE_ERROR) {
 592             int v = show_bits(&s->gb, 16);
 593
 594             if (get_bits_count(&s->gb) + 16 > active_bits_size)
 595                 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
 596
 597             if (!v)
 598                 ret = SLICE_END;
 599         }
 600         if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
 601             8 * buf_size2 >= get_bits_count(&s->gb)) {
 602             active_bits_size = buf_size2 * 8;
 603             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
 604                    8 * buf_size, active_bits_size);
 605             ret= SLICE_OK;
 606         }
 607
 608         if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
 609             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 610             return -1;
 611         }
 612         if(s->pict_type != AV_PICTURE_TYPE_B)
 613             ff_h263_update_motion_val(s);
 614         ff_MPV_decode_mb(s, s->block);
 615         if(s->loop_filter)
 616             ff_h263_loop_filter(s);
 617
 618         if (++s->mb_x == s->mb_width) {
 619             s->mb_x = 0;
 620             s->mb_y++;
 621             ff_init_block_index(s);
 622         }
 623         if(s->mb_x == s->resync_mb_x)
 624             s->first_slice_line=0;
 625         if(ret == SLICE_END) break;
 626     }
 627
 628     ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
 629
 630     return active_bits_size;
 631 }
 632
 633 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
 634 {
 635     if(avctx->slice_count) return avctx->slice_offset[n];
 636     else                   return AV_RL32(buf + n*8);
 637 }
 638
 639 static int rv10_decode_frame(AVCodecContext *avctx,
 640                              void *data, int *got_frame,
 641                              AVPacket *avpkt)
 642 {
 643     const uint8_t *buf = avpkt->data;
 644     int buf_size = avpkt->size;
 645     MpegEncContext *s = avctx->priv_data;
 646     int i;
 647     AVFrame *pict = data;
 648     int slice_count;
 649     const uint8_t *slices_hdr = NULL;
 650
 651     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 652
 653     /* no supplementary picture */
 654     if (buf_size == 0) {
 655         return 0;
 656     }
 657
 658     if(!avctx->slice_count){
 659         slice_count = (*buf++) + 1;
 660         buf_size--;
 661
 662         if (!slice_count || buf_size <= 8 * slice_count) {
 663             av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
 664             return AVERROR_INVALIDDATA;
 665         }
 666
 667         slices_hdr = buf + 4;
 668         buf += 8 * slice_count;
 669         buf_size -= 8 * slice_count;
 670     }else
 671         slice_count = avctx->slice_count;
 672
 673     for(i=0; i<slice_count; i++){
 674         unsigned offset = get_slice_offset(avctx, slices_hdr, i);
 675         int size, size2;
 676
 677         if (offset >= buf_size)
 678             return AVERROR_INVALIDDATA;
 679
 680         if(i+1 == slice_count)
 681             size= buf_size - offset;
 682         else
 683             size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
 684
 685         if(i+2 >= slice_count)
 686             size2= buf_size - offset;
 687         else
 688             size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
 689
 690         if (size <= 0 || size2 <= 0 ||
 691             offset + FFMAX(size, size2) > buf_size)
 692             return AVERROR_INVALIDDATA;
 693
 694         if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
 695             i++;
 696     }
 697
 698     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
 699         ff_er_frame_end(&s->er);
 700         ff_MPV_frame_end(s);
 701
 702         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
 703             *pict = s->current_picture_ptr->f;
 704         } else if (s->last_picture_ptr != NULL) {
 705             *pict = s->last_picture_ptr->f;
 706         }
 707
 708         if(s->last_picture_ptr || s->low_delay){
 709             *got_frame = 1;
 710             ff_print_debug_info(s, pict);
 711         }
 712         s->current_picture_ptr= NULL; // so we can detect if frame_end was not called (find some nicer solution...)
 713     }
 714
 715     return avpkt->size;
 716 }
 717
 718 AVCodec ff_rv10_decoder = {
 719     .name           = "rv10",
 720     .type           = AVMEDIA_TYPE_VIDEO,
 721     .id             = AV_CODEC_ID_RV10,
 722     .priv_data_size = sizeof(RVDecContext),
 723     .init           = rv10_decode_init,
 724     .close          = rv10_decode_end,
 725     .decode         = rv10_decode_frame,
 726     .capabilities   = CODEC_CAP_DR1,
 727     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 728     .pix_fmts       = ff_pixfmt_list_420,
 729 };
 730
 731 AVCodec ff_rv20_decoder = {
 732     .name           = "rv20",
 733     .type           = AVMEDIA_TYPE_VIDEO,
 734     .id             = AV_CODEC_ID_RV20,
 735     .priv_data_size = sizeof(RVDecContext),
 736     .init           = rv10_decode_init,
 737     .close          = rv10_decode_end,
 738     .decode         = rv10_decode_frame,
 739     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 740     .flush          = ff_mpeg_flush,
 741     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 742     .pix_fmts       = ff_pixfmt_list_420,
 743 };