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

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