path: root/tools/bmp2rb.c

/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id$
 *
 * Copyright (C) 2002 by Linus Nielsen Feltzing
 *
 * All files in this archive are subject to the GNU General Public License.
 * See the file COPYING in the source tree root for full license agreement.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/
/*********************************************************************
 *
 * Converts BMP files to Rockbox bitmap format
 *
 * 1999-05-03 Linus Nielsen Feltzing
 *
 **********************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define debugf printf

#ifdef __GNUC__
#define STRUCT_PACKED __attribute__((packed))
#else
#define STRUCT_PACKED
#pragma pack (push, 2)
#endif

struct Fileheader
{
  unsigned short Type;          /* signature - 'BM' */
  unsigned  long Size;          /* file size in bytes */
  unsigned short Reserved1;     /* 0 */
  unsigned short Reserved2;     /* 0 */
  unsigned long  OffBits;       /* offset to bitmap */
  unsigned long  StructSize;    /* size of this struct (40) */
  unsigned long  Width;         /* bmap width in pixels */
  unsigned long  Height;        /* bmap height in pixels */
  unsigned short Planes;        /* num planes - always 1 */
  unsigned short BitCount;      /* bits per pixel */
  unsigned long  Compression;   /* compression flag */
  unsigned long  SizeImage;     /* image size in bytes */
  long           XPelsPerMeter; /* horz resolution */
  long           YPelsPerMeter; /* vert resolution */
  unsigned long  ClrUsed;       /* 0 -> color table size */
  unsigned long  ClrImportant;  /* important color count */
} STRUCT_PACKED;

struct RGBQUAD
{
  unsigned char rgbBlue;
  unsigned char rgbGreen;
  unsigned char rgbRed;
  unsigned char rgbReserved;
} STRUCT_PACKED;


short readshort(void* value)
{
    unsigned char* bytes = (unsigned char*) value;
    return bytes[0] | (bytes[1] << 8);
}

int readlong(void* value)
{
    unsigned char* bytes = (unsigned char*) value;
    return bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24);
}

/*********************************************************************
 * read_bmp_file()
 *
 * Reads a 8bit BMP file and puts the data in a 1-pixel-per-byte
 * array. Returns 0 on success.
 *
 *********************************************************************/
int read_bmp_file(char* filename,
                  int *get_width,  /* in pixels */
                  int *get_height, /* in pixels */
                  char **bitmap)
{
    struct Fileheader fh;
    struct RGBQUAD palette[2]; /* two colors only */

    unsigned int bitmap_width, bitmap_height;

    long PaddedWidth;
    int background;
    int fd = open(filename, O_RDONLY);
    long size;
    unsigned int row, col;
    int l;
    unsigned char *bmp;
    int width;
    int depth;

    if(fd == -1)
    {
        debugf("error - can't open '%s'\n", filename);
        return 1;
    }
    else
   {
     if(read(fd, &fh, sizeof(struct Fileheader)) !=
        sizeof(struct Fileheader))
     {
         debugf("error - can't Read Fileheader Stucture\n");
         close(fd);
         return 2;
     }

     /* Exit if more than 8 bits */
     depth = readshort(&fh.BitCount);
     if(depth > 8)
     {
         debugf("error - Bitmap uses more than 8 bit depth, got %d\n",
                depth);
         close(fd);
         return 2;
     }

     /* Exit if too wide */
     if(readlong(&fh.Width) > 112)
     {
         debugf("error - Bitmap is too wide (%d pixels, max is 112)\n",
                readlong(&fh.Width));
         close(fd);
         return 3;
     }

     /* Exit if too high */
     if(readlong(&fh.Height) > 64)
     {
         debugf("error - Bitmap is too high (%d pixels, max is 64)\n",
                readlong(&fh.Height));
         close(fd);
         return 4;
     }
     
     for(l=0;l < 2;l++)
     {
         if(read(fd, &palette[l],sizeof(struct RGBQUAD)) !=
            sizeof(struct RGBQUAD))
         {
             debugf("error - Can't read bitmap's color palette\n");
             close(fd);
             return 5;
         }
     }
     if(depth == 8 ) {
         /* pass the other palettes */
         lseek(fd, 254*sizeof(struct RGBQUAD), SEEK_CUR);
     }

     /* Try to guess the foreground and background colors.
        We assume that the foreground color is the darkest. */
     if(((int)palette[0].rgbRed +
         (int)palette[0].rgbGreen +
         (int)palette[0].rgbBlue) >
        ((int)palette[1].rgbRed +
         (int)palette[1].rgbGreen +
         (int)palette[1].rgbBlue))
     {
         background = 0;
     }
     else
     {
         background = 1;
     }

      width = readlong(&fh.Width);

      if(depth == 8)
          PaddedWidth = ((width+3)&(~0x3)); /* aligned 4-bytes boundaries */
      else
          PaddedWidth = ((width+31)&(~0x1f))/8;

      size = PaddedWidth*readlong(&fh.Height);

      bmp = (unsigned char *)malloc(size);
      *bitmap = (unsigned char *)malloc(size);

      if(bmp == NULL)
      {
          debugf("error - Out of memory\n");
          close(fd);
          return 6;
      }
      else
      {
          if(read(fd, (unsigned char*)bmp,(long)size) != size) {
              debugf("error - Can't read image\n");
              close(fd);
              return 7;
          }
      }

      bitmap_height = readlong(&fh.Height);
      bitmap_width = readlong(&fh.Width);

      *get_width = bitmap_width;
      *get_height = bitmap_height;

      if(depth == 8)
      {
          /* Now convert the bitmap into an array with 1 byte per pixel,
             exactly the size of the image */
          for(row = 0;row < bitmap_height;row++) {
              for(col = 0;col < bitmap_width;col++) {
                  if(bmp[(bitmap_height-1 -row) * PaddedWidth + col]) {
                      (*bitmap)[ (row/8) * bitmap_width + col ] &=
                        ~ (1<<(row&7));
                  }
                  else {
                      (*bitmap)[ (row/8) * bitmap_width + col ] |=
                        1<<(row&7);
                  }
              }
          }
      }
      else
      {
          int bit;
          int byte;
          /* monocrome BMP conversion uses 8 pixels per byte */
          for(row = 0; row < bitmap_height; row++) {
              bit = 7;
              byte = 0;
              for(col = 0;col < bitmap_width;col++) {
                  if((bmp[(bitmap_height - row - 1) * PaddedWidth + byte] &
                      (1 << bit))) {
                      (*bitmap)[(row/8) * bitmap_width + col ] &=
                        ~(1<<(row&7));
                  }
                  else {
                      (*bitmap)[(row/8) * bitmap_width + col ] |= 
                        1<<(row&7);
                  }
                  if(bit) {
                      bit--;
                  }
                  else {
                      bit = 7;
                      byte++;
                  }
              }
          }
      }

      free(bmp);

   }
   close(fd);
   return 0; /* success */
}

/*********************************************************************
** generate_c_source()
**
** Outputs a C source code with the bitmap in an array, accompanied by
** some #define's
**********************************************************************/
void generate_c_source(char *id, int width, int height, unsigned char *bitmap)
{
   FILE *f;
   unsigned int i, a, eline;

   f = stdout;

   if(!id || !id[0])
     id = "bitmap";

   fprintf(f,
           "#define BMPHEIGHT_%s %d"
           "\n#define BMPWIDTH_%s %d"
           "\nconst unsigned char %s[] = {\n",
           id, height, id, width, id );

   for(i=0, eline=0; i< height; i+=8, eline++) {
       for (a=0; a<width; a++)
           fprintf(f, "0x%02x,%c", bitmap[eline*width + a],
                   (a+1)%13?' ':'\n');
       fprintf(f, "\n");
   }
   

   fprintf(f, "\n};\n");
}


/*********************************************************************
** generate_ascii()
**
** Outputs an ascii picture of the bitmap
**********************************************************************/
void generate_ascii(int width, int height, unsigned char *bitmap)
{
    FILE *f;
    unsigned int i, eline;

    f = stdout;

    /* for screen output debugging */
    for(i=0, eline=0; i< height; i+=8, eline++) {
        unsigned int x, y;
        for(y=0; y<8 && (i+y < height); y++) {
            for(x=0; x < width; x++) {
                
                if(bitmap[eline*width + x] & (1<<y)) {
                    fprintf(f, "*");
                }
                else
                    fprintf(f, " ");
            }
            fprintf(f, "\n");
        }
    }
}

void print_usage(void)
{
   printf("Usage: %s [-i <id>] [-a] <bitmap file>\n"
          "\t-i <id>     Bitmap name (default is filename without extension)\n"
          "\t-a          Show ascii picture of bitmap\n",
          APPLICATION_NAME);
   printf("build date: " __DATE__ "\n\n");
}

int main(int argc, char **argv)
{
   char *bmp_filename = NULL;
   char *id = NULL;
   int i;
   int height, width;
   int ascii = false;
   char* bitmap = NULL;
   
      
   for(i = 1;i < argc;i++)
   {
      if(argv[i][0] == '-')
      {
	switch(argv[i][1])
	{
	case 'i':   /* ID */
	   if(argv[i][2])
	   {
	      id = &argv[i][2];
	   }
	   else if(argc > i+1)
	   {
	      id = argv[i+1];
	      i++;
	   }
	   else
	   {
	      print_usage();
	      exit(1);
	   }
	   break;

	case 'a':   /* Assembly */
	   ascii = true;
	   break;

	default:
	   print_usage();
	   exit(1);
	   break;
	}
      }
      else
      {
	if(!bmp_filename)
	{
	   bmp_filename = argv[i];
	}
	else
	{
	   print_usage();
	   exit(1);
	}
      }
   }

   if (!bmp_filename)
   {
      print_usage();
      exit(1);
   }

   if (!id)
   {
       char *ptr=strrchr(bmp_filename, '/');
       if(ptr)
           ptr++;
       else
           ptr = bmp_filename;
       id = strdup(ptr);
       for (i = 0; id[i]; i++)
           if (id[i] == '.')
               id[i] = '\0';
   }

   if (read_bmp_file(bmp_filename, &width, &height, &bitmap))
       return 0;
   
   if (ascii)
       generate_ascii(width, height, bitmap);
   else
       generate_c_source(id, width, height, bitmap);
   
   return 0;
}