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