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                 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     avctx->pix_fmt = PIX_FMT_YUV420P;
 392
 393     return 0;
 394 }
 395
 396 static int rv10_decode_end(AVCodecContext *avctx)
 397 {
 398     MpegEncContext *s = avctx->priv_data;
 399
 400     MPV_common_end(s);
 401     return 0;
 402 }
 403
 404 static int rv10_decode_packet(AVCodecContext *avctx,
 405                              uint8_t *buf, int buf_size)
 406 {
 407     MpegEncContext *s = avctx->priv_data;
 408     int i, mb_count, mb_pos, left;
 409
 410     init_get_bits(&s->gb, buf, buf_size*8);
 411
 412     mb_count = rv10_decode_picture_header(s);
 413     if (mb_count < 0) {
 414         fprintf(stderr, "HEADER ERROR\n");
 415         return -1;
 416     }
 417
 418     if (s->mb_x >= s->mb_width ||
 419         s->mb_y >= s->mb_height) {
 420         fprintf(stderr, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 421         return -1;
 422     }
 423     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 424     left = s->mb_width * s->mb_height - mb_pos;
 425     if (mb_count > left) {
 426         fprintf(stderr, "COUNT ERROR\n");
 427         return -1;
 428     }
 429
 430     if (s->mb_x == 0 && s->mb_y == 0) {
 431         if(MPV_frame_start(s, avctx) < 0)
 432             return -1;
 433     }
 434
 435 #ifdef DEBUG
 436     printf("qscale=%d\n", s->qscale);
 437 #endif
 438
 439     /* default quantization values */
 440     s->y_dc_scale = 8;
 441     s->c_dc_scale = 8;
 442     s->rv10_first_dc_coded[0] = 0;
 443     s->rv10_first_dc_coded[1] = 0;
 444     s->rv10_first_dc_coded[2] = 0;
 445
 446     if(s->mb_y==0) s->first_slice_line=1;
 447
 448     s->block_wrap[0]=
 449     s->block_wrap[1]=
 450     s->block_wrap[2]=
 451     s->block_wrap[3]= s->mb_width*2 + 2;
 452     s->block_wrap[4]=
 453     s->block_wrap[5]= s->mb_width + 2;
 454     ff_init_block_index(s);
 455     /* decode each macroblock */
 456     for(i=0;i<mb_count;i++) {
 457         ff_update_block_index(s);
 458 #ifdef DEBUG
 459         printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 460 #endif
 461
 462         s->dsp.clear_blocks(s->block[0]);
 463         s->mv_dir = MV_DIR_FORWARD;
 464         s->mv_type = MV_TYPE_16X16;
 465         if (ff_h263_decode_mb(s, s->block) == SLICE_ERROR) {
 466             fprintf(stderr, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 467             return -1;
 468         }
 469         MPV_decode_mb(s, s->block);
 470         if (++s->mb_x == s->mb_width) {
 471             s->mb_x = 0;
 472             s->mb_y++;
 473             ff_init_block_index(s);
 474             s->first_slice_line=0;
 475         }
 476     }
 477
 478     return buf_size;
 479 }
 480
 481 static int rv10_decode_frame(AVCodecContext *avctx,
 482                              void *data, int *data_size,
 483                              uint8_t *buf, int buf_size)
 484 {
 485     MpegEncContext *s = avctx->priv_data;
 486     int i;
 487     AVFrame *pict = data;
 488
 489 #ifdef DEBUG
 490     printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
 491 #endif
 492
 493     /* no supplementary picture */
 494     if (buf_size == 0) {
 495         *data_size = 0;
 496         return 0;
 497     }
 498
 499     if(avctx->slice_count){
 500         for(i=0; i<avctx->slice_count; i++){
 501             int offset= avctx->slice_offset[i];
 502             int size;
 503
 504             if(i+1 == avctx->slice_count)
 505                 size= buf_size - offset;
 506             else
 507                 size= avctx->slice_offset[i+1] - offset;
 508
 509             if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
 510                 return -1;
 511         }
 512     }else{
 513         if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
 514             return -1;
 515     }
 516
 517     if(s->mb_y>=s->mb_height){
 518         MPV_frame_end(s);
 519
 520         *pict= *(AVFrame*)&s->current_picture;
 521
 522         *data_size = sizeof(AVFrame);
 523     }else{
 524         *data_size = 0;
 525     }
 526
 527     return buf_size;
 528 }
 529
 530 AVCodec rv10_decoder = {
 531     "rv10",
 532     CODEC_TYPE_VIDEO,
 533     CODEC_ID_RV10,
 534     sizeof(MpegEncContext),
 535     rv10_decode_init,
 536     NULL,
 537     rv10_decode_end,
 538     rv10_decode_frame,
 539     CODEC_CAP_DR1
 540 };