deps/libretro-common/formats/bmp/rbmp.c

   1 /* Copyright  (C) 2010-2020 The RetroArch team
   2  *
   3  * ---------------------------------------------------------------------------------------
   4  * The following license statement only applies to this file (rbmp.c).
   5  * ---------------------------------------------------------------------------------------
   6  *
   7  * Permission is hereby granted, free of charge,
   8  * to any person obtaining a copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation the rights to
  10  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
  11  * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  16  * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  18  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  19  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  */
  22
  23 /* Modified version of stb_image's BMP sources. */
  24
  25 #include <stdio.h>
  26 #include <stdint.h>
  27 #include <stdarg.h>
  28 #include <stddef.h> /* ptrdiff_t on osx */
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include <retro_inline.h>
  33
  34 #include <formats/image.h>
  35 #include <formats/rbmp.h>
  36
  37 /* truncate int to byte without warnings */
  38 #define RBMP_BYTECAST(x)  ((unsigned char) ((x) & 255))
  39
  40 #define RBMP_COMPUTE_Y(r, g, b) ((unsigned char) ((((r) * 77) + ((g) * 150) +  (29 * (b))) >> 8))
  41
  42 typedef struct
  43 {
  44    unsigned char *img_buffer;
  45    unsigned char *img_buffer_end;
  46    unsigned char *img_buffer_original;
  47    int img_n;
  48    int img_out_n;
  49    int buflen;
  50    uint32_t img_x;
  51    uint32_t img_y;
  52    unsigned char buffer_start[128];
  53 } rbmp_context;
  54
  55 struct rbmp
  56 {
  57    uint8_t *buff_data;
  58    uint32_t *output_image;
  59 };
  60
  61 static INLINE unsigned char rbmp_get8(rbmp_context *s)
  62 {
  63    if (s->img_buffer < s->img_buffer_end)
  64       return *s->img_buffer++;
  65
  66    return 0;
  67 }
  68
  69 static void rbmp_skip(rbmp_context *s, int n)
  70 {
  71    if (n < 0)
  72    {
  73       s->img_buffer = s->img_buffer_end;
  74       return;
  75    }
  76
  77    s->img_buffer += n;
  78 }
  79
  80 static int rbmp_get16le(rbmp_context *s)
  81 {
  82    return rbmp_get8(s) + (rbmp_get8(s) << 8);
  83 }
  84
  85 #define RBMP_GET32LE(s) (rbmp_get16le(s) + (rbmp_get16le(s) << 16))
  86
  87 static unsigned char *rbmp_convert_format(
  88       unsigned char *data,
  89       int img_n,
  90       int req_comp,
  91       unsigned int x,
  92       unsigned int y)
  93 {
  94    int i,j;
  95    unsigned char *good = (unsigned char *)malloc(req_comp * x * y);
  96
  97    if (!good)
  98       return NULL;
  99
 100    for (j=0; j < (int) y; ++j)
 101    {
 102       unsigned char *src  = data + j * x * img_n   ;
 103       unsigned char *dest = good + j * x * req_comp;
 104
 105       switch (((img_n)*8+(req_comp)))
 106       {
 107          case 10:
 108             for (i = x-1; i >= 0; --i, src += 1, dest += 2)
 109             {
 110                dest[0]=src[0];
 111                dest[1]=255;
 112             }
 113             break;
 114          case 11:
 115             for (i = x-1; i >= 0; --i, src += 1, dest += 3)
 116                dest[0]=dest[1]=dest[2]=src[0];
 117             break;
 118          case 12:
 119             for (i = x-1; i >= 0; --i, src += 1, dest += 4)
 120             {
 121                dest[0]=dest[1]=dest[2]=src[0];
 122                dest[3]=255;
 123             }
 124             break;
 125          case 17:
 126             for (i = x-1; i >= 0; --i, src += 2, dest += 1)
 127                dest[0]=src[0];
 128             break;
 129          case 19:
 130             for (i = x-1; i >= 0; --i, src += 2, dest += 3)
 131                dest[0]=dest[1]=dest[2]=src[0];
 132             break;
 133          case 20:
 134             for (i = x-1; i >= 0; --i, src += 2, dest += 4)
 135             {
 136                dest[0]=dest[1]=dest[2]=src[0];
 137                dest[3]=src[1];
 138             }
 139             break;
 140          case 28:
 141             for (i = x-1; i >= 0; --i, src += 3, dest += 4)
 142             {
 143                dest[0]=src[0];
 144                dest[1]=src[1];
 145                dest[2]=src[2];
 146                dest[3]=255;
 147             }
 148             break;
 149          case 25:
 150             for (i = x-1; i >= 0; --i, src += 3, dest += 1)
 151                dest[0] = RBMP_COMPUTE_Y(src[0],src[1],src[2]);
 152             break;
 153          case 26:
 154             for (i = x-1; i >= 0; --i, src += 3, dest += 2)
 155             {
 156                dest[0] = RBMP_COMPUTE_Y(src[0],src[1],src[2]);
 157                dest[1] = 255;
 158             }
 159             break;
 160          case 33:
 161             for (i = x-1; i >= 0; --i, src += 4, dest += 1)
 162                dest[0] = RBMP_COMPUTE_Y(src[0],src[1],src[2]);
 163             break;
 164          case 34:
 165             for (i = x-1; i >= 0; --i, src += 4, dest += 2)
 166             {
 167                dest[0] = RBMP_COMPUTE_Y(src[0],src[1],src[2]);
 168                dest[1] = src[3];
 169             }
 170             break;
 171          case 35:
 172             for (i = x-1; i >= 0; --i, src += 4, dest += 3)
 173             {
 174                dest[0]=src[0];
 175                dest[1]=src[1];
 176                dest[2]=src[2];
 177             }
 178             break;
 179          default:
 180             break;
 181       }
 182
 183    }
 184
 185    return good;
 186 }
 187
 188 /* Microsoft/Windows BMP image */
 189
 190 /* returns 0..31 for the highest set bit */
 191 static int rbmp_high_bit(unsigned int z)
 192 {
 193    int n=0;
 194    if (z == 0)
 195       return -1;
 196
 197    if (z >= 0x10000)
 198    {
 199       n  += 16;
 200       z >>= 16;
 201    }
 202    if (z >= 0x00100)
 203    {
 204       n  +=  8;
 205       z >>=  8;
 206    }
 207    if (z >= 0x00010)
 208    {
 209       n  +=  4;
 210       z >>=  4;
 211    }
 212    if (z >= 0x00004)
 213    {
 214       n  +=  2;
 215       z >>=  2;
 216    }
 217    if (z >= 0x00002)
 218       n +=  1;
 219    return n;
 220 }
 221
 222 static int rbmp_bitcount(unsigned int a)
 223 {
 224    a = (a & 0x55555555) + ((a >>  1) & 0x55555555); /* max 2 */
 225    a = (a & 0x33333333) + ((a >>  2) & 0x33333333); /* max 4 */
 226    a = (a + (a >> 4)) & 0x0f0f0f0f; /* max 8 per 4, now 8 bits */
 227    a = (a + (a >> 8));              /* max 16 per 8 bits */
 228    a = (a + (a >> 16));             /* max 32 per 8 bits */
 229    return a & 0xff;
 230 }
 231
 232 static int rbmp_shiftsigned(int v, int shift, int bits)
 233 {
 234    int result;
 235    int z = bits;
 236
 237    if (shift < 0)
 238       v <<= -shift;
 239    else
 240       v >>= shift;
 241
 242    result = v;
 243
 244    while (z < 8)
 245    {
 246       result += v >> z;
 247       z      += bits;
 248    }
 249    return result;
 250 }
 251
 252 static unsigned char *rbmp_bmp_load(rbmp_context *s, unsigned *x, unsigned *y,
 253       int *comp, int req_comp)
 254 {
 255    unsigned char *out;
 256    int bpp, flip_vertically, pad, target, offset, hsz;
 257    int psize=0,i,j,width;
 258    unsigned int mr=0,mg=0,mb=0,ma=0;
 259
 260    /* Corrupt BMP? */
 261    if (rbmp_get8(s) != 'B' || rbmp_get8(s) != 'M')
 262       return 0;
 263
 264    /* discard filesize */
 265    rbmp_get16le(s);
 266    rbmp_get16le(s);
 267    /* discard reserved */
 268    rbmp_get16le(s);
 269    rbmp_get16le(s);
 270
 271    offset = (uint32_t)RBMP_GET32LE(s);
 272    hsz    = (uint32_t)RBMP_GET32LE(s);
 273
 274    /* BMP type not supported? */
 275    if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124)
 276       return 0;
 277
 278    if (hsz == 12)
 279    {
 280       s->img_x = rbmp_get16le(s);
 281       s->img_y = rbmp_get16le(s);
 282    }
 283    else
 284    {
 285       s->img_x = (uint32_t)RBMP_GET32LE(s);
 286       s->img_y = (uint32_t)RBMP_GET32LE(s);
 287    }
 288
 289    /* Bad BMP? */
 290    if (rbmp_get16le(s) != 1)
 291       return 0;
 292
 293    bpp = rbmp_get16le(s);
 294
 295    /* BMP 1-bit type not supported? */
 296    if (bpp == 1)
 297       return 0;
 298
 299    flip_vertically = ((int) s->img_y) > 0;
 300    s->img_y        = abs((int) s->img_y);
 301
 302    if (hsz == 12)
 303    {
 304       if (bpp < 24)
 305          psize = (offset - 14 - 24) / 3;
 306    }
 307    else
 308    {
 309       int compress = (uint32_t)RBMP_GET32LE(s);
 310
 311       /* BMP RLE type not supported? */
 312       if (compress == 1 || compress == 2)
 313          return 0;
 314
 315       /* discard sizeof */
 316       rbmp_get16le(s);
 317       rbmp_get16le(s);
 318       /* discard hres */
 319       rbmp_get16le(s);
 320       rbmp_get16le(s);
 321       /* discard vres */
 322       rbmp_get16le(s);
 323       rbmp_get16le(s);
 324       /* discard colors used */
 325       rbmp_get16le(s);
 326       rbmp_get16le(s);
 327       /* discard max important */
 328       rbmp_get16le(s);
 329       rbmp_get16le(s);
 330
 331       if (hsz == 40 || hsz == 56)
 332       {
 333          if (hsz == 56)
 334          {
 335             rbmp_get16le(s);
 336             rbmp_get16le(s);
 337             rbmp_get16le(s);
 338             rbmp_get16le(s);
 339             rbmp_get16le(s);
 340             rbmp_get16le(s);
 341             rbmp_get16le(s);
 342             rbmp_get16le(s);
 343          }
 344          if (bpp == 16 || bpp == 32)
 345          {
 346             switch (compress)
 347             {
 348                case 0:
 349 #if 0
 350                   if (bpp == 32)
 351                   {
 352                      mr = 0xffu << 16;
 353                      mg = 0xffu <<  8;
 354                      mb = 0xffu <<  0;
 355                      ma = 0xffu << 24;
 356                   }
 357                   else
 358                   {
 359                      mr = 31u << 10;
 360                      mg = 31u <<  5;
 361                      mb = 31u <<  0;
 362                   }
 363 #endif
 364                   break;
 365                case 3:
 366                   mr = (uint32_t)RBMP_GET32LE(s);
 367                   mg = (uint32_t)RBMP_GET32LE(s);
 368                   mb = (uint32_t)RBMP_GET32LE(s);
 369                   /* not documented, but generated by
 370                    * Photoshop and handled by MS Paint */
 371                   /* Bad BMP ?*/
 372                   if (mr == mg && mg == mb)
 373                      return 0;
 374                   break;
 375                default:
 376 #if 0
 377                   mr = mg = mb = 0;
 378 #endif
 379                   break;
 380             }
 381
 382             /* Bad BMP? */
 383             return 0;
 384          }
 385       }
 386       else
 387       {
 388          mr = (uint32_t)RBMP_GET32LE(s);
 389          mg = (uint32_t)RBMP_GET32LE(s);
 390          mb = (uint32_t)RBMP_GET32LE(s);
 391          ma = (uint32_t)RBMP_GET32LE(s);
 392          /* Discard color space */
 393          rbmp_get16le(s);
 394          rbmp_get16le(s);
 395          for (i = 0; i < 12; ++i)
 396          {
 397             /* Discard color space parameters */
 398             rbmp_get16le(s);
 399             rbmp_get16le(s);
 400          }
 401          if (hsz == 124)
 402          {
 403             /* Discard rendering intent */
 404             rbmp_get16le(s);
 405             rbmp_get16le(s);
 406             /* Discard offset of profile data */
 407             rbmp_get16le(s);
 408             rbmp_get16le(s);
 409             /* Discard size of profile data */
 410             rbmp_get16le(s);
 411             rbmp_get16le(s);
 412             /* Discard reserved */
 413             rbmp_get16le(s);
 414             rbmp_get16le(s);
 415          }
 416       }
 417       if (bpp < 16)
 418          psize = (offset - 14 - hsz) >> 2;
 419    }
 420    s->img_n = ma ? 4 : 3;
 421    if (req_comp && req_comp >= 3) /* We can directly decode 3 or 4 */
 422       target = req_comp;
 423    else
 424       target = s->img_n; /* If they want monochrome, we'll post-convert */
 425
 426    out = (unsigned char *) malloc(target * s->img_x * s->img_y);
 427
 428    if (!out)
 429       return 0;
 430
 431    if (bpp < 16)
 432    {
 433       unsigned char pal[256][4];
 434       int z=0;
 435
 436       /* Corrupt BMP? */
 437       if (psize == 0 || psize > 256)
 438       {
 439          free(out);
 440          return 0;
 441       }
 442
 443       for (i = 0; i < psize; ++i)
 444       {
 445          pal[i][2] = rbmp_get8(s);
 446          pal[i][1] = rbmp_get8(s);
 447          pal[i][0] = rbmp_get8(s);
 448          if (hsz != 12)
 449             rbmp_get8(s);
 450          pal[i][3] = 255;
 451       }
 452
 453       rbmp_skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4));
 454       if (bpp == 4)
 455          width = (s->img_x + 1) >> 1;
 456       else if (bpp == 8)
 457          width = s->img_x;
 458       else
 459       {
 460          /* Corrupt BMP */
 461          free(out);
 462          return 0;
 463       }
 464
 465       pad = (-width)&3;
 466       for (j=0; j < (int) s->img_y; ++j)
 467       {
 468          for (i = 0; i < (int) s->img_x; i += 2)
 469          {
 470             int v  = rbmp_get8(s);
 471             int v2 = 0;
 472             if (bpp == 4)
 473             {
 474                v2  = v & 15;
 475                v >>= 4;
 476             }
 477             out[z++] = pal[v][0];
 478             out[z++] = pal[v][1];
 479             out[z++] = pal[v][2];
 480             if (target == 4)
 481                out[z++] = 255;
 482
 483             if (i+1 == (int)s->img_x)
 484                break;
 485
 486             v        = (bpp == 8) ? rbmp_get8(s) : v2;
 487             out[z++] = pal[v][0];
 488             out[z++] = pal[v][1];
 489             out[z++] = pal[v][2];
 490
 491             if (target == 4)
 492                out[z++] = 255;
 493          }
 494          rbmp_skip(s, pad);
 495       }
 496    }
 497    else
 498    {
 499       int rshift = 0;
 500       int gshift = 0;
 501       int bshift = 0;
 502       int ashift = 0;
 503       int rcount = 0;
 504       int gcount = 0;
 505       int bcount = 0;
 506       int acount = 0;
 507       int z      = 0;
 508       int easy   = 0;
 509
 510       rbmp_skip(s, offset - 14 - hsz);
 511
 512       if (bpp == 24)
 513          width = 3 * s->img_x;
 514       else if (bpp == 16)
 515          width = 2*s->img_x;
 516       else /* bpp = 32 and pad = 0 */
 517          width=0;
 518
 519       pad = (-width) & 3;
 520
 521       switch (bpp)
 522       {
 523          case 24:
 524             easy = 1;
 525             break;
 526          case 32:
 527             if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
 528                easy = 2;
 529             break;
 530          default:
 531             break;
 532       }
 533
 534       if (!easy)
 535       {
 536          /* Corrupt BMP? */
 537          if (!mr || !mg || !mb)
 538          {
 539             free(out);
 540             return 0;
 541          }
 542
 543          /* right shift amt to put high bit in position #7 */
 544          rshift = rbmp_high_bit(mr)-7;
 545          rcount = rbmp_bitcount(mr);
 546          gshift = rbmp_high_bit(mg)-7;
 547          gcount = rbmp_bitcount(mg);
 548          bshift = rbmp_high_bit(mb)-7;
 549          bcount = rbmp_bitcount(mb);
 550          ashift = rbmp_high_bit(ma)-7;
 551          acount = rbmp_bitcount(ma);
 552       }
 553
 554       for (j=0; j < (int) s->img_y; ++j)
 555       {
 556          if (easy)
 557          {
 558             if (target == 4)
 559             {
 560                /* Need to apply alpha channel as well */
 561                if (easy == 2)
 562                {
 563                   for (i = 0; i < (int) s->img_x; ++i)
 564                   {
 565                      out[z+2]        = rbmp_get8(s);
 566                      out[z+1]        = rbmp_get8(s);
 567                      out[z+0]        = rbmp_get8(s);
 568                      z              += 3;
 569                      out[z++]        = rbmp_get8(s);
 570                   }
 571                }
 572                else
 573                {
 574                   for (i = 0; i < (int) s->img_x; ++i)
 575                   {
 576                      out[z+2]        = rbmp_get8(s);
 577                      out[z+1]        = rbmp_get8(s);
 578                      out[z+0]        = rbmp_get8(s);
 579                      z              += 3;
 580                      out[z++]        = 255;
 581                   }
 582                }
 583             }
 584             else
 585             {
 586                for (i = 0; i < (int) s->img_x; ++i)
 587                {
 588                   out[z+2]        = rbmp_get8(s);
 589                   out[z+1]        = rbmp_get8(s);
 590                   out[z+0]        = rbmp_get8(s);
 591                   z              += 3;
 592                }
 593             }
 594          }
 595          else
 596          {
 597             if (target == 4)
 598             {
 599                /* Need to apply alpha channel as well */
 600                if (ma)
 601                {
 602                   if (bpp == 16)
 603                   {
 604                      for (i = 0; i < (int) s->img_x; ++i)
 605                      {
 606                         uint32_t v  = (uint32_t)rbmp_get16le(s);
 607                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mr, rshift, rcount));
 608                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mg, gshift, gcount));
 609                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mb, bshift, bcount));
 610                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & ma, ashift, acount));
 611                      }
 612                   }
 613                   else
 614                   {
 615                      for (i = 0; i < (int) s->img_x; ++i)
 616                      {
 617                         uint32_t v  = (uint32_t)RBMP_GET32LE(s);
 618                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mr, rshift, rcount));
 619                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mg, gshift, gcount));
 620                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mb, bshift, bcount));
 621                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & ma, ashift, acount));
 622                      }
 623                   }
 624                }
 625                else
 626                {
 627                   if (bpp == 16)
 628                   {
 629                      for (i = 0; i < (int) s->img_x; ++i)
 630                      {
 631                         uint32_t v  = (uint32_t)rbmp_get16le(s);
 632                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mr, rshift, rcount));
 633                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mg, gshift, gcount));
 634                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mb, bshift, bcount));
 635                         out[z++]    = RBMP_BYTECAST(255);
 636                      }
 637                   }
 638                   else
 639                   {
 640                      for (i = 0; i < (int) s->img_x; ++i)
 641                      {
 642                         uint32_t v  = (uint32_t)RBMP_GET32LE(s);
 643                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mr, rshift, rcount));
 644                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mg, gshift, gcount));
 645                         out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mb, bshift, bcount));
 646                         out[z++]    = RBMP_BYTECAST(255);
 647                      }
 648                   }
 649                }
 650             }
 651             else
 652             {
 653                if (bpp == 16)
 654                {
 655                   for (i = 0; i < (int) s->img_x; ++i)
 656                   {
 657                      uint32_t v  = (uint32_t)rbmp_get16le(s);
 658                      out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mr, rshift, rcount));
 659                      out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mg, gshift, gcount));
 660                      out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mb, bshift, bcount));
 661                   }
 662                }
 663                else
 664                {
 665                   for (i = 0; i < (int) s->img_x; ++i)
 666                   {
 667                      uint32_t v  = (uint32_t)RBMP_GET32LE(s);
 668                      out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mr, rshift, rcount));
 669                      out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mg, gshift, gcount));
 670                      out[z++]    = RBMP_BYTECAST(rbmp_shiftsigned(v & mb, bshift, bcount));
 671                   }
 672                }
 673             }
 674          }
 675          rbmp_skip(s, pad);
 676       }
 677    }
 678
 679    if (flip_vertically)
 680    {
 681       unsigned char t;
 682       for (j=0; j < (int) s->img_y>>1; ++j)
 683       {
 684          unsigned char *p1 = out +      j     *s->img_x*target;
 685          unsigned char *p2 = out + (s->img_y-1-j)*s->img_x*target;
 686          for (i = 0; i < (int) s->img_x*target; ++i)
 687          {
 688             t     = p1[i];
 689             p1[i] = p2[i];
 690             p2[i] = t;
 691          }
 692       }
 693    }
 694
 695    if (
 696             req_comp
 697          && (req_comp >= 1 && req_comp <= 4)
 698          && (req_comp != target))
 699    {
 700       unsigned char *tmp = rbmp_convert_format(out, target, req_comp, s->img_x, s->img_y);
 701
 702       free(out);
 703       out = NULL;
 704
 705       if (!tmp)
 706          return NULL;
 707
 708       out = tmp;
 709    }
 710
 711    *x = s->img_x;
 712    *y = s->img_y;
 713
 714    if (comp)
 715       *comp = s->img_n;
 716
 717    return out;
 718 }
 719
 720 static unsigned char *rbmp_load_from_memory(unsigned char const *buffer, int len,
 721       unsigned *x, unsigned *y, int *comp, int req_comp)
 722 {
 723    rbmp_context s;
 724
 725    s.img_buffer          = (unsigned char*)buffer;
 726    s.img_buffer_original = (unsigned char*)buffer;
 727    s.img_buffer_end      = (unsigned char*)buffer+len;
 728
 729    return rbmp_bmp_load(&s,x,y,comp,req_comp);
 730 }
 731
 732 static void rbmp_convert_frame(uint32_t *frame, unsigned width, unsigned height)
 733 {
 734    uint32_t *end = frame + (width * height * sizeof(uint32_t))/4;
 735
 736    while (frame < end)
 737    {
 738       uint32_t pixel = *frame;
 739       *frame = (pixel & 0xff00ff00) | ((pixel << 16) & 0x00ff0000) | ((pixel >> 16) & 0xff);
 740       frame++;
 741    }
 742 }
 743
 744 int rbmp_process_image(rbmp_t *rbmp, void **buf_data,
 745       size_t size, unsigned *width, unsigned *height)
 746 {
 747    int comp;
 748
 749    if (!rbmp)
 750       return IMAGE_PROCESS_ERROR;
 751
 752    rbmp->output_image   = (uint32_t*)rbmp_load_from_memory(rbmp->buff_data,
 753                            (int)size, width, height, &comp, 4);
 754    *buf_data             = rbmp->output_image;
 755
 756    rbmp_convert_frame(rbmp->output_image, *width, *height);
 757
 758    return IMAGE_PROCESS_END;
 759 }
 760
 761 bool rbmp_set_buf_ptr(rbmp_t *rbmp, void *data)
 762 {
 763    if (!rbmp)
 764       return false;
 765
 766    rbmp->buff_data = (uint8_t*)data;
 767
 768    return true;
 769 }
 770
 771 void rbmp_free(rbmp_t *rbmp)
 772 {
 773    if (!rbmp)
 774       return;
 775
 776    free(rbmp);
 777 }
 778
 779 rbmp_t *rbmp_alloc(void)
 780 {
 781    rbmp_t *rbmp = (rbmp_t*)calloc(1, sizeof(*rbmp));
 782    if (!rbmp)
 783       return NULL;
 784    return rbmp;
 785 }