libavcodec/rv10.c

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