tools/bmp2rb.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Linus Nielsen Feltzing
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 /****************************************************************************
  22  *
  23  * Converts BMP files to Rockbox bitmap format
  24  *
  25  * 1999-05-03 Linus Nielsen Feltzing
  26  *
  27  * 2005-07-06 Jens Arnold
  28  *            added reading of 4, 16, 24 and 32 bit bmps
  29  *            added 2 new target formats (playergfx and iriver 4-grey)
  30  *
  31  ****************************************************************************/
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <stdbool.h>
  37 #include <unistd.h>
  38
  39 #include <sys/types.h>
  40 #include <sys/stat.h>
  41 #include <fcntl.h>
  42
  43 #define debugf printf
  44
  45 #ifdef __GNUC__
  46 #define STRUCT_PACKED __attribute__((packed))
  47 #else
  48 #define STRUCT_PACKED
  49 #pragma pack (push, 2)
  50 #endif
  51
  52 struct Fileheader
  53 {
  54     unsigned short Type;          /* signature - 'BM' */
  55     unsigned int  Size;          /* file size in bytes */
  56     unsigned short Reserved1;     /* 0 */
  57     unsigned short Reserved2;     /* 0 */
  58     unsigned int  OffBits;       /* offset to bitmap */
  59     unsigned int  StructSize;    /* size of this struct (40) */
  60     unsigned int  Width;         /* bmap width in pixels */
  61     unsigned int  Height;        /* bmap height in pixels */
  62     unsigned short Planes;        /* num planes - always 1 */
  63     unsigned short BitCount;      /* bits per pixel */
  64     unsigned int  Compression;   /* compression flag */
  65     unsigned int  SizeImage;     /* image size in bytes */
  66     int           XPelsPerMeter; /* horz resolution */
  67     int           YPelsPerMeter; /* vert resolution */
  68     unsigned int  ClrUsed;       /* 0 -> color table size */
  69     unsigned int  ClrImportant;  /* important color count */
  70 } STRUCT_PACKED;
  71
  72 struct RGBQUAD
  73 {
  74     unsigned char rgbBlue;
  75     unsigned char rgbGreen;
  76     unsigned char rgbRed;
  77     unsigned char rgbReserved;
  78 } STRUCT_PACKED;
  79
  80 short readshort(void* value)
  81 {
  82     unsigned char* bytes = (unsigned char*) value;
  83     return bytes[0] | (bytes[1] << 8);
  84 }
  85
  86 int readint(void* value)
  87 {
  88     unsigned char* bytes = (unsigned char*) value;
  89     return bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24);
  90 }
  91
  92 unsigned char brightness(struct RGBQUAD color)
  93 {
  94     return (3 * (unsigned int)color.rgbRed + 6 * (unsigned int)color.rgbGreen
  95               + (unsigned int)color.rgbBlue) / 10;
  96 }
  97
  98 #ifndef O_BINARY
  99 #define O_BINARY 0 /* systems that don't have O_BINARY won't make a difference
 100                       on text and binary files */
 101 #endif
 102
 103 /****************************************************************************
 104  * read_bmp_file()
 105  *
 106  * Reads an uncompressed BMP file and puts the data in a 4-byte-per-pixel
 107  * (RGBQUAD) array. Returns 0 on success.
 108  *
 109  ***************************************************************************/
 110
 111 int read_bmp_file(char* filename,
 112                   int *get_width,  /* in pixels */
 113                   int *get_height, /* in pixels */
 114                   struct RGBQUAD **bitmap)
 115 {
 116     struct Fileheader fh;
 117     struct RGBQUAD palette[256];
 118
 119     int fd = open(filename, O_RDONLY| O_BINARY);
 120     unsigned short data;
 121     unsigned char *bmp;
 122     int width, height;
 123     int padded_width;
 124     int size;
 125     int row, col, i;
 126     int numcolors, compression;
 127     int depth;
 128
 129     if (fd == -1)
 130     {
 131         debugf("error - can't open '%s'\n", filename);
 132         return 1;
 133     }
 134     if (read(fd, &fh, sizeof(struct Fileheader)) !=
 135         sizeof(struct Fileheader))
 136     {
 137         debugf("error - can't Read Fileheader Stucture\n");
 138         close(fd);
 139         return 2;
 140     }
 141
 142     compression = readint(&fh.Compression);
 143
 144     if (compression != 0)
 145     {
 146         debugf("error - Unsupported compression %d\n", compression);
 147         close(fd);
 148         return 3;
 149     }
 150
 151     depth = readshort(&fh.BitCount);
 152
 153     if (depth <= 8)
 154     {
 155         numcolors = readint(&fh.ClrUsed);
 156         if (numcolors == 0)
 157             numcolors = 1 << depth;
 158
 159         if (read(fd, &palette[0], numcolors * sizeof(struct RGBQUAD))
 160             != (int)(numcolors * sizeof(struct RGBQUAD)))
 161         {
 162             debugf("error - Can't read bitmap's color palette\n");
 163             close(fd);
 164             return 4;
 165         }
 166     }
 167
 168     width = readint(&fh.Width);
 169     height = readint(&fh.Height);
 170     padded_width = ((width * depth + 31) / 8) & ~3; /* aligned 4-bytes boundaries */
 171
 172     size = padded_width * height; /* read this many bytes */
 173     bmp = (unsigned char *)malloc(size);
 174     *bitmap = (struct RGBQUAD *)malloc(width * height * sizeof(struct RGBQUAD));
 175
 176     if ((bmp == NULL) || (*bitmap == NULL))
 177     {
 178         debugf("error - Out of memory\n");
 179         close(fd);
 180         return 5;
 181     }
 182
 183     if (lseek(fd, (off_t)readint(&fh.OffBits), SEEK_SET) < 0)
 184     {
 185         debugf("error - Can't seek to start of image data\n");
 186         close(fd);
 187         return 6;
 188     }
 189     if (read(fd, (unsigned char*)bmp, (int)size) != size)
 190     {
 191         debugf("error - Can't read image\n");
 192         close(fd);
 193         return 7;
 194     }
 195
 196     close(fd);
 197     *get_width = width;
 198     *get_height = height;
 199
 200     switch (depth)
 201     {
 202       case 1:
 203         for (row = 0; row < height; row++)
 204             for (col = 0; col < width; col++)
 205             {
 206                 data = (bmp[(height - 1 - row) * padded_width + col / 8]
 207                         >> (~col & 7)) & 1;
 208                 (*bitmap)[row * width + col] = palette[data];
 209             }
 210         break;
 211
 212       case 4:
 213         for (row = 0; row < height; row++)
 214             for (col = 0; col < width; col++)
 215             {
 216                 data = (bmp[(height - 1 - row) * padded_width + col / 2]
 217                         >> (4 * (~col & 1))) & 0x0F;
 218                 (*bitmap)[row * width + col] = palette[data];
 219             }
 220         break;
 221
 222       case 8:
 223         for (row = 0; row < height; row++)
 224             for (col = 0; col < width; col++)
 225             {
 226                 data = bmp[(height - 1 - row) * padded_width + col];
 227                 (*bitmap)[row * width + col] = palette[data];
 228             }
 229         break;
 230
 231       case 16:
 232         for (row = 0; row < height; row++)
 233             for (col = 0; col < width; col++)
 234             {
 235                 data = readshort(&bmp[(height - 1 - row) * padded_width + 2 * col]);
 236                 (*bitmap)[row * width + col].rgbRed =
 237                     ((data >> 7) & 0xF8) | ((data >> 12) & 0x07);
 238                 (*bitmap)[row * width + col].rgbGreen =
 239                     ((data >> 2) & 0xF8) | ((data >> 7) & 0x07);
 240                 (*bitmap)[row * width + col].rgbBlue =
 241                     ((data << 3) & 0xF8) | ((data >> 2) & 0x07);
 242                 (*bitmap)[row * width + col].rgbReserved = 0;
 243             }
 244         break;
 245
 246       case 24:
 247         for (row = 0; row < height; row++)
 248             for (col = 0; col < width; col++)
 249             {
 250                 i = (height - 1 - row) * padded_width + 3 * col;
 251                 (*bitmap)[row * width + col].rgbRed = bmp[i+2];
 252                 (*bitmap)[row * width + col].rgbGreen = bmp[i+1];
 253                 (*bitmap)[row * width + col].rgbBlue = bmp[i];
 254                 (*bitmap)[row * width + col].rgbReserved = 0;
 255             }
 256         break;
 257
 258       case 32:
 259         for (row = 0; row < height; row++)
 260             for (col = 0; col < width; col++)
 261             {
 262                 i = (height - 1 - row) * padded_width + 4 * col;
 263                 (*bitmap)[row * width + col].rgbRed = bmp[i+2];
 264                 (*bitmap)[row * width + col].rgbGreen = bmp[i+1];
 265                 (*bitmap)[row * width + col].rgbBlue = bmp[i];
 266                 (*bitmap)[row * width + col].rgbReserved = 0;
 267             }
 268         break;
 269
 270       default: /* should never happen */
 271         debugf("error - Unsupported bitmap depth %d.\n", depth);
 272         return 8;
 273     }
 274
 275     free(bmp);
 276
 277     return 0; /* success */
 278 }
 279
 280 /****************************************************************************
 281  * transform_bitmap()
 282  *
 283  * Transform a 4-byte-per-pixel bitmap (RGBQUAD) into one of the supported
 284  * destination formats
 285  ****************************************************************************/
 286
 287 int transform_bitmap(const struct RGBQUAD *src, int width, int height,
 288                      int format, unsigned short **dest, int *dst_width,
 289                      int *dst_height, int *dst_depth)
 290 {
 291     int row, col;
 292     int dst_w, dst_h, dst_d;
 293
 294     switch (format)
 295     {
 296       case 0: /* Archos recorders, Ondio, Iriver H1x0 monochrome */
 297         dst_w = width;
 298         dst_h = (height + 7) / 8;
 299         dst_d = 8;
 300         break;
 301
 302       case 1: /* Archos player graphics library */
 303         dst_w = (width + 7) / 8;
 304         dst_h = height;
 305         dst_d = 8;
 306         break;
 307
 308       case 2: /* Iriver H1x0 4-grey */
 309         dst_w = width;
 310         dst_h = (height + 3) / 4;
 311         dst_d = 8;
 312         break;
 313
 314       case 3: /* Canonical 8-bit grayscale */
 315         dst_w = width;
 316         dst_h = height;
 317         dst_d = 8;
 318         break;
 319
 320       case 4: /* 16-bit packed RGB (5-6-5) */
 321       case 5: /* 16-bit packed and byte-swapped RGB (5-6-5) */
 322       case 8: /* 16-bit packed RGB (5-6-5) vertical stride*/
 323         dst_w = width;
 324         dst_h = height;
 325         dst_d = 16;
 326         break;
 327
 328       case 6: /* greyscale iPods 4-grey */
 329         dst_w = (width + 3) / 4;
 330         dst_h = height;
 331         dst_d = 8;
 332         break;
 333
 334       case 7: /* greyscale X5 remote 4-grey */
 335         dst_w = width;
 336         dst_h = (height + 7) / 8;
 337         dst_d = 16;
 338         break;
 339
 340       default: /* unknown */
 341         debugf("error - Undefined destination format\n");
 342         return 1;
 343     }
 344
 345     *dest = (unsigned short *)malloc(dst_w * dst_h * sizeof(short));
 346     if (*dest == NULL)
 347     {
 348         debugf("error - Out of memory.\n");
 349         return 2;
 350     }
 351     memset(*dest, 0, dst_w * dst_h * sizeof(short));
 352     *dst_width = dst_w;
 353     *dst_height = dst_h;
 354     *dst_depth = dst_d;
 355
 356     switch (format)
 357     {
 358       case 0: /* Archos recorders, Ondio, Iriver H1x0 b&w */
 359         for (row = 0; row < height; row++)
 360             for (col = 0; col < width; col++)
 361             {
 362                 (*dest)[(row/8) * dst_w + col] |=
 363                        (~brightness(src[row * width + col]) & 0x80) >> (~row & 7);
 364             }
 365         break;
 366
 367       case 1: /* Archos player graphics library */
 368         for (row = 0; row < height; row++)
 369             for (col = 0; col < width; col++)
 370             {
 371                 (*dest)[row * dst_w + (col/8)] |=
 372                        (~brightness(src[row * width + col]) & 0x80) >> (col & 7);
 373             }
 374         break;
 375
 376       case 2: /* Iriver H1x0 4-grey */
 377         for (row = 0; row < height; row++)
 378             for (col = 0; col < width; col++)
 379             {
 380                 (*dest)[(row/4) * dst_w + col] |=
 381                        (~brightness(src[row * width + col]) & 0xC0) >> (2 * (~row & 3));
 382             }
 383         break;
 384
 385       case 3: /* Canonical 8-bit grayscale */
 386         for (row = 0; row < height; row++)
 387             for (col = 0; col < width; col++)
 388             {
 389                 (*dest)[row * dst_w + col] = brightness(src[row * width + col]);
 390             }
 391         break;
 392
 393       case 4: /* 16-bit packed RGB (5-6-5) */
 394       case 5: /* 16-bit packed and byte-swapped RGB (5-6-5) */
 395         for (row = 0; row < height; row++)
 396             for (col = 0; col < width; col++)
 397             {
 398                 unsigned short rgb =
 399                     (((src[row * width + col].rgbRed >> 3) << 11) |
 400                      ((src[row * width + col].rgbGreen >> 2) << 5) |
 401                      ((src[row * width + col].rgbBlue >> 3)));
 402
 403                 if (format == 4)
 404                     (*dest)[row * dst_w + col] = rgb;
 405                 else
 406                     (*dest)[row * dst_w + col] = ((rgb&0xff00)>>8)|((rgb&0x00ff)<<8);
 407             }
 408         break;
 409
 410       case 6: /* greyscale iPods 4-grey */
 411         for (row = 0; row < height; row++)
 412             for (col = 0; col < width; col++)
 413             {
 414                 (*dest)[row * dst_w + (col/4)] |=
 415                        (~brightness(src[row * width + col]) & 0xC0) >> (2 * (col & 3));
 416             }
 417         break;
 418
 419       case 7: /* greyscale X5 remote 4-grey */
 420         for (row = 0; row < height; row++)
 421             for (col = 0; col < width; col++)
 422             {
 423                 unsigned short data = (~brightness(src[row * width + col]) & 0xC0) >> 6;
 424
 425                 data = (data | (data << 7)) & 0x0101;
 426                 (*dest)[(row/8) * dst_w + col] |= data << (row & 7);
 427             }
 428         break;
 429
 430       case 8: /* 16-bit packed RGB (5-6-5) vertical stride*/
 431         for (row = 0; row < height; row++)
 432             for (col = 0; col < width; col++)
 433             {
 434                 unsigned short rgb =
 435                     (((src[row * width + col].rgbRed >> 3) << 11) |
 436                      ((src[row * width + col].rgbGreen >> 2) << 5) |
 437                      ((src[row * width + col].rgbBlue >> 3)));
 438
 439                 (*dest)[col * dst_h + row] = rgb;
 440             }
 441         break;
 442     }
 443
 444     return 0;
 445 }
 446
 447 /****************************************************************************
 448  * generate_c_source()
 449  *
 450  * Outputs a C source code with the bitmap in an array, accompanied by
 451  * some #define's
 452  ****************************************************************************/
 453
 454 void generate_c_source(char *id, char* header_dir, int width, int height,
 455                        const unsigned short *t_bitmap, int t_width,
 456                        int t_height, int t_depth, bool t_mono, bool create_bm)
 457 {
 458     FILE *f;
 459     FILE *fh;
 460     int i, a;
 461     char header_name[1024];
 462     bool have_header = header_dir && header_dir[0];
 463     create_bm = have_header && create_bm;
 464
 465     if (!id || !id[0])
 466         id = "bitmap";
 467
 468     f = stdout;
 469
 470     if (have_header)
 471     {
 472         snprintf(header_name,sizeof(header_name),"%s/%s.h",header_dir,id);
 473         fh = fopen(header_name,"w+");
 474
 475         if (fh == NULL)
 476         {
 477             debugf("error - can't open '%s'\n", header_name);
 478             return;
 479         }
 480         fprintf(fh,
 481                 "#define BMPHEIGHT_%s %d\n"
 482                 "#define BMPWIDTH_%s %d\n",
 483                 id, height, id, width);
 484         if (t_depth <= 8)
 485             fprintf(fh, "extern const unsigned char %s[];\n", id);
 486         else
 487             fprintf(fh, "extern const unsigned short %s[];\n", id);
 488
 489         if (create_bm)
 490         {
 491             fprintf(f, "#include \"lcd.h\"\n");
 492             fprintf(fh, "extern const struct bitmap bm_%s;\n", id);
 493         }
 494         fclose(fh);
 495     } else {
 496         fprintf(f,
 497                 "#define BMPHEIGHT_%s %d\n"
 498                 "#define BMPWIDTH_%s %d\n",
 499                 id, height, id, width);
 500     }
 501
 502     if (create_bm) {
 503         fprintf(f, "#include \"%s\"\n", header_name);
 504     }
 505
 506     if (t_depth <= 8)
 507         fprintf(f, "const unsigned char %s[] = {\n", id);
 508     else
 509         fprintf(f, "const unsigned short %s[] = {\n", id);
 510
 511     for (i = 0; i < t_height; i++)
 512     {
 513         for (a = 0; a < t_width; a++)
 514         {
 515             if (t_depth <= 8)
 516                 fprintf(f, "0x%02x,%c", t_bitmap[i * t_width + a],
 517                         (a + 1) % 13 ? ' ' : '\n');
 518             else
 519                 fprintf(f, "0x%04x,%c", t_bitmap[i * t_width + a],
 520                         (a + 1) % 10 ? ' ' : '\n');
 521         }
 522         fprintf(f, "\n");
 523     }
 524
 525     fprintf(f, "\n};\n\n");
 526
 527     if (create_bm) {
 528         char format_line[] = "    .format = FORMAT_NATIVE, \n";
 529         fprintf(f, "const struct bitmap bm_%s = { \n"
 530                    "    .width = BMPWIDTH_%s, \n"
 531                    "    .height = BMPHEIGHT_%s, \n"
 532                    "%s"
 533                    "    .data = (unsigned char*)%s,\n"
 534                    "};\n",
 535                     id, id, id,
 536                     t_mono ? "" : format_line,
 537                     id);
 538     }
 539 }
 540
 541 void generate_raw_file(const unsigned short *t_bitmap,
 542                        int t_width, int t_height, int t_depth)
 543 {
 544     FILE *f;
 545     int i, a;
 546     unsigned char lo,hi;
 547
 548     f = stdout;
 549
 550     for (i = 0; i < t_height; i++)
 551     {
 552         for (a = 0; a < t_width; a++)
 553         {
 554             if (t_depth <= 8)
 555             {
 556                 lo = (t_bitmap[i * t_width + a] & 0x00ff);
 557                 fwrite(&lo, 1, 1, f);
 558             }
 559             else
 560             {
 561                 lo = (t_bitmap[i * t_width + a] & 0x00ff);
 562                 hi = (t_bitmap[i * t_width + a] & 0xff00) >> 8;
 563                 fwrite(&lo, 1, 1, f);
 564                 fwrite(&hi, 1, 1, f);
 565             }
 566         }
 567     }
 568 }
 569
 570 /****************************************************************************
 571  * generate_ascii()
 572  *
 573  * Outputs an ascii picture of the bitmap
 574  ****************************************************************************/
 575
 576 void generate_ascii(int width, int height, struct RGBQUAD *bitmap)
 577 {
 578     FILE *f;
 579     int x, y;
 580
 581     f = stdout;
 582
 583     /* for screen output debugging */
 584     for (y = 0; y < height; y++)
 585     {
 586         for (x = 0; x < width; x++)
 587         {
 588             fprintf(f, (brightness(bitmap[y * width + x]) & 0x80) ? " " : "*");
 589         }
 590         fprintf(f, "\n");
 591     }
 592 }
 593
 594 void print_usage(void)
 595 {
 596     printf("Usage: %s [-i <id>] [-a] <bitmap file>\n"
 597            "\t-i <id>  Bitmap name (default is filename without extension)\n"
 598            "\t-h <dir> Create header file in <dir>/<id>.h\n"
 599            "\t-a       Show ascii picture of bitmap\n"
 600            "\t-b       Create bitmap struct along with pixel array\n"
 601            "\t-r       Generate RAW file (little-endian)\n"
 602            "\t-f <n>   Generate destination format n, default = 0\n"
 603            "\t         0  Archos recorder, Ondio, Iriver H1x0 mono\n"
 604            , APPLICATION_NAME);
 605     printf("\t         1  Archos player graphics library\n"
 606            "\t         2  Iriver H1x0 4-grey\n"
 607            "\t         3  Canonical 8-bit greyscale\n"
 608            "\t         4  16-bit packed 5-6-5 RGB (iriver H300)\n"
 609            "\t         5  16-bit packed and byte-swapped 5-6-5 RGB (iPod, Fuzev2)\n"
 610            "\t         6  Greyscale iPod 4-grey\n"
 611            "\t         7  Greyscale X5 remote 4-grey\n"
 612            "\t         8  16-bit packed 5-6-5 RGB with a vertical stride\n");
 613     printf("build date: " __DATE__ "\n\n");
 614 }
 615
 616 int main(int argc, char **argv)
 617 {
 618     char *bmp_filename = NULL;
 619     char *id = NULL;
 620     char* header_dir = NULL;
 621     int i;
 622     int ascii = false;
 623     int format = 0;
 624     struct RGBQUAD *bitmap = NULL;
 625     unsigned short *t_bitmap = NULL;
 626     int width, height;
 627     int t_width, t_height, t_depth;
 628     bool raw = false;
 629     bool create_bm = false;
 630
 631
 632     for (i = 1;i < argc;i++)
 633     {
 634         if (argv[i][0] == '-')
 635         {
 636             switch (argv[i][1])
 637             {
 638               case 'h':   /* .h filename */
 639                 if (argv[i][2])
 640                 {
 641                     header_dir = &argv[i][2];
 642                 }
 643                 else if (argc > i+1)
 644                 {
 645                     header_dir = argv[i+1];
 646                     i++;
 647                 }
 648                 else
 649                 {
 650                     print_usage();
 651                     exit(1);
 652                 }
 653                 break;
 654
 655               case 'i':   /* ID */
 656                 if (argv[i][2])
 657                 {
 658                     id = &argv[i][2];
 659                 }
 660                 else if (argc > i+1)
 661                 {
 662                     id = argv[i+1];
 663                     i++;
 664                 }
 665                 else
 666                 {
 667                     print_usage();
 668                     exit(1);
 669                 }
 670                 break;
 671
 672               case 'a':   /* Ascii art */
 673                 ascii = true;
 674                 break;
 675
 676               case 'b':
 677                 create_bm = true;
 678                 break;
 679
 680               case 'r':   /* Raw File */
 681                 raw = true;
 682                 break;
 683
 684               case 'f':
 685                 if (argv[i][2])
 686                 {
 687                     format = atoi(&argv[i][2]);
 688                 }
 689                 else if (argc > i+1)
 690                 {
 691                     format = atoi(argv[i+1]);
 692                     i++;
 693                 }
 694                 else
 695                 {
 696                     print_usage();
 697                     exit(1);
 698                 }
 699                 break;
 700
 701               default:
 702                 print_usage();
 703                 exit(1);
 704                 break;
 705             }
 706         }
 707         else
 708         {
 709             if (!bmp_filename)
 710             {
 711                 bmp_filename = argv[i];
 712             }
 713             else
 714             {
 715                 print_usage();
 716                 exit(1);
 717             }
 718         }
 719     }
 720
 721     if (!bmp_filename)
 722     {
 723         print_usage();
 724         exit(1);
 725     }
 726
 727     if (!id)
 728     {
 729         char *ptr=strrchr(bmp_filename, '/');
 730         if (ptr)
 731             ptr++;
 732         else
 733             ptr = bmp_filename;
 734         id = strdup(ptr);
 735         for (i = 0; id[i]; i++)
 736             if (id[i] == '.')
 737                 id[i] = '\0';
 738     }
 739
 740     if (read_bmp_file(bmp_filename, &width, &height, &bitmap))
 741         exit(1);
 742
 743
 744     if (ascii)
 745     {
 746         generate_ascii(width, height, bitmap);
 747     }
 748     else
 749     {
 750         if (transform_bitmap(bitmap, width, height, format, &t_bitmap,
 751                              &t_width, &t_height, &t_depth))
 752             exit(1);
 753         if(raw)
 754             generate_raw_file(t_bitmap, t_width, t_height, t_depth);
 755         else
 756             generate_c_source(id, header_dir, width, height, t_bitmap,
 757                               t_width, t_height, t_depth,
 758                               format <= 1, create_bm);
 759     }
 760
 761     return 0;
 762 }