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