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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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     printf("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             printf("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     for(i=0; i<s->avctx->extradata_size; i++){
 387         av_log(s->avctx, AV_LOG_DEBUG, "%2X ", ((uint8_t*)s->avctx->extradata)[i]);
 388         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
 389     }
 390     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 391 #endif
 392
 393     if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
 394         if (get_bits(&s->gb, 3)){
 395             av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
 396             return -1;
 397         }
 398     }
 399
 400     i= get_bits(&s->gb, 2);
 401     switch(i){
 402     case 0: s->pict_type= I_TYPE; break;
 403     case 1: s->pict_type= I_TYPE; break; //hmm ...
 404     case 2: s->pict_type= P_TYPE; break;
 405     case 3: s->pict_type= B_TYPE; break;
 406     default:
 407         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
 408         return -1;
 409     }
 410
 411     if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
 412         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
 413         return -1;
 414     }
 415
 416     if (get_bits(&s->gb, 1)){
 417         av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
 418         return -1;
 419     }
 420
 421     s->qscale = get_bits(&s->gb, 5);
 422     if(s->qscale==0){
 423         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 424         return -1;
 425     }
 426     if(s->avctx->sub_id == 0x30203002){
 427         if (get_bits(&s->gb, 1)){
 428             av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
 429             return -1;
 430         }
 431     }
 432
 433     if(s->avctx->has_b_frames){
 434         int f=9;
 435         int v= s->avctx->extradata_size >= 4 ? ((uint8_t*)s->avctx->extradata)[1] : 0;
 436
 437         if (get_bits(&s->gb, 1)){
 438             av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
 439 //            return -1;
 440         }
 441         seq= get_bits(&s->gb, 14)<<1;
 442
 443         if(v>1 || (s->avctx->sub_id < 0x20201002 && v>0)){
 444             f= get_bits(&s->gb, av_log2(v-1)+1);
 445         }
 446
 447         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 448             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
 449         }
 450
 451         mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
 452         s->mb_x= mb_pos % s->mb_width;
 453         s->mb_y= mb_pos / s->mb_width;
 454     }else{
 455         seq= get_bits(&s->gb, 8)*128;
 456         mb_pos= ff_h263_decode_mba(s);
 457     }
 458 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
 459     seq |= s->time &~0x7FFF;
 460     if(seq - s->time >  0x4000) seq -= 0x8000;
 461     if(seq - s->time < -0x4000) seq += 0x8000;
 462     if(seq != s->time){
 463         if(s->pict_type!=B_TYPE){
 464             s->time= seq;
 465             s->pp_time= s->time - s->last_non_b_time;
 466             s->last_non_b_time= s->time;
 467         }else{
 468             s->time= seq;
 469             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
 470             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
 471                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, seeking?, skiping current b frame\n");
 472                 return FRAME_SKIPED;
 473             }
 474         }
 475     }
 476 //    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
 477 /*for(i=0; i<32; i++){
 478     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
 479 }
 480 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
 481     s->no_rounding= get_bits1(&s->gb);
 482
 483     s->f_code = 1;
 484     s->unrestricted_mv = 1;
 485     s->h263_aic= s->pict_type == I_TYPE;
 486 //    s->alt_inter_vlc=1;
 487 //    s->obmc=1;
 488 //    s->umvplus=1;
 489     s->modified_quant=1;
 490     s->loop_filter=1;
 491
 492     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 493             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
 494                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
 495     }
 496
 497     assert(s->pict_type != B_TYPE || !s->low_delay);
 498
 499     return s->mb_width*s->mb_height - mb_pos;
 500 }
 501
 502 static int rv10_decode_init(AVCodecContext *avctx)
 503 {
 504     MpegEncContext *s = avctx->priv_data;
 505     static int done=0;
 506
 507     MPV_decode_defaults(s);
 508
 509     s->avctx= avctx;
 510     s->out_format = FMT_H263;
 511     s->codec_id= avctx->codec_id;
 512
 513     s->width = avctx->width;
 514     s->height = avctx->height;
 515
 516     switch(avctx->sub_id){
 517     case 0x10000000:
 518         s->rv10_version= 0;
 519         s->h263_long_vectors=0;
 520         s->low_delay=1;
 521         break;
 522     case 0x10002000:
 523         s->rv10_version= 3;
 524         s->h263_long_vectors=1;
 525         s->low_delay=1;
 526         s->obmc=1;
 527         break;
 528     case 0x10003000:
 529         s->rv10_version= 3;
 530         s->h263_long_vectors=1;
 531         s->low_delay=1;
 532         break;
 533     case 0x10003001:
 534         s->rv10_version= 3;
 535         s->h263_long_vectors=0;
 536         s->low_delay=1;
 537         break;
 538     case 0x20001000:
 539     case 0x20100001:
 540     case 0x20101001:
 541     case 0x20103001:
 542         s->low_delay=1;
 543         break;
 544     case 0x20200002:
 545     case 0x20201002:
 546     case 0x20203002:
 547     case 0x30202002:
 548     case 0x30203002:
 549         s->low_delay=0;
 550         s->avctx->has_b_frames=1;
 551         break;
 552     default:
 553         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
 554     }
 555
 556     if(avctx->debug & FF_DEBUG_PICT_INFO){
 557         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
 558     }
 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(&rv_dc_lum, DC_VLC_BITS, 256,
 568                  rv_lum_bits, 1, 1,
 569                  rv_lum_code, 2, 2, 1);
 570         init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
 571                  rv_chrom_bits, 1, 1,
 572                  rv_chrom_code, 2, 2, 1);
 573         done = 1;
 574     }
 575
 576     avctx->pix_fmt = PIX_FMT_YUV420P;
 577
 578     return 0;
 579 }
 580
 581 static int rv10_decode_end(AVCodecContext *avctx)
 582 {
 583     MpegEncContext *s = avctx->priv_data;
 584
 585     MPV_common_end(s);
 586     return 0;
 587 }
 588
 589 static int rv10_decode_packet(AVCodecContext *avctx,
 590                              uint8_t *buf, int buf_size)
 591 {
 592     MpegEncContext *s = avctx->priv_data;
 593     int mb_count, mb_pos, left;
 594
 595     init_get_bits(&s->gb, buf, buf_size*8);
 596     if(s->codec_id ==CODEC_ID_RV10)
 597         mb_count = rv10_decode_picture_header(s);
 598     else
 599         mb_count = rv20_decode_picture_header(s);
 600     if (mb_count < 0) {
 601         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 602         return -1;
 603     }
 604
 605     if (s->mb_x >= s->mb_width ||
 606         s->mb_y >= s->mb_height) {
 607         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 608         return -1;
 609     }
 610     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 611     left = s->mb_width * s->mb_height - mb_pos;
 612     if (mb_count > left) {
 613         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 614         return -1;
 615     }
 616 //if(s->pict_type == P_TYPE) return 0;
 617
 618     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
 619         if(MPV_frame_start(s, avctx) < 0)
 620             return -1;
 621     }
 622
 623 #ifdef DEBUG
 624     printf("qscale=%d\n", s->qscale);
 625 #endif
 626
 627     /* default quantization values */
 628     if(s->codec_id== CODEC_ID_RV10){
 629         if(s->mb_y==0) s->first_slice_line=1;
 630     }else{
 631         s->first_slice_line=1;
 632         s->resync_mb_x= s->mb_x;
 633         s->resync_mb_y= s->mb_y;
 634     }
 635     if(s->h263_aic){
 636         s->y_dc_scale_table=
 637         s->c_dc_scale_table= ff_aic_dc_scale_table;
 638     }else{
 639         s->y_dc_scale_table=
 640         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 641     }
 642
 643     if(s->modified_quant)
 644         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
 645
 646     ff_set_qscale(s, s->qscale);
 647
 648     s->rv10_first_dc_coded[0] = 0;
 649     s->rv10_first_dc_coded[1] = 0;
 650     s->rv10_first_dc_coded[2] = 0;
 651 //printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
 652     s->block_wrap[0]=
 653     s->block_wrap[1]=
 654     s->block_wrap[2]=
 655     s->block_wrap[3]= s->b8_stride;
 656     s->block_wrap[4]=
 657     s->block_wrap[5]= s->mb_stride;
 658     ff_init_block_index(s);
 659     /* decode each macroblock */
 660
 661     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
 662         int ret;
 663         ff_update_block_index(s);
 664 #ifdef DEBUG
 665         printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 666 #endif
 667
 668         s->dsp.clear_blocks(s->block[0]);
 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) {
 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 != 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     return buf_size;
 694 }
 695
 696 static int rv10_decode_frame(AVCodecContext *avctx,
 697                              void *data, int *data_size,
 698                              uint8_t *buf, int buf_size)
 699 {
 700     MpegEncContext *s = avctx->priv_data;
 701     int i;
 702     AVFrame *pict = data;
 703
 704 #ifdef DEBUG
 705     printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
 706 #endif
 707
 708     /* no supplementary picture */
 709     if (buf_size == 0) {
 710         return 0;
 711     }
 712
 713     if(avctx->slice_count){
 714         for(i=0; i<avctx->slice_count; i++){
 715             int offset= avctx->slice_offset[i];
 716             int size;
 717
 718             if(i+1 == avctx->slice_count)
 719                 size= buf_size - offset;
 720             else
 721                 size= avctx->slice_offset[i+1] - offset;
 722
 723             if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
 724                 return -1;
 725         }
 726     }else{
 727         if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
 728             return -1;
 729     }
 730
 731     if(s->mb_y>=s->mb_height){
 732         MPV_frame_end(s);
 733
 734         if(s->pict_type==B_TYPE || s->low_delay){
 735             *pict= *(AVFrame*)&s->current_picture;
 736             ff_print_debug_info(s, pict);
 737         } else {
 738             *pict= *(AVFrame*)&s->last_picture;
 739             ff_print_debug_info(s, pict);
 740         }
 741         if(s->last_picture_ptr || s->low_delay)
 742             *data_size = sizeof(AVFrame);
 743     }
 744
 745     return buf_size;
 746 }
 747
 748 AVCodec rv10_decoder = {
 749     "rv10",
 750     CODEC_TYPE_VIDEO,
 751     CODEC_ID_RV10,
 752     sizeof(MpegEncContext),
 753     rv10_decode_init,
 754     NULL,
 755     rv10_decode_end,
 756     rv10_decode_frame,
 757     CODEC_CAP_DR1
 758 };
 759
 760 AVCodec rv20_decoder = {
 761     "rv20",
 762     CODEC_TYPE_VIDEO,
 763     CODEC_ID_RV20,
 764     sizeof(MpegEncContext),
 765     rv10_decode_init,
 766     NULL,
 767     rv10_decode_end,
 768     rv10_decode_frame,
 769     CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 770     .flush= ff_mpeg_flush,
 771 };
 772