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 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 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 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 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)(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)(get_bits(&s->gb, 8) + 1);
 191                 else
 192                     code = (INT8)(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)(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 /* write RV 1.0 compatible frame header */
 224 void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
 225 {
 226     int full_frame= 0;
 227
 228     align_put_bits(&s->pb);
 229
 230     put_bits(&s->pb, 1, 1);     /* marker */
 231
 232     put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
 233
 234     put_bits(&s->pb, 1, 0);     /* not PB frame */
 235
 236     put_bits(&s->pb, 5, s->qscale);
 237
 238     if (s->pict_type == I_TYPE) {
 239         /* specific MPEG like DC coding not used */
 240     }
 241     /* if multiple packets per frame are sent, the position at which
 242        to display the macro blocks is coded here */
 243     if(!full_frame){
 244         put_bits(&s->pb, 6, 0); /* mb_x */
 245         put_bits(&s->pb, 6, 0); /* mb_y */
 246         put_bits(&s->pb, 12, s->mb_width * s->mb_height);
 247     }
 248
 249     put_bits(&s->pb, 3, 0);     /* ignored */
 250 }
 251
 252 static int get_num(GetBitContext *gb)
 253 {
 254     int n, n1;
 255
 256     n = get_bits(gb, 16);
 257     if (n >= 0x4000) {
 258         return n - 0x4000;
 259     } else {
 260         n1 = get_bits(gb, 16);
 261         return (n << 16) | n1;
 262     }
 263 }
 264
 265 /* read RV 1.0 compatible frame header */
 266 static int rv10_decode_picture_header(MpegEncContext *s)
 267 {
 268     int mb_count, pb_frame, marker, h, full_frame;
 269     int pic_num, unk;
 270
 271     //XXX/FIXME this should be done in the demuxer not here
 272     /* skip packet header */
 273     h = get_bits(&s->gb, 8);
 274     if ((h & 0xc0) == 0xc0) {
 275         int len, pos;
 276         full_frame = 1;
 277         len = get_num(&s->gb);
 278         pos = get_num(&s->gb);
 279 //printf("pos:%d\n",len);
 280     } else {
 281         int seq, frame_size, pos;
 282         full_frame = 0;
 283         seq = get_bits(&s->gb, 8);
 284         frame_size = get_num(&s->gb);
 285         pos = get_num(&s->gb);
 286 //printf("seq:%d, size:%d, pos:%d\n",seq,frame_size,pos);
 287     }
 288     /* picture number */
 289     pic_num= get_bits(&s->gb, 8);
 290
 291     marker = get_bits(&s->gb, 1);
 292
 293     if (get_bits(&s->gb, 1))
 294         s->pict_type = P_TYPE;
 295     else
 296         s->pict_type = I_TYPE;
 297 //printf("h:%d ver:%d\n",h,s->rv10_version);
 298     if(!marker) printf("marker missing\n");
 299     pb_frame = get_bits(&s->gb, 1);
 300
 301 #ifdef DEBUG
 302     printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
 303 #endif
 304
 305     if (pb_frame){
 306         fprintf(stderr, "pb frame not supported\n");
 307         return -1;
 308     }
 309
 310     s->qscale = get_bits(&s->gb, 5);
 311     if(s->qscale==0){
 312         fprintf(stderr, "error, qscale:0\n");
 313         return -1;
 314     }
 315
 316     if (s->pict_type == I_TYPE) {
 317         if (s->rv10_version == 3) {
 318             /* specific MPEG like DC coding not used */
 319             s->last_dc[0] = get_bits(&s->gb, 8);
 320             s->last_dc[1] = get_bits(&s->gb, 8);
 321             s->last_dc[2] = get_bits(&s->gb, 8);
 322 #ifdef DEBUG
 323             printf("DC:%d %d %d\n",
 324                    s->last_dc[0],
 325                    s->last_dc[1],
 326                    s->last_dc[2]);
 327 #endif
 328         }
 329     }
 330     /* if multiple packets per frame are sent, the position at which
 331        to display the macro blocks is coded here */
 332     if (!full_frame) {
 333         s->mb_x = get_bits(&s->gb, 6);  /* mb_x */
 334         s->mb_y = get_bits(&s->gb, 6);  /* mb_y */
 335         mb_count = get_bits(&s->gb, 12);
 336     } else {
 337         s->mb_x = 0;
 338         s->mb_y = 0;
 339         mb_count = s->mb_width * s->mb_height;
 340     }
 341     unk= get_bits(&s->gb, 3);   /* ignored */
 342 //printf("%d\n", unk);
 343     s->f_code = 1;
 344     s->unrestricted_mv = 1;
 345
 346     return mb_count;
 347 }
 348
 349 static int rv10_decode_init(AVCodecContext *avctx)
 350 {
 351     MpegEncContext *s = avctx->priv_data;
 352     static int done;
 353
 354     s->avctx= avctx;
 355     s->out_format = FMT_H263;
 356
 357     s->width = avctx->width;
 358     s->height = avctx->height;
 359
 360     s->h263_rv10 = 1;
 361     if(avctx->extradata_size >= 8){
 362         switch(((uint32_t*)avctx->extradata)[1]){
 363         case 0x10000000:
 364             s->rv10_version= 0;
 365             s->h263_long_vectors=0;
 366             break;
 367         case 0x10003000:
 368             s->rv10_version= 3;
 369             s->h263_long_vectors=1;
 370             break;
 371         case 0x10003001:
 372             s->rv10_version= 3;
 373             s->h263_long_vectors=0;
 374             break;
 375         default:
 376             fprintf(stderr, "unknown header %X\n", ((uint32_t*)avctx->extradata)[1]);
 377         }
 378     }else{
 379     //  for backward compatibility
 380         s->rv10_version= avctx->sub_id;
 381     }
 382
 383     s->flags= avctx->flags;
 384
 385     if (MPV_common_init(s) < 0)
 386         return -1;
 387
 388     h263_decode_init_vlc(s);
 389
 390     s->y_dc_scale_table=
 391     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 392
 393     /* init rv vlc */
 394     if (!done) {
 395         init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
 396                  rv_lum_bits, 1, 1,
 397                  rv_lum_code, 2, 2);
 398         init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
 399                  rv_chrom_bits, 1, 1,
 400                  rv_chrom_code, 2, 2);
 401         done = 1;
 402     }
 403
 404     return 0;
 405 }
 406
 407 static int rv10_decode_end(AVCodecContext *avctx)
 408 {
 409     MpegEncContext *s = avctx->priv_data;
 410
 411     MPV_common_end(s);
 412     return 0;
 413 }
 414
 415 static int rv10_decode_frame(AVCodecContext *avctx,
 416                              void *data, int *data_size,
 417                              UINT8 *buf, int buf_size)
 418 {
 419     MpegEncContext *s = avctx->priv_data;
 420     int i, mb_count, mb_pos, left;
 421     DCTELEM block[6][64];
 422     AVPicture *pict = data;
 423
 424 #ifdef DEBUG
 425     printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
 426 #endif
 427
 428     /* no supplementary picture */
 429     if (buf_size == 0) {
 430         *data_size = 0;
 431         return 0;
 432     }
 433
 434     init_get_bits(&s->gb, buf, buf_size);
 435
 436     mb_count = rv10_decode_picture_header(s);
 437     if (mb_count < 0) {
 438         fprintf(stderr, "HEADER ERROR\n");
 439         return -1;
 440     }
 441
 442     if (s->mb_x >= s->mb_width ||
 443         s->mb_y >= s->mb_height) {
 444         fprintf(stderr, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 445         return -1;
 446     }
 447     mb_pos = s->mb_y * s->mb_width + s->mb_x;
 448     left = s->mb_width * s->mb_height - mb_pos;
 449     if (mb_count > left) {
 450         fprintf(stderr, "COUNT ERROR\n");
 451         return -1;
 452     }
 453
 454     if (s->mb_x == 0 && s->mb_y == 0) {
 455         MPV_frame_start(s, avctx);
 456     }
 457
 458 #ifdef DEBUG
 459     printf("qscale=%d\n", s->qscale);
 460 #endif
 461
 462     /* default quantization values */
 463     s->y_dc_scale = 8;
 464     s->c_dc_scale = 8;
 465     s->rv10_first_dc_coded[0] = 0;
 466     s->rv10_first_dc_coded[1] = 0;
 467     s->rv10_first_dc_coded[2] = 0;
 468
 469     s->block_wrap[0]=
 470     s->block_wrap[1]=
 471     s->block_wrap[2]=
 472     s->block_wrap[3]= s->mb_width*2 + 2;
 473     s->block_wrap[4]=
 474     s->block_wrap[5]= s->mb_width + 2;
 475     s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
 476     s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1)     + s->mb_x*2;
 477     s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
 478     s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2)     + s->mb_x*2;
 479     s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
 480     s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
 481     /* decode each macroblock */
 482     for(i=0;i<mb_count;i++) {
 483         s->block_index[0]+=2;
 484         s->block_index[1]+=2;
 485         s->block_index[2]+=2;
 486         s->block_index[3]+=2;
 487         s->block_index[4]++;
 488         s->block_index[5]++;
 489 #ifdef DEBUG
 490         printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 491 #endif
 492
 493         memset(block, 0, sizeof(block));
 494         s->mv_dir = MV_DIR_FORWARD;
 495         s->mv_type = MV_TYPE_16X16;
 496         if (h263_decode_mb(s, block) < 0) {
 497             fprintf(stderr, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 498             return -1;
 499         }
 500         MPV_decode_mb(s, block);
 501         if (++s->mb_x == s->mb_width) {
 502             s->mb_x = 0;
 503             s->mb_y++;
 504             s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1;
 505             s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1);
 506             s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1;
 507             s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2);
 508             s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);
 509             s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
 510         }
 511     }
 512
 513     if (s->mb_x == 0 &&
 514         s->mb_y == s->mb_height) {
 515         MPV_frame_end(s);
 516
 517         pict->data[0] = s->current_picture[0];
 518         pict->data[1] = s->current_picture[1];
 519         pict->data[2] = s->current_picture[2];
 520         pict->linesize[0] = s->linesize;
 521         pict->linesize[1] = s->uvlinesize;
 522         pict->linesize[2] = s->uvlinesize;
 523
 524         avctx->quality = s->qscale;
 525         *data_size = sizeof(AVPicture);
 526     } else {
 527         *data_size = 0;
 528     }
 529     return buf_size;
 530 }
 531
 532 AVCodec rv10_decoder = {
 533     "rv10",
 534     CODEC_TYPE_VIDEO,
 535     CODEC_ID_RV10,
 536     sizeof(MpegEncContext),
 537     rv10_decode_init,
 538     NULL,
 539     rv10_decode_end,
 540     rv10_decode_frame,
 541     CODEC_CAP_DR1
 542 };