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