src/misc/bitmap.c

   1
   2 /*
   3  * libneuro, a light weight abstraction of high or lower libraries
   4  * and toolkit for applications.
   5  * Copyright (C) 2005-2006  Nicholas Niro, Robert Lemay
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 /* bitmap process module */
  23
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <math.h>
  27 #include <string.h>
  28
  29 #define old 0
  30
  31 #if USE_ZLIB
  32 /* this is used to open the bitmaps,
  33  * the beauty of this is it works
  34  * for compressed and uncompressed
  35  * transparently, meaning no extra code
  36  * for both!
  37  */
  38 #include <zlib.h>
  39 typedef gzFile nFILE;
  40 #else /* NOT USE_ZLIB */
  41 typedef FILE nFILE;
  42 #endif /* USE_ZLIB */
  43
  44 #include <ebuf.h>
  45 #include <other.h>
  46 #include <extlib.h> /* Lib_GetDefaultDepth() */
  47
  48 #include <graphics.h> /* Neuro_PutPixel */
  49
  50
  51 typedef struct BITMAP_HEADER
  52 {
  53         u16 type __attribute__((packed));                       /* Magic identifier            */
  54         u32 size __attribute__((packed));                       /* File size in bytes          */
  55         u16 reserved1, reserved2;       /* reserved */
  56         u32 offset __attribute__((packed));                     /* Offset to image data, bytes */
  57 }BITMAP_HEADER;
  58
  59 typedef struct BITMAP_INFOHEADER
  60 {
  61         u32 size;                       /* Header size in bytes      */
  62         i32 width, height;              /* Width and height of image */
  63         u16 planes;                     /* Number of colour planes   */
  64         u16 bits;                       /* Bits per pixel            */
  65         u32 compression;                /* Compression type          */
  66         u32 imagesize;                  /* Image size in bytes       */
  67         i32 xresolution, yresolution;   /* Pixels per meter          */
  68         u32 ncolors;                    /* Number of colours         */
  69         u32 importantcolours;           /* Important colours         */
  70 }BITMAP_INFOHEADER;
  71
  72 typedef struct BITMAP_HDATA
  73 {
  74         BITMAP_HEADER header __attribute__((packed));
  75         BITMAP_INFOHEADER infoheader __attribute__((packed));
  76 }BITMAP_HDATA;
  77
  78 typedef struct BITMAP_COLOR
  79 {
  80         u8 r, g, b /*, a*/ ; /* red green blue */
  81         u8 *symbol; /* unique symbol associated with this color */
  82 }BITMAP_COLOR;
  83
  84 typedef struct BITMAP_MAP
  85 {
  86         BITMAP_COLOR *color;
  87 }BITMAP_MAP;
  88
  89 static u32 color_key = 0; /* this is the pixel we will make it so it is transparent */
  90
  91 /* static function prototypes */
  92 static void print_bitmap_infos(BITMAP_HDATA *bmap) __attribute__((unused));
  93 static int fpdata8(nFILE *input, u8 *output) __attribute__((unused));
  94 static int fpdata16(nFILE *input, u16 *output) __attribute__((unused));
  95 static int fpdata32(nFILE *input, u32 *output) __attribute__((unused));
  96
  97
  98
  99 /* static functions */
 100
 101 static void
 102 clean_bmap_color(void *eng)
 103 {
 104         BITMAP_COLOR *buf;
 105
 106         buf = (BITMAP_COLOR*)eng;
 107
 108         if (buf->symbol)
 109                 free(buf->symbol);
 110 }
 111
 112
 113 /* returns 0 on success and puts the data in *output
 114  * 1 on error dont touch output
 115  */
 116 static int
 117 fpdata8(nFILE *input, u8 *output)
 118 {
 119         if (input == NULL || output == NULL)
 120                 return 1;
 121 #if USE_ZLIB
 122         *output = gzgetc(input);
 123 #else /* NOT USE_ZLIB */
 124         *output = fgetc(input);
 125 #endif /* NOT USE_ZLIB */
 126
 127
 128         return 0;
 129 }
 130
 131 /* returns 0 on success and puts the data in *output
 132  * 1 on error dont touch output
 133  */
 134 static int
 135 fpdata16(nFILE *input, u16 *output)
 136 {
 137         u8 feed[2];
 138         u16 *buf;
 139
 140         if (input == NULL || output == NULL)
 141                 return 1;
 142
 143 #if USE_ZLIB
 144         feed[0] = gzgetc(input);
 145         feed[1] = gzgetc(input);
 146 #else /* NOT USE_ZLIB */
 147         feed[0] = fgetc(input);
 148         feed[1] = fgetc(input);
 149 #endif /* NOT USE_ZLIB */
 150
 151         buf = (u16*)&feed;
 152
 153         *output = *buf;
 154
 155         return 0;
 156 }
 157
 158 /* returns 0 on success and puts the data in *output
 159  * 1 on error dont touch output
 160  */
 161 static int
 162 fpdata32(nFILE *input, u32 *output)
 163 {
 164         /* register int feed; */
 165         u8 feed[4];
 166         u32 *buf;
 167
 168
 169         if (input == NULL || output == NULL)
 170                 return 1;
 171
 172 #if USE_ZLIB
 173         feed[0] = gzgetc(input);
 174         feed[1] = gzgetc(input);
 175         feed[2] = gzgetc(input);
 176         feed[3] = gzgetc(input);
 177 #else /* NOT USE_ZLIB */
 178         feed[0] = fgetc(input);
 179         feed[1] = fgetc(input);
 180         feed[2] = fgetc(input);
 181         feed[3] = fgetc(input);
 182 #endif /* NOT USE_ZLIB */
 183
 184         buf = (u32*)&feed;
 185
 186         *output = *buf;
 187
 188         return 0;
 189 }
 190
 191 static BITMAP_HDATA *
 192 parse_bitmap_header(nFILE *input)
 193 {
 194         BITMAP_HDATA *buf;
 195         BITMAP_INFOHEADER *tmp;
 196
 197         if (input == NULL)
 198                 return NULL;
 199
 200         buf = calloc(1, sizeof(BITMAP_HDATA));
 201
 202         tmp = &buf->infoheader;
 203
 204         fpdata16(input, &buf->header.type);
 205         fpdata32(input, &buf->header.size);
 206         fpdata16(input, &buf->header.reserved1);
 207         fpdata16(input, &buf->header.reserved2);
 208         fpdata32(input, &buf->header.offset);
 209
 210         fpdata32(input, &tmp->size);
 211         fpdata32(input, (u32*)&tmp->width);
 212         fpdata32(input, (u32*)&tmp->height);
 213         fpdata16(input, &tmp->planes);
 214         fpdata16(input, &tmp->bits);
 215         fpdata32(input, &tmp->compression);
 216         fpdata32(input, &tmp->imagesize);
 217         fpdata32(input, (u32*)&tmp->xresolution);
 218         fpdata32(input, (u32*)&tmp->yresolution);
 219         fpdata32(input, &tmp->ncolors);
 220         fpdata32(input, &tmp->importantcolours);
 221
 222         return buf;
 223 }
 224
 225 /* the magic number will probably not show correctly if big endian */
 226 static void
 227 print_bitmap_infos(BITMAP_HDATA *bmap)
 228 {
 229         printf("[%c%c] header data :\nsize %d\noffset %d\ninfoheader data :\nsize %d\nwidth %d\nheight %d\nplanes %d\nbits %d\ncompression %d\nimagesize %d\nxres %d\nyres %d\nncolors %d\nimportantcolors %d\n",
 230                 bmap->header.type & 0x00FF,
 231                 (bmap->header.type & 0xFF00) >> 8,
 232                 bmap->header.size,
 233                 bmap->header.offset,
 234                 bmap->infoheader.size,
 235                 bmap->infoheader.width,
 236                 bmap->infoheader.height,
 237                 bmap->infoheader.planes,
 238                 bmap->infoheader.bits,
 239                 bmap->infoheader.compression,
 240                 bmap->infoheader.imagesize,
 241                 bmap->infoheader.xresolution,
 242                 bmap->infoheader.yresolution,
 243                 bmap->infoheader.ncolors,
 244                 bmap->infoheader.importantcolours);
 245 }
 246
 247
 248 static void
 249 process_palette(nFILE *input, BITMAP_HDATA *bmap, EBUF *bcolors)
 250 {
 251         u32 i = 0;
 252         BITMAP_COLOR *buf;
 253
 254         while (i < bmap->infoheader.ncolors)
 255         {
 256                 Neuro_AllocEBuf(bcolors, sizeof(BITMAP_COLOR*), sizeof(BITMAP_COLOR));
 257
 258                 buf = Neuro_GiveCurEBuf(bcolors);
 259
 260                 /*buf->r = palette[(i * 4) + 2];
 261                 buf->g = palette[(i * 4) + 1];
 262                 buf->b = palette[(i * 4)];
 263                 */
 264
 265                 /*
 266                 fpdata8(input, &buf->b);
 267                 fpdata8(input, &buf->g);
 268                 fpdata8(input, &buf->r);
 269                 fpdata8(input, &buf->a);
 270                 */
 271 #if USE_ZLIB
 272                 buf->b = gzgetc(input);
 273                 buf->g = gzgetc(input);
 274                 buf->r = gzgetc(input);
 275
 276                 /* I leave this just in case */
 277                 /* buf->a = fgetc(input); */
 278
 279                 /* skip the alpha color */
 280                 gzgetc(input);
 281 #else /* NOT USE_ZLIB */
 282                 buf->b = fgetc(input);
 283                 buf->g = fgetc(input);
 284                 buf->r = fgetc(input);
 285
 286                 /* I leave this just in case */
 287                 /* buf->a = fgetc(input); */
 288
 289                 /* skip the alpha color */
 290                 fgetc(input);
 291 #endif /* NOT USE_ZLIB */
 292                 i++;
 293         }
 294 }
 295
 296 /* input the bits per pixel of the image
 297  * input a 1 byte of data to process
 298  */
 299 static void
 300 process_bitmap2(BITMAP_HDATA *bmap, v_object *image, u8 *palette, u8 *data, EBUF *bcolors, u32 *x, u32 *y, int *aux, char **buf)
 301 {
 302
 303         /* we will call functions depending on the bpp of the image */
 304         switch (bmap->infoheader.bits)
 305         {
 306                 case 1:
 307                 {
 308                         /* will do a loop to get each 8 pixels from the data */
 309
 310                         /* this is pretty much for little endian
 311                          * the minimum data size we can have for a certain width is
 312                          * 32 bits (4 bytes increments). Those 32 bits will be able
 313                          * to hold up to 32 pixels. In case the width is higher than
 314                          * 32 pixels, it will put 32 bits until the whole width
 315                          * can be fulfilled.
 316                          */
 317                         /* we will need to have the width value because we will need
 318                          * to know how many bits we have to read from 32 bits (4 bytes).
 319                          */
 320                         /* aux will keep how many 32 bits still need to be done in a
 321                          * certain width
 322                          */
 323                         u8 temp;
 324                         /* double calc = 0; */
 325
 326                         /* u8 r, g, b; */
 327
 328                         const u8 values[8] = {
 329                                 0x80,
 330                                 0x40,
 331                                 0x20,
 332                                 0x10,
 333                                 0x08,
 334                                 0x04,
 335                                 0x02,
 336                                 0x01
 337                         };
 338                         u32 i = 0;
 339                         u32 max = 0;
 340
 341                         if (*buf == NULL)
 342                         {
 343                                 *buf = calloc(1, sizeof(char));
 344                                 **buf = 0;
 345                                 *aux = 0;
 346                         }
 347
 348                         /* set up aux for remaining pixels */
 349                         if (*aux == 0)
 350                                 *aux = bmap->infoheader.width;
 351
 352                         /* set up the number of pixels we need to process in this cycle */
 353                         if (*aux > 8)
 354                         {
 355                                 max = 8;
 356                                 *aux = *aux - 8;
 357                         }
 358                         else
 359                         {
 360                                 max = *aux;
 361                                 *aux = 0;
 362                         }
 363
 364                         temp = *data;
 365
 366                         while (i < max)
 367                         {
 368                                 BITMAP_COLOR *cbuf = NULL;
 369
 370                                 if (IsLittleEndian())
 371                                         temp = *data & values[i];
 372                                 else
 373                                         temp = *data & values[7 - i];
 374
 375
 376                                 if (temp)
 377                                         temp = 1;
 378
 379                                 cbuf = Neuro_GiveEBuf(bcolors, temp);
 380
 381                                 Neuro_PutPixel(image, *x, (bmap->infoheader.height - 1) - *y, Neuro_MapRGB(cbuf->r, cbuf->g, cbuf->b));
 382
 383                                 *x = *x + 1;
 384                                 i++;
 385                         }
 386
 387                         if (*x > bmap->infoheader.width - 1)
 388                         {
 389                                 *x = 0;
 390                                 *y = *y + 1;
 391                         }
 392                 }
 393                 break;
 394
 395                 case 4:
 396                 {
 397                         /* will do a loop to get each 2 pixels from the data */
 398                         u8 temp;
 399                         /* double calc = 0; */
 400
 401                         /* u8 r, g, b; */
 402
 403                         const u8 values[2] = {
 404                                 0xF0,
 405                                 0x0F,
 406                         };
 407                         u32 i = 0;
 408                         u32 max = 0;
 409
 410                         if (*buf == NULL)
 411                         {
 412                                 *buf = calloc(1, sizeof(char));
 413                                 **buf = 0;
 414                                 *aux = 0;
 415                         }
 416
 417                         /* set up aux for remaining pixels */
 418                         if (*aux == 0)
 419                                 *aux = bmap->infoheader.width;
 420
 421                         /* set up the number of pixels we need to process in this cycle */
 422                         if (*aux > 2)
 423                         {
 424                                 max = 2;
 425                                 *aux = *aux - 2;
 426                         }
 427                         else
 428                         {
 429                                 max = *aux;
 430                                 *aux = 0;
 431                         }
 432
 433                         temp = *data;
 434
 435                         while (i < max)
 436                         {
 437                                 BITMAP_COLOR *cbuf = NULL;
 438
 439                                 if (IsLittleEndian())
 440                                 {
 441                                         temp = *data & values[i];
 442
 443                                         if (temp > values[1])
 444                                                 temp >>= 4;
 445                                 }
 446                                 else
 447                                 {
 448                                         temp = *data & values[1 - i];
 449
 450                                         if (temp > values[0])
 451                                                 temp <<= 4;
 452                                 }
 453
 454                                 cbuf = Neuro_GiveEBuf(bcolors, temp);
 455
 456                                 Neuro_PutPixel(image, *x, (bmap->infoheader.height - 1) - *y, Neuro_MapRGB(cbuf->r, cbuf->g, cbuf->b));
 457
 458                                 *x = *x + 1;
 459                                 i++;
 460                         }
 461
 462                         if (*x > bmap->infoheader.width - 1)
 463                         {
 464                                 *x = 0;
 465                                 *y = *y + 1;
 466                         }
 467
 468                 }
 469                 break;
 470
 471                 case 8:
 472                 {
 473                         /* will get the single pixel from the data */
 474                         u8 temp;
 475                         /* double calc = 0; */
 476
 477                         /* u8 r, g, b; */
 478
 479                         u32 i = 0;
 480                         u32 max = 0;
 481
 482                         if (*buf == NULL)
 483                         {
 484                                 *buf = calloc(1, sizeof(char));
 485                                 **buf = 0;
 486                                 *aux = 0;
 487                         }
 488
 489                         /* set up aux for remaining pixels */
 490                         if (*aux == 0)
 491                                 *aux = bmap->infoheader.width;
 492
 493                         /* set up the number of pixels we need to process in this cycle */
 494                         if (*aux > 1)
 495                         {
 496                                 max = 1;
 497                                 *aux = *aux - 1;
 498                         }
 499                         else
 500                         {
 501                                 max = *aux;
 502                                 *aux = 0;
 503                         }
 504
 505                         temp = *data;
 506
 507                         while (i < max)
 508                         {
 509                                 BITMAP_COLOR *cbuf = NULL;
 510                                 temp = *data;
 511
 512
 513                                 cbuf = Neuro_GiveEBuf(bcolors, temp);
 514
 515                                 Neuro_PutPixel(image, *x, (bmap->infoheader.height - 1) - *y, Neuro_MapRGB(cbuf->r, cbuf->g, cbuf->b));
 516
 517                                 *x = *x + 1;
 518                                 i++;
 519                         }
 520
 521                         if (*x > bmap->infoheader.width - 1)
 522                         {
 523                                 *x = 0;
 524                                 *y = *y + 1;
 525                         }
 526
 527                 }
 528                 break;
 529
 530                 case 16:
 531                 {
 532                         /* we do not support 16 bit because I think they
 533                          * use 24 bit for those. we'll see through use.
 534                          * if not, I really think this depth is pointless...
 535                          */
 536                 }
 537                 break;
 538
 539                 case 24:
 540                 {
 541                         /* will need to gather the data for 2 other bytes to get a
 542                          * single pixel. We will use the auxiliary variable to keep
 543                          * track of where we are at in the gathering.
 544                          */
 545
 546                         if (!*buf)
 547                         {
 548                                 *buf = calloc(3, sizeof(u8));
 549                                 *aux = 0;
 550                         }
 551
 552                         (*buf)[*aux] = *data;
 553                         *aux = *aux + 1;
 554
 555                         if (*aux >= 3)
 556                         {
 557                                 *aux = 0;
 558
 559                                 Neuro_PutPixel(image, *x, (bmap->infoheader.height - 1) - *y, Neuro_MapRGB((*buf)[2], (*buf)[1], (*buf)[0]));
 560
 561                                 *x = *x + 1;
 562                         }
 563
 564                         if (*x > bmap->infoheader.width - 1)
 565                         {
 566                                 *x = 0;
 567                                 *y = *y + 1;
 568                         }
 569                 }
 570                 break;
 571
 572                 case 32:
 573                 {
 574                         /* we do not support 32 bit because it is Very uncommon if it
 575                          * actually exist. Pretty much the same as 16 bpp.
 576                          */
 577                 }
 578                 break;
 579
 580                 default:
 581                 {
 582                         /* an error occured */
 583                 }
 584                 break;
 585
 586         }
 587 }
 588
 589 static v_object *
 590 processFD_BMP(nFILE *f_bitmap)
 591 {
 592         /* major (buffers) */
 593         EBUF *bmap_colors = NULL; /* the colors */
 594         u8 *buf = NULL; /* the buffer that will contain the content of the file */
 595
 596         /* minor (mostly pointers and temporary variables) */
 597         register i32 i = 0; /* incremental variable */
 598         u32 skip_i = 0, x = 0, y = 0;
 599
 600         u32 psize = 0; /* the full size of the pixels data */
 601         u8 *palette = NULL; /* the pointer to the palette if theres one */
 602         BITMAP_HDATA *bmap; /* this is how we will get informations about the bitmap */
 603         int aux_var = 0; /* auxiliary variable that can be used by external functions */
 604         char *aux_buf = NULL; /* same as aux_var but a buffer */
 605         double msize = 0;
 606         double calc = 0;
 607         double tmp = 0;
 608         u32 wmult = 0;
 609         double pixellen = 0;
 610         u32 increm = 0;
 611         u8 DATA;
 612         v_object *output; /* the image into which we will load the bitmap */
 613
 614         if (f_bitmap == NULL)
 615                 return NULL;
 616
 617         bmap = parse_bitmap_header(f_bitmap);
 618
 619         /* TODO TODO XXX check here if the bitmap is valid or not
 620          * first check for the BM word
 621          * then we check for the size of the file in header and size
 622          * we got when reading the file
 623          */
 624         {
 625
 626         }
 627
 628         /* if it is valid, we create the buffers */
 629         Neuro_CreateEBuf(&bmap_colors);
 630         Neuro_SetcallbEBuf(bmap_colors, &clean_bmap_color);
 631
 632
 633         /* print_bitmap_infos(bmap); */
 634
 635         /* process the bitmap(load it in memory) */
 636         i = 0;
 637         psize = bmap->header.size - (sizeof(BITMAP_HEADER) + sizeof(BITMAP_INFOHEADER));
 638         psize = psize - (bmap->infoheader.ncolors * 4);
 639         /* printf("data size %d\n", psize); */
 640
 641         if (bmap->infoheader.ncolors)
 642         {
 643                 process_palette(f_bitmap, bmap, bmap_colors);
 644         }
 645
 646         /* we create the v_object
 647          *
 648          * will need to put better values for the masks to support SDL.
 649          */
 650         {
 651                 u32 rmask = 0, gmask = 0, bmask = 0, amask = 0;
 652
 653                 if (IsLittleEndian())
 654                 {
 655                         switch (Lib_GetDefaultDepth())
 656                         {
 657                                 case 16:
 658                                 {
 659                                         rmask = 0x0000f800;
 660                                         gmask = 0x000007e0;
 661                                         bmask = 0x0000001f;
 662                                         amask = 0x00000000;
 663                                 }
 664                                 break;
 665
 666                                 case 24:
 667                                 {
 668                                         rmask = 0x00ff0000;
 669                                         gmask = 0x0000ff00;
 670                                         bmask = 0x000000ff;
 671                                         amask = 0x00000000;
 672                                 }
 673                                 break;
 674
 675
 676                                 default:
 677                                 break;
 678                         }
 679                 }
 680                 else
 681                 {
 682                         switch (Lib_GetDefaultDepth())
 683                         {
 684                                 case 16:
 685                                 {
 686                                         rmask = 0x0000001f;
 687                                         gmask = 0x000007e0;
 688                                         bmask = 0x0000f800;
 689                                         amask = 0x00000000;
 690                                 }
 691                                 break;
 692
 693                                 case 24:
 694                                 {
 695                                         rmask = 0x0000ff00;
 696                                         gmask = 0x00ff0000;
 697                                         bmask = 0xff000000;
 698                                         amask = 0x00000000;
 699                                 }
 700                                 break;
 701
 702                                 default:
 703                                 break;
 704                         }
 705                 }
 706 /*
 707                 if (IsLittleEndian())
 708                 {
 709                         rmask = 0x0000f800;
 710                         gmask = 0x000007e0;
 711                         bmask = 0x0000001f;
 712                         amask = 0x00000000;
 713                 }
 714                 else
 715                 {
 716                         rmask = 0x0000001f;
 717                         gmask = 0x000007e0;
 718                         bmask = 0x0000f800;
 719                         amask = 0x00000000;
 720                 }
 721 */
 722
 723                 output = Neuro_CreateVObject(0, bmap->infoheader.width, bmap->infoheader.height, bmap->infoheader.bits, rmask, gmask, bmask, amask);
 724
 725                 if (output == NULL)
 726                         return NULL;
 727         }
 728
 729         /* semi static values to skip bytes that form 32 bit chunks in the data */
 730
 731         pixellen = (8 / (double)bmap->infoheader.bits);
 732         msize = pixellen * 4;
 733
 734         /* we calculate the number of bytes there is per rows
 735          * this is mainly so we can know how much "alignment"
 736          * bytes there is (which need to be skipped)
 737          */
 738         {
 739                 wmult = (u32)bmap->infoheader.bits / 8;
 740
 741                 if (wmult == 0)
 742                         wmult++;
 743
 744                 wmult = wmult * bmap->infoheader.width;
 745         }
 746
 747         increm = (u32)pixellen;
 748
 749         if (increm == 0)
 750                 increm++;
 751
 752         x = (u32)(bmap->infoheader.width / msize);
 753         tmp = msize * x;
 754         tmp = (double)bmap->infoheader.width - tmp;
 755         tmp = tmp - 0.000001; /* to avoid bugs */
 756
 757         x = 0;
 758 #if USE_ZLIB
 759         gzseek(f_bitmap, bmap->header.offset, SEEK_SET);
 760 #else /* NOT USE_ZLIB */
 761         fseek(f_bitmap, bmap->header.offset, SEEK_SET);
 762 #endif /* NOT USE_ZLIB */
 763
 764         Lib_LockVObject(output);
 765
 766         /* Debug_Val(0, "Image bits depth %d  tmp %f\n", bmap->infoheader.bits, tmp); */
 767
 768         while (i < psize)
 769         {
 770                 if (tmp > 0)
 771                 {
 772                         /* skip bytes that are inside the bitmap for
 773                          * filling purpose. (the data is purposely filled
 774                          * with 0 bits so the data is 32bits aligned)
 775                          */
 776                         if (skip_i >= wmult)
 777                         {
 778                                 calc = tmp / pixellen;
 779                                 skip_i = (u32)calc;
 780                                 if (skip_i < calc)
 781                                 {
 782                                         skip_i++;
 783                                 }
 784                                 skip_i = (4 - skip_i);
 785                                 i += skip_i;
 786
 787 #if USE_ZLIB
 788                                 gzseek(f_bitmap, bmap->header.offset + i, SEEK_SET);
 789 #else /* NOT USE_ZLIB */
 790                                 fseek(f_bitmap, bmap->header.offset + i, SEEK_SET);
 791 #endif /* NOT USE_ZLIB */
 792
 793                                 /*
 794                                 printf("skipping %d bytes  wmult %d width %d tmp %f plen %f calc %f\n",
 795                                                 skip_i,
 796                                                 wmult,
 797                                                 bmap->infoheader.width,
 798                                                 tmp,
 799                                                 pixellen, calc);
 800                                 */
 801
 802                                 skip_i = 0;
 803                         }
 804
 805                         skip_i += increm;
 806
 807                         if (i >= psize)
 808                                 break;
 809                 }
 810
 811
 812                 fpdata8(f_bitmap, &DATA);
 813
 814                 process_bitmap2(bmap, output, palette, &DATA,
 815                                 bmap_colors, &x, &y, &aux_var, &aux_buf);
 816
 817
 818                 /* process_bitmap2(bmap, output, palette, &DATA,
 819                                 bmap_colors, x, y, &aux_var, &aux_buf); */
 820
 821
 822                 /* printf("i %d psize %d\n", i, psize); */
 823                 /* Debug_Val(0, "current coord : %d,%d   %d\n", x, y, wmult); */
 824                 /*
 825                 if (tmp <= 0)
 826                 {
 827                         static u8 t = 2;
 828
 829                         if (t == 0 || x > bmap->infoheader.width - 1)
 830                         {
 831                                 if (x < bmap->infoheader.width - 1)
 832                                         x++;
 833                                 else
 834                                 {
 835                                         x = 0;
 836                                         y++;
 837                                 }
 838
 839                                 t = 2;
 840                         }
 841                         else
 842                                 t--;
 843                 }
 844                 */
 845
 846                 i++;
 847         }
 848
 849         Lib_UnlockVObject(output);
 850
 851         if (bmap)
 852                 free(bmap);
 853         if (buf)
 854                 free(buf);
 855         if (aux_buf)
 856                 free(aux_buf);
 857
 858         Neuro_CleanEBuf(&bmap_colors);
 859
 860 #if USE_ZLIB
 861         if (f_bitmap)
 862                 gzclose(f_bitmap);
 863 #else /* NOT USE_ZLIB */
 864         if (f_bitmap)
 865                 fclose(f_bitmap);
 866 #endif /* NOT USE_ZLIB */
 867
 868         return output;
 869 }
 870
 871 /* Global functions */
 872
 873 void
 874 cleanPixmapEbuf(EBUF **pixmap)
 875 {
 876         Neuro_CleanEBuf(pixmap);
 877 }
 878
 879 void
 880 setBitmapColorKey(u32 key)
 881 {
 882         color_key = key;
 883 }
 884
 885 void
 886 readBitmapBufferToPixmap(char *data, EBUF **output_pixmap)
 887 {
 888 }
 889
 890 void
 891 readBitmapFileToPixmap(const char *bitmap, EBUF **output_pixmap)
 892 {
 893 }
 894
 895 v_object *
 896 readBitmapFile(const char *bitmap)
 897 {
 898         nFILE *f_bitmap;
 899
 900 #if USE_ZLIB
 901         f_bitmap = gzopen(bitmap, "r"); /* can also be used for non compressed files */
 902 #else /* NOT USE_ZLIB */
 903         f_bitmap = fopen(bitmap, "r");
 904 #endif /* NOT USE_ZLIB */
 905
 906         return processFD_BMP(f_bitmap);
 907 }
 908