git.sesse.net Git - ffmpeg/blob - libavcodec/rv10.c

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