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 #include "avcodec.h"
  20 #include "dsputil.h"
  21 #include "mpegvideo.h"
  22
  23 //#define DEBUG
  24
  25 #define DC_VLC_BITS 14 //FIXME find a better solution
  26
  27 static const uint16_t rv_lum_code[256] =
  28 {
  29  0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
  30  0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
  31  0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
  32  0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
  33  0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
  34  0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
  35  0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
  36  0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
  37  0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
  38  0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
  39  0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
  40  0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
  41  0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
  42  0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
  43  0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
  44  0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
  45  0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
  46  0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
  47  0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
  48  0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
  49  0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
  50  0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
  51  0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
  52  0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
  53  0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
  54  0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
  55  0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
  56  0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
  57  0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
  58  0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
  59  0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
  60  0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
  61 };
  62
  63 static const uint8_t rv_lum_bits[256] =
  64 {
  65  14, 12, 12, 12, 12, 12, 12, 12,
  66  12, 12, 12, 12, 12, 12, 12, 12,
  67  12, 12, 12, 12, 12, 12, 12, 12,
  68  12, 12, 12, 12, 12, 12, 12, 12,
  69  12, 12, 12, 12, 12, 12, 12, 12,
  70  12, 12, 12, 12, 12, 12, 12, 12,
  71  12, 12, 12, 12, 12, 12, 12, 12,
  72  12, 12, 12, 12, 12, 12, 12, 12,
  73  12, 10, 10, 10, 10, 10, 10, 10,
  74  10, 10, 10, 10, 10, 10, 10, 10,
  75  10, 10, 10, 10, 10, 10, 10, 10,
  76  10, 10, 10, 10, 10, 10, 10, 10,
  77  10,  8,  8,  8,  8,  8,  8,  8,
  78   8,  8,  8,  8,  8,  8,  8,  8,
  79   8,  7,  7,  7,  7,  7,  7,  7,
  80   7,  6,  6,  6,  6,  5,  5,  4,
  81   2,  4,  5,  5,  6,  6,  6,  6,
  82   7,  7,  7,  7,  7,  7,  7,  7,
  83   8,  8,  8,  8,  8,  8,  8,  8,
  84   8,  8,  8,  8,  8,  8,  8,  8,
  85  10, 10, 10, 10, 10, 10, 10, 10,
  86  10, 10, 10, 10, 10, 10, 10, 10,
  87  10, 10, 10, 10, 10, 10, 10, 10,
  88  10, 10, 10, 10, 10, 10, 10, 10,
  89  12, 12, 12, 12, 12, 12, 12, 12,
  90  12, 12, 12, 12, 12, 12, 12, 12,
  91  12, 12, 12, 12, 12, 12, 12, 12,
  92  12, 12, 12, 12, 12, 12, 12, 12,
  93  12, 12, 12, 12, 12, 12, 12, 12,
  94  12, 12, 12, 12, 12, 12, 12, 12,
  95  12, 12, 12, 12, 12, 12, 12, 12,
  96  12, 12, 12, 12, 12, 12, 12, 12,
  97 };
  98
  99 static const uint16_t rv_chrom_code[256] =
 100 {
 101  0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
 102  0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
 103  0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
 104  0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
 105  0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
 106  0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
 107  0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
 108  0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
 109  0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
 110  0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
 111  0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
 112  0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
 113  0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
 114  0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
 115  0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
 116  0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
 117  0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
 118  0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
 119  0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
 120  0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
 121  0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
 122  0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
 123  0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
 124  0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
 125  0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
 126  0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
 127  0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
 128  0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
 129  0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
 130  0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
 131  0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
 132  0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
 133 };
 134
 135 static const uint8_t rv_chrom_bits[256] =
 136 {
 137  16, 14, 14, 14, 14, 14, 14, 14,
 138  14, 14, 14, 14, 14, 14, 14, 14,
 139  14, 14, 14, 14, 14, 14, 14, 14,
 140  14, 14, 14, 14, 14, 14, 14, 14,
 141  14, 14, 14, 14, 14, 14, 14, 14,
 142  14, 14, 14, 14, 14, 14, 14, 14,
 143  14, 14, 14, 14, 14, 14, 14, 14,
 144  14, 14, 14, 14, 14, 14, 14, 14,
 145  14, 12, 12, 12, 12, 12, 12, 12,
 146  12, 12, 12, 12, 12, 12, 12, 12,
 147  12, 12, 12, 12, 12, 12, 12, 12,
 148  12, 12, 12, 12, 12, 12, 12, 12,
 149  12, 10, 10, 10, 10, 10, 10, 10,
 150  10, 10, 10, 10, 10, 10, 10, 10,
 151  10,  8,  8,  8,  8,  8,  8,  8,
 152   8,  6,  6,  6,  6,  4,  4,  3,
 153   2,  3,  4,  4,  6,  6,  6,  6,
 154   8,  8,  8,  8,  8,  8,  8,  8,
 155  10, 10, 10, 10, 10, 10, 10, 10,
 156  10, 10, 10, 10, 10, 10, 10, 10,
 157  12, 12, 12, 12, 12, 12, 12, 12,
 158  12, 12, 12, 12, 12, 12, 12, 12,
 159  12, 12, 12, 12, 12, 12, 12, 12,
 160  12, 12, 12, 12, 12, 12, 12, 12,
 161  14, 14, 14, 14, 14, 14, 14, 14,
 162  14, 14, 14, 14, 14, 14, 14, 14,
 163  14, 14, 14, 14, 14, 14, 14, 14,
 164  14, 14, 14, 14, 14, 14, 14, 14,
 165  14, 14, 14, 14, 14, 14, 14, 14,
 166  14, 14, 14, 14, 14, 14, 14, 14,
 167  14, 14, 14, 14, 14, 14, 14, 14,
 168  14, 14, 14, 14, 14, 14, 14, 14,
 169 };
 170
 171 static VLC rv_dc_lum, rv_dc_chrom;
 172
 173 int rv_decode_dc(MpegEncContext *s, int n)
 174 {
 175     int code;
 176
 177     if (n < 4) {
 178         code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
 179         if (code < 0) {
 180             /* XXX: I don't understand why they use LONGER codes than
 181                necessary. The following code would be completely useless
 182                if they had thought about it !!! */
 183             code = get_bits(&s->gb, 7);
 184             if (code == 0x7c) {
 185                 code = (int8_t)(get_bits(&s->gb, 7) + 1);
 186             } else if (code == 0x7d) {
 187                 code = -128 + get_bits(&s->gb, 7);
 188             } else if (code == 0x7e) {
 189                 if (get_bits(&s->gb, 1) == 0)
 190                     code = (int8_t)(get_bits(&s->gb, 8) + 1);
 191                 else
 192                     code = (int8_t)(get_bits(&s->gb, 8));
 193             } else if (code == 0x7f) {
 194                 get_bits(&s->gb, 11);
 195                 code = 1;
 196             }
 197         } else {
 198             code -= 128;
 199         }
 200     } else {
 201         code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
 202         /* same remark */
 203         if (code < 0) {
 204             code = get_bits(&s->gb, 9);
 205             if (code == 0x1fc) {
 206                 code = (int8_t)(get_bits(&s->gb, 7) + 1);
 207             } else if (code == 0x1fd) {
 208                 code = -128 + get_bits(&s->gb, 7);
 209             } else if (code == 0x1fe) {
 210                 get_bits(&s->gb, 9);
 211                 code = 1;
 212             } else {
 213                 fprintf(stderr, "chroma dc error\n");
 214                 return 0xffff;
 215             }
 216         } else {
 217             code -= 128;
 218         }
 219     }
 220     return -code;
 221 }
 222
 223 #ifdef CONFIG_ENCODERS
 224
 225 /* write RV 1.0 compatible frame header */
 226 void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
 227 {
 228     int full_frame= 0;
 229
 230     align_put_bits(&s->pb);
 231
 232     put_bits(&s->pb, 1, 1);     /* marker */
 233
 234     put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
 235
 236     put_bits(&s->pb, 1, 0);     /* not PB frame */
 237
 238     put_bits(&s->pb, 5, s->qscale);
 239
 240     if (s->pict_type == I_TYPE) {
 241         /* specific MPEG like DC coding not used */
 242     }
 243     /* if multiple packets per frame are sent, the position at which
 244        to display the macro blocks is coded here */
 245     if(!full_frame){
 246         put_bits(&s->pb, 6, 0); /* mb_x */
 247         put_bits(&s->pb, 6, 0); /* mb_y */
 248         put_bits(&s->pb, 12, s->mb_width * s->mb_height);
 249     }
 250
 251     put_bits(&s->pb, 3, 0);     /* ignored */
 252 }
 253
 254 static int get_num(GetBitContext *gb)
 255 {
 256     int n, n1;
 257
 258     n = get_bits(gb, 16);
 259     if (n >= 0x4000) {
 260         return n - 0x4000;
 261     } else {
 262         n1 = get_bits(gb, 16);
 263         return (n << 16) | n1;
 264     }
 265 }
 266
 267 #endif //CONFIG_ENCODERS
 268
 269 /* read RV 1.0 compatible frame header */
 270 static int rv10_decode_picture_header(MpegEncContext *s)
 271 {
 272     int mb_count, pb_frame, marker, full_frame, unk;
 273
 274     full_frame= s->avctx->slice_count==1;
 275 //printf("ff:%d\n", full_frame);
 276     marker = get_bits(&s->gb, 1);
 277
 278     if (get_bits(&s->gb, 1))
 279         s->pict_type = P_TYPE;
 280     else
 281         s->pict_type = I_TYPE;
 282 //printf("h:%X ver:%d\n",h,s->rv10_version);
 283     if(!marker) printf("marker missing\n");
 284     pb_frame = get_bits(&s->gb, 1);
 285
 286 #ifdef DEBUG
 287     printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
 288 #endif
 289
 290     if (pb_frame){
 291         fprintf(stderr, "pb frame not supported\n");
 292         return -1;
 293     }
 294
 295     s->qscale = get_bits(&s->gb, 5);
 296     if(s->qscale==0){
 297         fprintf(stderr, "error, qscale:0\n");
 298         return -1;
 299     }
 300
 301     if (s->pict_type == I_TYPE) {
 302         if (s->rv10_version == 3) {
 303             /* specific MPEG like DC coding not used */
 304             s->last_dc[0] = get_bits(&s->gb, 8);
 305             s->last_dc[1] = get_bits(&s->gb, 8);
 306             s->last_dc[2] = get_bits(&s->gb, 8);
 307 #ifdef DEBUG
 308             printf("DC:%d %d %d\n",
 309                    s->last_dc[0],
 310                    s->last_dc[1],
 311                    s->last_dc[2]);
 312 #endif
 313         }
 314     }
 315     /* if multiple packets per frame are sent, the position at which
 316        to display the macro blocks is coded here */
 317     if ((!full_frame) || show_bits(&s->gb, 12)==0) {
 318         s->mb_x = get_bits(&s->gb, 6);  /* mb_x */
 319         s->mb_y = get_bits(&s->gb, 6);  /* mb_y */
 320         mb_count = get_bits(&s->gb, 12);
 321     } else {
 322         s->mb_x = 0;
 323         s->mb_y = 0;
 324         mb_count = s->mb_width * s->mb_height;
 325     }
 326     unk= get_bits(&s->gb, 3);   /* ignored */
 327 //printf("%d\n", unk);
 328     s->f_code = 1;
 329     s->unrestricted_mv = 1;
 330
 331     return mb_count;
 332 }
 333
 334 static int rv10_decode_init(AVCodecContext *avctx)
 335 {
 336     MpegEncContext *s = avctx->priv_data;
 337     static int done=0;
 338
 339     s->avctx= avctx;
 340     s->out_format = FMT_H263;
 341
 342     s->width = avctx->width;
 343     s->height = avctx->height;
 344
 345     s->h263_rv10 = 1;
 346     switch(avctx->sub_id){
 347     case 0x10000000:
 348         s->rv10_version= 0;
 349         s->h263_long_vectors=0;
 350         break;
 351     case 0x10003000:
 352         s->rv10_version= 3;
 353         s->h263_long_vectors=1;
 354         break;
 355     case 0x10003001:
 356         s->rv10_version= 3;
 357         s->h263_long_vectors=0;
 358         break;
 359     default:
 360         fprintf(stderr, "unknown header %X\n", avctx->sub_id);
 361     }
 362 //printf("ver:%X\n", avctx->sub_id);
 363     s->flags= avctx->flags;
 364
 365     if (MPV_common_init(s) < 0)
 366         return -1;
 367
 368     h263_decode_init_vlc(s);
 369
 370     s->y_dc_scale_table=
 371     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 372     s->progressive_sequence=1;
 373
 374     /* init rv vlc */
 375     if (!done) {
 376         init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
 377                  rv_lum_bits, 1, 1,
 378                  rv_lum_code, 2, 2);
 379         init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
 380                  rv_chrom_bits, 1, 1,
 381                  rv_chrom_code, 2, 2);
 382         done = 1;
 383     }
 384
 385     return 0;
 386 }
 387
 388 static int rv10_decode_end(AVCodecContext *avctx)
 389 {
 390     MpegEncContext *s = avctx->priv_data;
 391
 392     MPV_common_end(s);
 393     return 0;
 394 }
 395
 396 static int rv10_decode_packet(AVCodecContext *avctx,
 397                              uint8_t *buf, int buf_size)
 398 {
 399     MpegEncContext *s = avctx->priv_data;
 400     int i, mb_count, mb_pos, left;
 401
 402     init_get_bits(&s->gb, buf, buf_size*8);
 403
 404     mb_count = rv10_decode_picture_header(s);
 405     if (mb_count < 0) {
 406         fprintf(stderr, "HEADER ERROR\n");
 407         return -1;
 408     }
 409
 410     if (s->mb_x >= s->mb_width ||
 411         s->mb_y >= s->mb_height) {
 412         fprintf(stderr, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 413         return -1;
 414     }
 415     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 416     left = s->mb_width * s->mb_height - mb_pos;
 417     if (mb_count > left) {
 418         fprintf(stderr, "COUNT ERROR\n");
 419         return -1;
 420     }
 421
 422     if (s->mb_x == 0 && s->mb_y == 0) {
 423         if(MPV_frame_start(s, avctx) < 0)
 424             return -1;
 425     }
 426
 427 #ifdef DEBUG
 428     printf("qscale=%d\n", s->qscale);
 429 #endif
 430
 431     /* default quantization values */
 432     s->y_dc_scale = 8;
 433     s->c_dc_scale = 8;
 434     s->rv10_first_dc_coded[0] = 0;
 435     s->rv10_first_dc_coded[1] = 0;
 436     s->rv10_first_dc_coded[2] = 0;
 437
 438     if(s->mb_y==0) s->first_slice_line=1;
 439
 440     s->block_wrap[0]=
 441     s->block_wrap[1]=
 442     s->block_wrap[2]=
 443     s->block_wrap[3]= s->mb_width*2 + 2;
 444     s->block_wrap[4]=
 445     s->block_wrap[5]= s->mb_width + 2;
 446     ff_init_block_index(s);
 447     /* decode each macroblock */
 448     for(i=0;i<mb_count;i++) {
 449         ff_update_block_index(s);
 450 #ifdef DEBUG
 451         printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 452 #endif
 453
 454         s->dsp.clear_blocks(s->block[0]);
 455         s->mv_dir = MV_DIR_FORWARD;
 456         s->mv_type = MV_TYPE_16X16;
 457         if (ff_h263_decode_mb(s, s->block) == SLICE_ERROR) {
 458             fprintf(stderr, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 459             return -1;
 460         }
 461         MPV_decode_mb(s, s->block);
 462         if (++s->mb_x == s->mb_width) {
 463             s->mb_x = 0;
 464             s->mb_y++;
 465             ff_init_block_index(s);
 466             s->first_slice_line=0;
 467         }
 468     }
 469
 470     return buf_size;
 471 }
 472
 473 static int rv10_decode_frame(AVCodecContext *avctx,
 474                              void *data, int *data_size,
 475                              uint8_t *buf, int buf_size)
 476 {
 477     MpegEncContext *s = avctx->priv_data;
 478     int i;
 479     AVFrame *pict = data;
 480
 481 #ifdef DEBUG
 482     printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
 483 #endif
 484
 485     /* no supplementary picture */
 486     if (buf_size == 0) {
 487         *data_size = 0;
 488         return 0;
 489     }
 490
 491     if(avctx->slice_count){
 492         for(i=0; i<avctx->slice_count; i++){
 493             int offset= avctx->slice_offset[i];
 494             int size;
 495
 496             if(i+1 == avctx->slice_count)
 497                 size= buf_size - offset;
 498             else
 499                 size= avctx->slice_offset[i+1] - offset;
 500
 501             if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
 502                 return -1;
 503         }
 504     }else{
 505         if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
 506             return -1;
 507     }
 508
 509     if(s->mb_y>=s->mb_height){
 510         MPV_frame_end(s);
 511
 512         *pict= *(AVFrame*)&s->current_picture;
 513
 514         *data_size = sizeof(AVFrame);
 515     }else{
 516         *data_size = 0;
 517     }
 518
 519     return buf_size;
 520 }
 521
 522 AVCodec rv10_decoder = {
 523     "rv10",
 524     CODEC_TYPE_VIDEO,
 525     CODEC_ID_RV10,
 526     sizeof(MpegEncContext),
 527     rv10_decode_init,
 528     NULL,
 529     rv10_decode_end,
 530     rv10_decode_frame,
 531     CODEC_CAP_DR1
 532 };