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 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 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_bits(&s->gb, 1) == 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                 get_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                 get_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 #ifdef CONFIG_ENCODERS
 233
 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 == 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 == 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 macro blocks 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_bits(&s->pb, 8, picture_number&0xFF); //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 == 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 == 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 #if 0 /* unused, remove? */
 293 static int get_num(GetBitContext *gb)
 294 {
 295     int n, n1;
 296
 297     n = get_bits(gb, 16);
 298     if (n >= 0x4000) {
 299         return n - 0x4000;
 300     } else {
 301         n1 = get_bits(gb, 16);
 302         return (n << 16) | n1;
 303     }
 304 }
 305 #endif
 306
 307 #endif //CONFIG_ENCODERS
 308
 309 /* read RV 1.0 compatible frame header */
 310 static int rv10_decode_picture_header(MpegEncContext *s)
 311 {
 312     int mb_count, pb_frame, marker, unk, mb_xy;
 313
 314 //printf("ff:%d\n", full_frame);
 315     marker = get_bits(&s->gb, 1);
 316
 317     if (get_bits(&s->gb, 1))
 318         s->pict_type = P_TYPE;
 319     else
 320         s->pict_type = I_TYPE;
 321 //printf("h:%X ver:%d\n",h,s->rv10_version);
 322     if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
 323     pb_frame = get_bits(&s->gb, 1);
 324
 325 #ifdef DEBUG
 326     av_log(s->avctx, AV_LOG_DEBUG, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
 327 #endif
 328
 329     if (pb_frame){
 330         av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
 331         return -1;
 332     }
 333
 334     s->qscale = get_bits(&s->gb, 5);
 335     if(s->qscale==0){
 336         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 337         return -1;
 338     }
 339
 340     if (s->pict_type == I_TYPE) {
 341         if (s->rv10_version == 3) {
 342             /* specific MPEG like DC coding not used */
 343             s->last_dc[0] = get_bits(&s->gb, 8);
 344             s->last_dc[1] = get_bits(&s->gb, 8);
 345             s->last_dc[2] = get_bits(&s->gb, 8);
 346 #ifdef DEBUG
 347             av_log(s->avctx, AV_LOG_DEBUG, "DC:%d %d %d\n",
 348                    s->last_dc[0],
 349                    s->last_dc[1],
 350                    s->last_dc[2]);
 351 #endif
 352         }
 353     }
 354     /* if multiple packets per frame are sent, the position at which
 355        to display the macro blocks is coded here */
 356
 357     mb_xy= s->mb_x + s->mb_y*s->mb_width;
 358     if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
 359         s->mb_x = get_bits(&s->gb, 6); /* mb_x */
 360         s->mb_y = get_bits(&s->gb, 6); /* mb_y */
 361         mb_count = get_bits(&s->gb, 12);
 362     } else {
 363         s->mb_x = 0;
 364         s->mb_y = 0;
 365         mb_count = s->mb_width * s->mb_height;
 366     }
 367     unk= get_bits(&s->gb, 3);   /* ignored */
 368 //printf("%d\n", unk);
 369     s->f_code = 1;
 370     s->unrestricted_mv = 1;
 371
 372     return mb_count;
 373 }
 374
 375 static int rv20_decode_picture_header(MpegEncContext *s)
 376 {
 377     int seq, mb_pos, i;
 378
 379 #if 0
 380     GetBitContext gb= s->gb;
 381     for(i=0; i<64; i++){
 382         av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
 383         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
 384     }
 385     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 386 #endif
 387 #if 0
 388     av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
 389     for(i=0; i<s->avctx->extradata_size; i++){
 390         av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
 391         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
 392     }
 393     av_log(s->avctx, AV_LOG_DEBUG, "\n");
 394 #endif
 395
 396     if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
 397         if (get_bits(&s->gb, 3)){
 398             av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
 399             return -1;
 400         }
 401     }
 402
 403     i= get_bits(&s->gb, 2);
 404     switch(i){
 405     case 0: s->pict_type= I_TYPE; break;
 406     case 1: s->pict_type= I_TYPE; break; //hmm ...
 407     case 2: s->pict_type= P_TYPE; break;
 408     case 3: s->pict_type= B_TYPE; break;
 409     default:
 410         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
 411         return -1;
 412     }
 413
 414     if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
 415         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
 416         return -1;
 417     }
 418
 419     if (get_bits(&s->gb, 1)){
 420         av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
 421         return -1;
 422     }
 423
 424     s->qscale = get_bits(&s->gb, 5);
 425     if(s->qscale==0){
 426         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 427         return -1;
 428     }
 429     if(s->avctx->sub_id == 0x30203002){
 430         if (get_bits(&s->gb, 1)){
 431             av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
 432             return -1;
 433         }
 434     }
 435
 436     if(s->avctx->has_b_frames){
 437         int f, new_w, new_h;
 438         int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
 439
 440         if (get_bits(&s->gb, 1)){
 441             av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
 442 //            return -1;
 443         }
 444         seq= get_bits(&s->gb, 13)<<2;
 445
 446         f= get_bits(&s->gb, av_log2(v)+1);
 447
 448         if(f){
 449             new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
 450             new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
 451         }else{
 452             new_w= s->width; //FIXME wrong we of course must save the original in the context
 453             new_h= s->height;
 454         }
 455         if(new_w != s->width || new_h != s->height){
 456             av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
 457             MPV_common_end(s);
 458             s->width  = s->avctx->width = new_w;
 459             s->height = s->avctx->height= new_h;
 460             if (MPV_common_init(s) < 0)
 461                 return -1;
 462         }
 463
 464         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 465             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
 466         }
 467     }else{
 468         seq= get_bits(&s->gb, 8)*128;
 469     }
 470
 471 //     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
 472     mb_pos= ff_h263_decode_mba(s);
 473 /*    }else{
 474         mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
 475         s->mb_x= mb_pos % s->mb_width;
 476         s->mb_y= mb_pos / s->mb_width;
 477     }*/
 478 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
 479     seq |= s->time &~0x7FFF;
 480     if(seq - s->time >  0x4000) seq -= 0x8000;
 481     if(seq - s->time < -0x4000) seq += 0x8000;
 482     if(seq != s->time){
 483         if(s->pict_type!=B_TYPE){
 484             s->time= seq;
 485             s->pp_time= s->time - s->last_non_b_time;
 486             s->last_non_b_time= s->time;
 487         }else{
 488             s->time= seq;
 489             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
 490             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
 491                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
 492                 return FRAME_SKIPPED;
 493             }
 494             ff_mpeg4_init_direct_mv(s);
 495         }
 496     }
 497 //    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
 498 /*for(i=0; i<32; i++){
 499     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
 500 }
 501 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
 502     s->no_rounding= get_bits1(&s->gb);
 503
 504     s->f_code = 1;
 505     s->unrestricted_mv = 1;
 506     s->h263_aic= s->pict_type == I_TYPE;
 507 //    s->alt_inter_vlc=1;
 508 //    s->obmc=1;
 509 //    s->umvplus=1;
 510     s->modified_quant=1;
 511     s->loop_filter=1;
 512
 513     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 514             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
 515                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
 516     }
 517
 518     assert(s->pict_type != B_TYPE || !s->low_delay);
 519
 520     return s->mb_width*s->mb_height - mb_pos;
 521 }
 522
 523 static int rv10_decode_init(AVCodecContext *avctx)
 524 {
 525     MpegEncContext *s = avctx->priv_data;
 526     static int done=0;
 527
 528     MPV_decode_defaults(s);
 529
 530     s->avctx= avctx;
 531     s->out_format = FMT_H263;
 532     s->codec_id= avctx->codec_id;
 533
 534     s->width = avctx->width;
 535     s->height = avctx->height;
 536
 537     s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
 538     avctx->sub_id= BE_32((uint8_t*)avctx->extradata + 4);
 539
 540     switch(avctx->sub_id){
 541     case 0x10000000:
 542         s->rv10_version= 0;
 543         s->low_delay=1;
 544         break;
 545     case 0x10002000:
 546         s->rv10_version= 3;
 547         s->low_delay=1;
 548         s->obmc=1;
 549         break;
 550     case 0x10003000:
 551         s->rv10_version= 3;
 552         s->low_delay=1;
 553         break;
 554     case 0x10003001:
 555         s->rv10_version= 3;
 556         s->low_delay=1;
 557         break;
 558     case 0x20001000: /* real rv20 decoder fail on this id */
 559     /*case 0x20100001:
 560     case 0x20101001:
 561     case 0x20103001:*/
 562     case 0x20100000 ... 0x2019ffff:
 563         s->low_delay=1;
 564         break;
 565     /*case 0x20200002:
 566     case 0x20201002:
 567     case 0x20203002:*/
 568     case 0x20200002 ... 0x202fffff:
 569     case 0x30202002:
 570     case 0x30203002:
 571         s->low_delay=0;
 572         s->avctx->has_b_frames=1;
 573         break;
 574     default:
 575         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
 576     }
 577
 578     if(avctx->debug & FF_DEBUG_PICT_INFO){
 579         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
 580     }
 581
 582     avctx->pix_fmt = PIX_FMT_YUV420P;
 583
 584     if (MPV_common_init(s) < 0)
 585         return -1;
 586
 587     h263_decode_init_vlc(s);
 588
 589     /* init rv vlc */
 590     if (!done) {
 591         init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
 592                  rv_lum_bits, 1, 1,
 593                  rv_lum_code, 2, 2, 1);
 594         init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
 595                  rv_chrom_bits, 1, 1,
 596                  rv_chrom_code, 2, 2, 1);
 597         done = 1;
 598     }
 599
 600     return 0;
 601 }
 602
 603 static int rv10_decode_end(AVCodecContext *avctx)
 604 {
 605     MpegEncContext *s = avctx->priv_data;
 606
 607     MPV_common_end(s);
 608     return 0;
 609 }
 610
 611 static int rv10_decode_packet(AVCodecContext *avctx,
 612                              uint8_t *buf, int buf_size)
 613 {
 614     MpegEncContext *s = avctx->priv_data;
 615     int mb_count, mb_pos, left, start_mb_x;
 616
 617     init_get_bits(&s->gb, buf, buf_size*8);
 618     if(s->codec_id ==CODEC_ID_RV10)
 619         mb_count = rv10_decode_picture_header(s);
 620     else
 621         mb_count = rv20_decode_picture_header(s);
 622     if (mb_count < 0) {
 623         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 624         return -1;
 625     }
 626
 627     if (s->mb_x >= s->mb_width ||
 628         s->mb_y >= s->mb_height) {
 629         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 630         return -1;
 631     }
 632     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 633     left = s->mb_width * s->mb_height - mb_pos;
 634     if (mb_count > left) {
 635         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 636         return -1;
 637     }
 638 //if(s->pict_type == P_TYPE) return 0;
 639
 640     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
 641         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
 642             ff_er_frame_end(s);
 643             MPV_frame_end(s);
 644             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
 645         }
 646         if(MPV_frame_start(s, avctx) < 0)
 647             return -1;
 648         ff_er_frame_start(s);
 649     }
 650
 651 #ifdef DEBUG
 652     av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
 653 #endif
 654
 655     /* default quantization values */
 656     if(s->codec_id== CODEC_ID_RV10){
 657         if(s->mb_y==0) s->first_slice_line=1;
 658     }else{
 659         s->first_slice_line=1;
 660         s->resync_mb_x= s->mb_x;
 661     }
 662     start_mb_x= s->mb_x;
 663     s->resync_mb_y= s->mb_y;
 664     if(s->h263_aic){
 665         s->y_dc_scale_table=
 666         s->c_dc_scale_table= ff_aic_dc_scale_table;
 667     }else{
 668         s->y_dc_scale_table=
 669         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 670     }
 671
 672     if(s->modified_quant)
 673         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
 674
 675     ff_set_qscale(s, s->qscale);
 676
 677     s->rv10_first_dc_coded[0] = 0;
 678     s->rv10_first_dc_coded[1] = 0;
 679     s->rv10_first_dc_coded[2] = 0;
 680 //printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
 681     s->block_wrap[0]=
 682     s->block_wrap[1]=
 683     s->block_wrap[2]=
 684     s->block_wrap[3]= s->b8_stride;
 685     s->block_wrap[4]=
 686     s->block_wrap[5]= s->mb_stride;
 687     ff_init_block_index(s);
 688     /* decode each macroblock */
 689
 690     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
 691         int ret;
 692         ff_update_block_index(s);
 693 #ifdef DEBUG
 694         av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 695 #endif
 696
 697         s->mv_dir = MV_DIR_FORWARD;
 698         s->mv_type = MV_TYPE_16X16;
 699         ret=ff_h263_decode_mb(s, s->block);
 700
 701         if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
 702             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 703             return -1;
 704         }
 705         if(s->pict_type != B_TYPE)
 706             ff_h263_update_motion_val(s);
 707         MPV_decode_mb(s, s->block);
 708         if(s->loop_filter)
 709             ff_h263_loop_filter(s);
 710
 711         if (++s->mb_x == s->mb_width) {
 712             s->mb_x = 0;
 713             s->mb_y++;
 714             ff_init_block_index(s);
 715         }
 716         if(s->mb_x == s->resync_mb_x)
 717             s->first_slice_line=0;
 718         if(ret == SLICE_END) break;
 719     }
 720
 721     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);
 722
 723     return buf_size;
 724 }
 725
 726 static int rv10_decode_frame(AVCodecContext *avctx,
 727                              void *data, int *data_size,
 728                              uint8_t *buf, int buf_size)
 729 {
 730     MpegEncContext *s = avctx->priv_data;
 731     int i;
 732     AVFrame *pict = data;
 733
 734 #ifdef DEBUG
 735     av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 736 #endif
 737
 738     /* no supplementary picture */
 739     if (buf_size == 0) {
 740         return 0;
 741     }
 742
 743     if(avctx->slice_count){
 744         for(i=0; i<avctx->slice_count; i++){
 745             int offset= avctx->slice_offset[i];
 746             int size;
 747
 748             if(i+1 == avctx->slice_count)
 749                 size= buf_size - offset;
 750             else
 751                 size= avctx->slice_offset[i+1] - offset;
 752
 753             rv10_decode_packet(avctx, buf+offset, size);
 754         }
 755     }else{
 756         rv10_decode_packet(avctx, buf, buf_size);
 757     }
 758
 759     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
 760         ff_er_frame_end(s);
 761         MPV_frame_end(s);
 762
 763         if (s->pict_type == B_TYPE || s->low_delay) {
 764             *pict= *(AVFrame*)s->current_picture_ptr;
 765         } else if (s->last_picture_ptr != NULL) {
 766             *pict= *(AVFrame*)s->last_picture_ptr;
 767         }
 768
 769         if(s->last_picture_ptr || s->low_delay){
 770             *data_size = sizeof(AVFrame);
 771             ff_print_debug_info(s, pict);
 772         }
 773         s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
 774     }
 775
 776     return buf_size;
 777 }
 778
 779 AVCodec rv10_decoder = {
 780     "rv10",
 781     CODEC_TYPE_VIDEO,
 782     CODEC_ID_RV10,
 783     sizeof(MpegEncContext),
 784     rv10_decode_init,
 785     NULL,
 786     rv10_decode_end,
 787     rv10_decode_frame,
 788     CODEC_CAP_DR1
 789 };
 790
 791 AVCodec rv20_decoder = {
 792     "rv20",
 793     CODEC_TYPE_VIDEO,
 794     CODEC_ID_RV20,
 795     sizeof(MpegEncContext),
 796     rv10_decode_init,
 797     NULL,
 798     rv10_decode_end,
 799     rv10_decode_frame,
 800     CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 801     .flush= ff_mpeg_flush,
 802 };
 803