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

   1 /*
   2  * RV10 codec
   3  * Copyright (c) 2000,2001 Fabrice Bellard.
   4  * Copyright (c) 2002-2004 Michael Niedermayer
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 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 static int get_num(GetBitContext *gb)
 262 {
 263     int n, n1;
 264
 265     n = get_bits(gb, 16);
 266     if (n >= 0x4000) {
 267         return n - 0x4000;
 268     } else {
 269         n1 = get_bits(gb, 16);
 270         return (n << 16) | n1;
 271     }
 272 }
 273
 274 #endif //CONFIG_ENCODERS
 275
 276 /* read RV 1.0 compatible frame header */
 277 static int rv10_decode_picture_header(MpegEncContext *s)
 278 {
 279     int mb_count, pb_frame, marker, full_frame, unk;
 280
 281     full_frame= s->avctx->slice_count==1;
 282 //printf("ff:%d\n", full_frame);
 283     marker = get_bits(&s->gb, 1);
 284
 285     if (get_bits(&s->gb, 1))
 286         s->pict_type = P_TYPE;
 287     else
 288         s->pict_type = I_TYPE;
 289 //printf("h:%X ver:%d\n",h,s->rv10_version);
 290     if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
 291     pb_frame = get_bits(&s->gb, 1);
 292
 293 #ifdef DEBUG
 294     printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
 295 #endif
 296
 297     if (pb_frame){
 298         av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
 299         return -1;
 300     }
 301
 302     s->qscale = get_bits(&s->gb, 5);
 303     if(s->qscale==0){
 304         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 305         return -1;
 306     }
 307
 308     if (s->pict_type == I_TYPE) {
 309         if (s->rv10_version == 3) {
 310             /* specific MPEG like DC coding not used */
 311             s->last_dc[0] = get_bits(&s->gb, 8);
 312             s->last_dc[1] = get_bits(&s->gb, 8);
 313             s->last_dc[2] = get_bits(&s->gb, 8);
 314 #ifdef DEBUG
 315             printf("DC:%d %d %d\n",
 316                    s->last_dc[0],
 317                    s->last_dc[1],
 318                    s->last_dc[2]);
 319 #endif
 320         }
 321     }
 322     /* if multiple packets per frame are sent, the position at which
 323        to display the macro blocks is coded here */
 324     if ((!full_frame) || show_bits(&s->gb, 12)==0) {
 325         s->mb_x = get_bits(&s->gb, 6);  /* mb_x */
 326         s->mb_y = get_bits(&s->gb, 6);  /* mb_y */
 327         mb_count = get_bits(&s->gb, 12);
 328     } else {
 329         s->mb_x = 0;
 330         s->mb_y = 0;
 331         mb_count = s->mb_width * s->mb_height;
 332     }
 333     unk= get_bits(&s->gb, 3);   /* ignored */
 334 //printf("%d\n", unk);
 335     s->f_code = 1;
 336     s->unrestricted_mv = 1;
 337
 338     return mb_count;
 339 }
 340
 341 static int rv20_decode_picture_header(MpegEncContext *s)
 342 {
 343     int seq, mb_pos, i;
 344
 345     if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
 346         if (get_bits(&s->gb, 3)){
 347             av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
 348             return -1;
 349         }
 350     }
 351
 352     i= get_bits(&s->gb, 2);
 353     switch(i){
 354     case 0: s->pict_type= I_TYPE; break;
 355     case 1: s->pict_type= I_TYPE; break; //hmm ...
 356     case 2: s->pict_type= P_TYPE; break;
 357     case 3: s->pict_type= B_TYPE; break;
 358     default:
 359         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
 360         return -1;
 361     }
 362
 363     if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
 364         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
 365         return -1;
 366     }
 367
 368     if (get_bits(&s->gb, 1)){
 369         av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
 370         return -1;
 371     }
 372
 373     s->qscale = get_bits(&s->gb, 5);
 374     if(s->qscale==0){
 375         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 376         return -1;
 377     }
 378     if(s->avctx->sub_id == 0x30203002){
 379         if (get_bits(&s->gb, 1)){
 380             av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
 381             return -1;
 382         }
 383     }
 384
 385     if(s->avctx->has_b_frames){
 386         if (get_bits(&s->gb, 1)){
 387 //            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
 388 //            return -1;
 389         }
 390         seq= get_bits(&s->gb, 15);
 391         if (s->avctx->sub_id == 0x20201002 && get_bits(&s->gb, 1)){
 392             av_log(s->avctx, AV_LOG_ERROR, "unknown bit4 set\n");
 393 //            return -1;
 394         }
 395         mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
 396         s->mb_x= mb_pos % s->mb_width;
 397         s->mb_y= mb_pos / s->mb_width;
 398     }else{
 399         seq= get_bits(&s->gb, 8)*128;
 400         mb_pos= ff_h263_decode_mba(s);
 401     }
 402 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
 403     seq |= s->time &~0x7FFF;
 404     if(seq - s->time >  0x4000) seq -= 0x8000;
 405     if(seq - s->time < -0x4000) seq += 0x8000;
 406     if(seq != s->time){
 407         if(s->pict_type!=B_TYPE){
 408             s->time= seq;
 409             s->pp_time= s->time - s->last_non_b_time;
 410             s->last_non_b_time= s->time;
 411         }else{
 412             s->time= seq;
 413             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
 414             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
 415                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, seeking?, skiping current b frame\n");
 416                 return FRAME_SKIPED;
 417             }
 418         }
 419     }
 420 //    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
 421 /*for(i=0; i<32; i++){
 422     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
 423 }
 424 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
 425     s->no_rounding= get_bits1(&s->gb);
 426
 427     s->f_code = 1;
 428     s->unrestricted_mv = 1;
 429     s->h263_aic= s->pict_type == I_TYPE;
 430 //    s->alt_inter_vlc=1;
 431 //    s->obmc=1;
 432 //    s->umvplus=1;
 433     s->modified_quant=1;
 434     s->loop_filter=1;
 435
 436     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 437             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
 438                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
 439     }
 440
 441     assert(s->pict_type != B_TYPE || !s->low_delay);
 442
 443     return s->mb_width*s->mb_height - mb_pos;
 444 }
 445
 446 static int rv10_decode_init(AVCodecContext *avctx)
 447 {
 448     MpegEncContext *s = avctx->priv_data;
 449     static int done=0;
 450
 451     MPV_decode_defaults(s);
 452
 453     s->avctx= avctx;
 454     s->out_format = FMT_H263;
 455     s->codec_id= avctx->codec_id;
 456
 457     s->width = avctx->width;
 458     s->height = avctx->height;
 459
 460     switch(avctx->sub_id){
 461     case 0x10000000:
 462         s->rv10_version= 0;
 463         s->h263_long_vectors=0;
 464         s->low_delay=1;
 465         break;
 466     case 0x10002000:
 467         s->rv10_version= 3;
 468         s->h263_long_vectors=1;
 469         s->low_delay=1;
 470         s->obmc=1;
 471         break;
 472     case 0x10003000:
 473         s->rv10_version= 3;
 474         s->h263_long_vectors=1;
 475         s->low_delay=1;
 476         break;
 477     case 0x10003001:
 478         s->rv10_version= 3;
 479         s->h263_long_vectors=0;
 480         s->low_delay=1;
 481         break;
 482     case 0x20001000:
 483     case 0x20100001:
 484     case 0x20101001:
 485         s->low_delay=1;
 486         break;
 487     case 0x20200002:
 488     case 0x20201002:
 489     case 0x30202002:
 490     case 0x30203002:
 491         s->low_delay=0;
 492         s->avctx->has_b_frames=1;
 493         break;
 494     default:
 495         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
 496     }
 497 //printf("ver:%X\n", avctx->sub_id);
 498     if (MPV_common_init(s) < 0)
 499         return -1;
 500
 501     h263_decode_init_vlc(s);
 502
 503     /* init rv vlc */
 504     if (!done) {
 505         init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
 506                  rv_lum_bits, 1, 1,
 507                  rv_lum_code, 2, 2);
 508         init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
 509                  rv_chrom_bits, 1, 1,
 510                  rv_chrom_code, 2, 2);
 511         done = 1;
 512     }
 513
 514     avctx->pix_fmt = PIX_FMT_YUV420P;
 515
 516     return 0;
 517 }
 518
 519 static int rv10_decode_end(AVCodecContext *avctx)
 520 {
 521     MpegEncContext *s = avctx->priv_data;
 522
 523     MPV_common_end(s);
 524     return 0;
 525 }
 526
 527 static int rv10_decode_packet(AVCodecContext *avctx,
 528                              uint8_t *buf, int buf_size)
 529 {
 530     MpegEncContext *s = avctx->priv_data;
 531     int i, mb_count, mb_pos, left;
 532
 533     init_get_bits(&s->gb, buf, buf_size*8);
 534 #if 0
 535     for(i=0; i<buf_size*8 && i<200; i++)
 536         printf("%d", get_bits1(&s->gb));
 537     printf("\n");
 538     return 0;
 539 #endif
 540     if(s->codec_id ==CODEC_ID_RV10)
 541         mb_count = rv10_decode_picture_header(s);
 542     else
 543         mb_count = rv20_decode_picture_header(s);
 544     if (mb_count < 0) {
 545         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 546         return -1;
 547     }
 548
 549     if (s->mb_x >= s->mb_width ||
 550         s->mb_y >= s->mb_height) {
 551         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 552         return -1;
 553     }
 554     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 555     left = s->mb_width * s->mb_height - mb_pos;
 556     if (mb_count > left) {
 557         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 558         return -1;
 559     }
 560 //if(s->pict_type == P_TYPE) return 0;
 561
 562     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
 563         if(MPV_frame_start(s, avctx) < 0)
 564             return -1;
 565     }
 566
 567     if(s->pict_type == B_TYPE){ //FIXME remove after cleaning mottion_val indexing
 568         memset(s->current_picture.motion_val[0], 0, sizeof(int16_t)*2*(s->mb_width*2+2)*(s->mb_height*2+2));
 569     }
 570
 571 #ifdef DEBUG
 572     printf("qscale=%d\n", s->qscale);
 573 #endif
 574
 575     /* default quantization values */
 576     if(s->codec_id== CODEC_ID_RV10){
 577         if(s->mb_y==0) s->first_slice_line=1;
 578     }else{
 579         s->first_slice_line=1;
 580         s->resync_mb_x= s->mb_x;
 581         s->resync_mb_y= s->mb_y;
 582     }
 583     if(s->h263_aic){
 584         s->y_dc_scale_table=
 585         s->c_dc_scale_table= ff_aic_dc_scale_table;
 586     }else{
 587         s->y_dc_scale_table=
 588         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 589     }
 590
 591     if(s->modified_quant)
 592         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
 593
 594     ff_set_qscale(s, s->qscale);
 595
 596     s->rv10_first_dc_coded[0] = 0;
 597     s->rv10_first_dc_coded[1] = 0;
 598     s->rv10_first_dc_coded[2] = 0;
 599 //printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
 600     s->block_wrap[0]=
 601     s->block_wrap[1]=
 602     s->block_wrap[2]=
 603     s->block_wrap[3]= s->mb_width*2 + 2;
 604     s->block_wrap[4]=
 605     s->block_wrap[5]= s->mb_width + 2;
 606     ff_init_block_index(s);
 607     /* decode each macroblock */
 608
 609     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
 610         int ret;
 611         ff_update_block_index(s);
 612 #ifdef DEBUG
 613         printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 614 #endif
 615
 616         s->dsp.clear_blocks(s->block[0]);
 617         s->mv_dir = MV_DIR_FORWARD;
 618         s->mv_type = MV_TYPE_16X16;
 619         ret=ff_h263_decode_mb(s, s->block);
 620
 621         if (ret == SLICE_ERROR) {
 622             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 623             return -1;
 624         }
 625         if(s->pict_type != B_TYPE)
 626             ff_h263_update_motion_val(s);
 627         MPV_decode_mb(s, s->block);
 628         if(s->loop_filter)
 629             ff_h263_loop_filter(s);
 630
 631         if (++s->mb_x == s->mb_width) {
 632             s->mb_x = 0;
 633             s->mb_y++;
 634             ff_init_block_index(s);
 635         }
 636         if(s->mb_x == s->resync_mb_x)
 637             s->first_slice_line=0;
 638         if(ret == SLICE_END) break;
 639     }
 640
 641     return buf_size;
 642 }
 643
 644 static int rv10_decode_frame(AVCodecContext *avctx,
 645                              void *data, int *data_size,
 646                              uint8_t *buf, int buf_size)
 647 {
 648     MpegEncContext *s = avctx->priv_data;
 649     int i;
 650     AVFrame *pict = data;
 651
 652 #ifdef DEBUG
 653     printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
 654 #endif
 655
 656     /* no supplementary picture */
 657     if (buf_size == 0) {
 658         *data_size = 0;
 659         return 0;
 660     }
 661
 662     if(avctx->slice_count){
 663         for(i=0; i<avctx->slice_count; i++){
 664             int offset= avctx->slice_offset[i];
 665             int size;
 666
 667             if(i+1 == avctx->slice_count)
 668                 size= buf_size - offset;
 669             else
 670                 size= avctx->slice_offset[i+1] - offset;
 671
 672             if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
 673                 return -1;
 674         }
 675     }else{
 676         if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
 677             return -1;
 678     }
 679
 680     if(s->pict_type == B_TYPE){ //FIXME remove after cleaning mottion_val indexing
 681         memset(s->current_picture.motion_val[0], 0, sizeof(int16_t)*2*(s->mb_width*2+2)*(s->mb_height*2+2));
 682     }
 683
 684     if(s->mb_y>=s->mb_height){
 685         MPV_frame_end(s);
 686
 687         if(s->pict_type==B_TYPE || s->low_delay){
 688             *pict= *(AVFrame*)&s->current_picture;
 689             ff_print_debug_info(s, pict);
 690         } else {
 691             *pict= *(AVFrame*)&s->last_picture;
 692             ff_print_debug_info(s, pict);
 693         }
 694
 695         *data_size = sizeof(AVFrame);
 696     }else{
 697         *data_size = 0;
 698     }
 699
 700     return buf_size;
 701 }
 702
 703 AVCodec rv10_decoder = {
 704     "rv10",
 705     CODEC_TYPE_VIDEO,
 706     CODEC_ID_RV10,
 707     sizeof(MpegEncContext),
 708     rv10_decode_init,
 709     NULL,
 710     rv10_decode_end,
 711     rv10_decode_frame,
 712     CODEC_CAP_DR1
 713 };
 714
 715 AVCodec rv20_decoder = {
 716     "rv20",
 717     CODEC_TYPE_VIDEO,
 718     CODEC_ID_RV20,
 719     sizeof(MpegEncContext),
 720     rv10_decode_init,
 721     NULL,
 722     rv10_decode_end,
 723     rv10_decode_frame,
 724     CODEC_CAP_DR1
 725 };
 726