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                 fprintf(stderr, "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) printf("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         fprintf(stderr, "pb frame not supported\n");
 298         return -1;
 299     }
 300
 301     s->qscale = get_bits(&s->gb, 5);
 302     if(s->qscale==0){
 303         fprintf(stderr, "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 rv10_decode_init(AVCodecContext *avctx)
 341 {
 342     MpegEncContext *s = avctx->priv_data;
 343     static int done=0;
 344
 345     s->avctx= avctx;
 346     s->out_format = FMT_H263;
 347
 348     s->width = avctx->width;
 349     s->height = avctx->height;
 350
 351     s->h263_rv10 = 1;
 352     switch(avctx->sub_id){
 353     case 0x10000000:
 354         s->rv10_version= 0;
 355         s->h263_long_vectors=0;
 356         break;
 357     case 0x10003000:
 358         s->rv10_version= 3;
 359         s->h263_long_vectors=1;
 360         break;
 361     case 0x10003001:
 362         s->rv10_version= 3;
 363         s->h263_long_vectors=0;
 364         break;
 365     default:
 366         fprintf(stderr, "unknown header %X\n", avctx->sub_id);
 367     }
 368 //printf("ver:%X\n", avctx->sub_id);
 369     s->flags= avctx->flags;
 370
 371     if (MPV_common_init(s) < 0)
 372         return -1;
 373
 374     h263_decode_init_vlc(s);
 375
 376     s->y_dc_scale_table=
 377     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 378     s->progressive_sequence=1;
 379
 380     /* init rv vlc */
 381     if (!done) {
 382         init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
 383                  rv_lum_bits, 1, 1,
 384                  rv_lum_code, 2, 2);
 385         init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
 386                  rv_chrom_bits, 1, 1,
 387                  rv_chrom_code, 2, 2);
 388         done = 1;
 389     }
 390
 391     return 0;
 392 }
 393
 394 static int rv10_decode_end(AVCodecContext *avctx)
 395 {
 396     MpegEncContext *s = avctx->priv_data;
 397
 398     MPV_common_end(s);
 399     return 0;
 400 }
 401
 402 static int rv10_decode_packet(AVCodecContext *avctx,
 403                              uint8_t *buf, int buf_size)
 404 {
 405     MpegEncContext *s = avctx->priv_data;
 406     int i, mb_count, mb_pos, left;
 407
 408     init_get_bits(&s->gb, buf, buf_size*8);
 409
 410     mb_count = rv10_decode_picture_header(s);
 411     if (mb_count < 0) {
 412         fprintf(stderr, "HEADER ERROR\n");
 413         return -1;
 414     }
 415
 416     if (s->mb_x >= s->mb_width ||
 417         s->mb_y >= s->mb_height) {
 418         fprintf(stderr, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 419         return -1;
 420     }
 421     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 422     left = s->mb_width * s->mb_height - mb_pos;
 423     if (mb_count > left) {
 424         fprintf(stderr, "COUNT ERROR\n");
 425         return -1;
 426     }
 427
 428     if (s->mb_x == 0 && s->mb_y == 0) {
 429         if(MPV_frame_start(s, avctx) < 0)
 430             return -1;
 431     }
 432
 433 #ifdef DEBUG
 434     printf("qscale=%d\n", s->qscale);
 435 #endif
 436
 437     /* default quantization values */
 438     s->y_dc_scale = 8;
 439     s->c_dc_scale = 8;
 440     s->rv10_first_dc_coded[0] = 0;
 441     s->rv10_first_dc_coded[1] = 0;
 442     s->rv10_first_dc_coded[2] = 0;
 443
 444     if(s->mb_y==0) s->first_slice_line=1;
 445
 446     s->block_wrap[0]=
 447     s->block_wrap[1]=
 448     s->block_wrap[2]=
 449     s->block_wrap[3]= s->mb_width*2 + 2;
 450     s->block_wrap[4]=
 451     s->block_wrap[5]= s->mb_width + 2;
 452     ff_init_block_index(s);
 453     /* decode each macroblock */
 454     for(i=0;i<mb_count;i++) {
 455         ff_update_block_index(s);
 456 #ifdef DEBUG
 457         printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 458 #endif
 459
 460         s->dsp.clear_blocks(s->block[0]);
 461         s->mv_dir = MV_DIR_FORWARD;
 462         s->mv_type = MV_TYPE_16X16;
 463         if (ff_h263_decode_mb(s, s->block) == SLICE_ERROR) {
 464             fprintf(stderr, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 465             return -1;
 466         }
 467         MPV_decode_mb(s, s->block);
 468         if (++s->mb_x == s->mb_width) {
 469             s->mb_x = 0;
 470             s->mb_y++;
 471             ff_init_block_index(s);
 472             s->first_slice_line=0;
 473         }
 474     }
 475
 476     return buf_size;
 477 }
 478
 479 static int rv10_decode_frame(AVCodecContext *avctx,
 480                              void *data, int *data_size,
 481                              uint8_t *buf, int buf_size)
 482 {
 483     MpegEncContext *s = avctx->priv_data;
 484     int i;
 485     AVFrame *pict = data;
 486
 487 #ifdef DEBUG
 488     printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
 489 #endif
 490
 491     /* no supplementary picture */
 492     if (buf_size == 0) {
 493         *data_size = 0;
 494         return 0;
 495     }
 496
 497     if(avctx->slice_count){
 498         for(i=0; i<avctx->slice_count; i++){
 499             int offset= avctx->slice_offset[i];
 500             int size;
 501
 502             if(i+1 == avctx->slice_count)
 503                 size= buf_size - offset;
 504             else
 505                 size= avctx->slice_offset[i+1] - offset;
 506
 507             if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
 508                 return -1;
 509         }
 510     }else{
 511         if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
 512             return -1;
 513     }
 514
 515     if(s->mb_y>=s->mb_height){
 516         MPV_frame_end(s);
 517
 518         *pict= *(AVFrame*)&s->current_picture;
 519
 520         *data_size = sizeof(AVFrame);
 521     }else{
 522         *data_size = 0;
 523     }
 524
 525     return buf_size;
 526 }
 527
 528 AVCodec rv10_decoder = {
 529     "rv10",
 530     CODEC_TYPE_VIDEO,
 531     CODEC_ID_RV10,
 532     sizeof(MpegEncContext),
 533     rv10_decode_init,
 534     NULL,
 535     rv10_decode_end,
 536     rv10_decode_frame,
 537     CODEC_CAP_DR1
 538 };