Just recently we needed some embedded C code to decompress bitmap files (we use bitmaps in our Retinal camera to display icon-like images on the video screen for such applications as giving user-feedback). I include this code here not because it's anything fancy, but because I couldn't find any on the net. Much can be found on the bitmap format and windows applications that uses standard API to decompress, but nothing for embedded systems.

The bitmap format is used by image files using the .bmp extension. It was developed by Microsoft who uses bitmap images in the windows operating system for storing icons. The bitmap format uses the following structs in its header:

typedef struct                       /**** BMP file header structure ****/
    {
    unsigned short bfType;           /* Magic number for file */
    unsigned int   bfSize;           /* Size of file */
    unsigned short bfReserved1;      /* Reserved */
    unsigned short bfReserved2;      /* ... */
    unsigned int   bfOffBits;        /* Offset to bitmap data */
    } BITMAPFILEHEADER;

#  define BF_TYPE 0x4D42             /* "MB" */

typedef struct                       /**** BMP file info structure ****/
    {
    unsigned int   biSize;           /* Size of info header */
    int            biWidth;          /* Width of image */
    int            biHeight;         /* Height of image */
    unsigned short biPlanes;         /* Number of color planes */
    unsigned short biBitCount;       /* Number of bits per pixel */
    unsigned int   biCompression;    /* Type of compression to use */
    unsigned int   biSizeImage;      /* Size of image data */
    int            biXPelsPerMeter;  /* X pixels per meter */
    int            biYPelsPerMeter;  /* Y pixels per meter */
    unsigned int   biClrUsed;        /* Number of colors used */
    unsigned int   biClrImportant;   /* Number of important colors */
    } BITMAPINFOHEADER;

/*
 * Constants for the biCompression field...
 */

#  define BI_RGB       0             /* No compression - straight BGR data */
#  define BI_RLE8      1             /* 8-bit run-length compression */
#  define BI_RLE4      2             /* 4-bit run-length compression */
#  define BI_BITFIELDS 3             /* RGB bitmap with RGB masks */

typedef struct                       /**** Colormap entry structure ****/
    {
    unsigned char  rgbBlue;          /* Blue value */
    unsigned char  rgbGreen;         /* Green value */
    unsigned char  rgbRed;           /* Red value */
    unsigned char  rgbReserved;      /* Reserved */
    } RGBQUAD;

typedef struct                       /**** Bitmap information structure ****/
    {
    BITMAPINFOHEADER bmiHeader;      /* Image header */
    RGBQUAD          bmiColors[256]; /* Image colormap */
    } BITMAPINFO;		

And here is the code that displays both bitmap and compressed bitmap files. The type of compression used is 8 bit Run Length Encoding (RLE), in which essentially, recurring pixels are stored as a single pixel with a count value. The compression algorithm can be found here. Other information on bitmaps can be found on the same site.

// displays bitmap image top left corner at Xoff, Yoff
int BmpDisplay(const char *Image, int Xoff, int Yoff)
{
  unsigned char * ImageData;         // pointer to array keeping the binary bitmap data
  unsigned int Width;                // width of image
  unsigned int DisplayWidth;         // width of display
  unsigned int Height;               // height of image
  unsigned int Compression;          // stores value of compression                     
  int x,y;                           // coordinates
  
  BITMAPFILEHEADER * BMFH = (BITMAPFILEHEADER *) Image;
  BITMAPINFOHEADER * BMIH = (BITMAPINFOHEADER *) (Image + sizeof(BITMAPFILEHEADER));
  if(8 != SwapBytesShort(BMIH->biBitCount))
  {
    OutStr("biBitCount is %d, should be 8 !!!",SwapBytesShort(BMIH->biBitCount));
    return ERR_BITCOUNT_NOT_8;
  }
  
  // calculate offset to 1st byte of image
  ImageData = (unsigned char *)(Image + SwapBytesInt(BMFH->bfOffBits));  
  DisplayWidth = Width  = SwapBytesInt(BMIH->biWidth);
  Compression = SwapBytesInt(BMIH->biCompression); 
  if (0 != Width & 0x03)
  {
    Width &= ~0x03;
    Width+=4;
  }
  Height = SwapBytesInt(BMIH->biHeight);

  // No compression
  if(0 == Compression)                             
  {
    for(y=Height-1;y>=0;y--)
    {
       for(x=0;x<Width;x++)
       {
         if(x<DisplayWidth)
           plot_pixel(x+Xoff,y+Yoff,*ImageData);
         ImageData++;
       }
    }
  }

  // Bitmap is 8-bit RLE compressed
  else if (1 == Compression)                    
  {
    unsigned char firstByte, secondByte;
    unsigned int currX, currY, i, state;

    currX = Xoff;
    currY = Yoff;
    state = 0;

    while(state == 0)
    {
      firstByte = *ImageData;
      ImageData++;
      if(0 != firstByte)
      {
        secondByte =*ImageData;
        for(i=0; i < firstByte; i++)
        {
          plot_pixel(currX, currY, secondByte);
          currX++;
        }
        ImageData++;
      }
      else   // value is zero
      {
        firstByte = *ImageData;            // store next byte
        ImageData++;
        switch (firstByte)
        {
          case 0:
            currX = Xoff;
            currY++;                       // move cursor to beginning of next line
            break;
          case 1:
            state = ERR_NONE;
            return ERR_NONE;               // end of bitmap, finish plotting
          case 2:
            currX += (int)(*ImageData);    // read byte and add value to x value
            ImageData++;
            currY += (int)(*ImageData);    // read byte and add value to y value
            ImageData++;
            break;
          // for any other value, print the next firstByte bytes
          default:                         
            for(i = 0; i < firstByte; i++)
            {
              secondByte = *ImageData;
              plot_pixel(currX, currY, secondByte);
              ImageData++;
              currX++;
            }
            if(0 != firstByte & 0x01)      // if the run doesn't end on a word boundary, 
              ImageData++;                 // advance the pointer
          } // END switch
        } // END else
      } // END while
    } // END else(if 1 == compression)

  else
  {
     return ERR_COMPRESSION_NOT_SUPPORTED;
  }

  return ERR_NONE;
}