/* 
 * bmp_headers.h
 */
#ifndef BMP_HEADERS_H__
#define BMP_HEADERS_H__
/*
 * Tested with little-endian machines and "normal"
 * little-endian bmp files.
*/

#include <stdint.h>

/*
 * I have found that the following pragma is necessary to ensure
 * the correct size of the structs.
 *
 * In the file, the BmpFileHeader struct is 14 bytes long and
 * the BmpInfoHeader is 40 bytes long
 *
 * Works for GNU, Borland bcc32, Microsoft VC++
 *
 * davekw7x
 */
/* Note that all 'standard' bitmap files are little-endian
 * If your architecture is little-endian, then you can
 * read the first 54 bytes of the file directly into the
 * following two structs.
 */ 

#pragma pack(push, 1)
typedef struct {
    uint16_t type;               /* Two chars "BM" in little-endian order  */
    uint32_t size;               /* File size                              */
    uint16_t reserved1;
    uint16_t reserved2;
    uint32_t offset;             /* Bytes from start of file to pixel data */
} BmpFileHeader;

typedef struct {
    uint32_t size;               /* Size of this header  (40 bytes)        */
    int32_t  width;              /* Bitmap width in pixels                 */
    int32_t  height;             /* Bitmap height in pixels                */
    uint16_t planes;             /* Must be 1                              */
    uint16_t bits;               /* Bits per pixel. (8 for 256-color bmps) */
    uint32_t compression;        /* 0 means no compression                 */
    uint32_t imagesize;          /* Number of bytes in pixel data section  */
    int32_t  xresolution;        /* Not used by any of my functions        */
    int32_t  yresolution;        /* Not used by any of my functions        */

    uint32_t ncolors;            /* 0 means use all colors                 */
    uint32_t importantcolors;    /* 0 means all are important              */
} BmpInfoHeader;
#pragma pack(pop)

#endif

/*
 * test_bmp_headers.c
 *
 * Tests size of bitmap headers
 *
 * Run this before writing any program that uses bmp_headers.h
 *
 */
#include <stdio.h>
#include <assert.h>
#include "bmp_headers.h"
int main()
{
    printf("sizeof(BmpFileHeader) = %d\n", sizeof(BmpFileHeader));
    printf("sizeof(BmpInfoHeader) = %d\n", sizeof(BmpInfoHeader));
    assert(sizeof(BmpFileHeader) == 14);
    assert(sizeof(BmpInfoHeader) == 40);
    return 0;
}

#include <stdio.h>

int main(void)
{
  unsigned int i, j, endline, startpix, maxread = 200;
  char filename[] = "exp2.bmp\0\0\0\0\0\0\0\0\0\0\0\0";
  unsigned char cdat[1000];
  FILE *fp;

  if( (fp = fopen(filename, "r")) == NULL)
  {
    printf("%s failed to open, is it there?", filename);
    return 1;
  }
  printf("\n      File \"%s\" opened for reading: \n\n", filename);
  printf(" hex   0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f \n0000  ");
  for(i=j=0 , endline = 0x10, startpix = 40; i < maxread; i++, j++)
  {
    cdat[i] = getc(fp);
    if(i == 0x0a)
    {
      startpix = cdat[i];   /* risky... will only get the value of that one byte */
    }
    if(i == startpix)
    {
      printf("\n\n  End header;  Begin pixels;  Bottom line first;  Left to Right: \n\n%04x  ", i);
      endline = 24;
      j = 0;
    }
    if(j % endline == 0)
      if(j > 0)
      {
        printf("\n%04x  ", i);
      }
    printf("%02x ", cdat[i]);
  }
  fclose(fp);
  printf("\n    Reading intentionally stopped here at %u bytes. \n ", maxread);
  return 0;
}

#include <stdio.h>
#include "bmp_headers.h"

int main(void)
{
  FILE *fp;
  char *cptr;
  unsigned char c;
  unsigned int i, j, linect, endline, pixwidth;
  char filename[] = "exp2.bmp\0\0\0\0\0\0\0\0\0\0\0\0";

  BmpFileHeader fheader;
  BmpInfoHeader iheader;

  printf("sizeof: fheader: %d   iheader: %d \n", sizeof(fheader), sizeof(iheader) );
  /* looks good  14 and 40*/

  if( (fp = fopen(filename, "r")) == NULL)
  {
    printf("%s failed to open, is it there?", filename);
    return 1;
  };
  fread(&fheader, sizeof(fheader), 1, fp );
  fread(&iheader, sizeof(iheader), 1, fp );
  cptr = (void*)&fheader;
  cptr++;
  printf("           fheader.type= %c%c \n", fheader.type, *cptr );
  printf("           fheader.size= %u   \n", fheader.size );
  printf("      fheader.reserved1= %u   \n", (int)fheader.reserved1 );
  printf("      fheader.reserved2= %u   \n", (int)fheader.reserved2 );
  printf("         fheader.offset= %u   \n", fheader.offset );
  printf("           iheader.size= %u   \n", iheader.size );
  printf("          iheader.width= %u   \n", iheader.width );
  printf("         iheader.height= %u   \n", iheader.height );
  printf("         iheader.planes= %u   \n", (int)iheader.planes );
  printf("           iheader.bits= %u   \n", (int)iheader.bits );
  printf("    iheader.compression= %u   \n", iheader.compression );
  printf("      iheader.imagesize= %u   \n", iheader.imagesize );
  printf("    iheader.xresolution= %u   \n", iheader.xresolution );
  printf("    iheader.yresolution= %u   \n", iheader.yresolution );
  printf("        iheader.ncolors= %u   \n", iheader.ncolors );
  printf("iheader.importantcolors= %u   \n", iheader.importantcolors );

  fseek(fp, (long)fheader.offset, 0);   /* ensure fp is at right place */
  linect = 0;
  endline = 30;
  pixwidth = (iheader.bits / 8);
  for(i = 0 ; i < 5000; i++)
  {
    if(i % endline == 0)
    {
      if( (++linect % 25) == 0)
      {  getchar();
      }
      printf("\n%04x  ", i);
      j = 0;
    }
    if( (i % 3) == 0 && j++ > 0)
    {
      putchar(0x20);
    }
    c = getc(fp);
    printf("%02x", c );
  }

  fclose(fp);

  return 0;
}

  printf("           fheader.type= 0x%04x \n", fheader.type);

/* in bmp_headers.h */
#define BMP_MAGIC 0x4d42

/* in the program */
    if (fheader.type != BMP_MAGIC) {
        printf("Magic number is 0x%04x. Bit map file must have 0x%04x\n",
              fheader.type, BMP_MAGIC);
        /* some error stuff here. Maybe  exit(EXIT_FAILURE); */
    }

typedef struct RGB
{
  uint8_t blue;
  uint8_ green;
  uint8_t red;
} RGB;