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