#include <stdio.h>    /* width_exc.c */

int main(void)
{
  unsigned int a, b, c, d, e, f, g, i, start, end;
  start = 400;
  end   = 390;
  printf("\n\
\"Exercise for the student:  suppose it had a width of 399 pixels,\n\
how many padding bytes would be required for each row?\n\
How about 398? 397? 396?\" \n");

  printf("\n...so if we have a 24-bit .bmp which is 3 bytes per pixel.... \n");

  printf("\niheader.width  The math:       Tbytes                   Padding bytes needed\n");
  for(i = start; i > end; i--)
  {
    a = i * 3;  /* total bytes                                            */
    b = a % 4;  /* remainder after dividing by block-size                 */
    c = 4 - b;  /* the amount needed to bring up to full 1 block-size (4) */
    d = c % 4;  /* get rid of that 4 for widths which already fit correctly */
    e = (4-((i * 3)%4))%4 ;  /* seems like this can be shortened but I suffer from algeblock */
    printf(" %10u  (4 - ( (%u * 3 = %u) %% 4 = %u) = %u) %%4 =    %u \n", i, i, a, b, c, e );
  }
  printf("\n\
...but I guess we would actually do it like this leaving out the last %%4 :\n\n\
iheader.width   Padding bytes needed   pixel data eol (in bytes) \n");
  for(i = start; i > end; i--)
  {
    e = 0;
    if(i % 4 != 0)
    {
      e = (4-((i * 3)%4));
    }
    f = (i * 3);
    g = f + e;
    printf(" %12u     %u                    (%u * 3 = %u) + %u = %u \n", i, e, i, f, e, g );
  }

  return 0;
}

    if ((iheader.height != 512) || (iheader.width != 512) || (iheader.bits != 24)) {
        printf("This only works for 512x512 24-color bitmaps\n");
        return 0;
    }

    ibyteswidth    = ceil(width * bitsperpixel/8.0);

    extrabytes     = (4 - ((ibyteswidth)%4)) % 4;

/*
 * You can change the "#if 0" to #if 1" if your compiler
 * has <stdint.h>
 */
#if 0
#include <stdint.h>
#else
typedef unsigned int uint32_t;
typedef          int int32_t;
typedef unsigned short uint16_t;
#endif

#include <stdio.h>
#include <stdlib.h>     /* for calloc and free */

/* If you do NOT have <stdint.h> use #if 0 for the defined data sizes.
   If you DO     have <stdint.h> use #if 1
   mingw and dmc both have the definitions and don't need either!
   but niether complains about an #include <stdin.h> so #if 1  is OK*/
#if 1
#include <stdint.h>
#else
typedef unsigned int uint32_t;
typedef          int int32_t;
typedef unsigned short uint16_t;
#endif

#include "bmp_headers.h"


void PAUSE(void){int cc=0; while( cc != EOF && cc != '\n') cc = getc(stdin);}

int main(int argc , char *argv[])
{
  FILE *fp1, *fp2, *fp3;
  uint8_t   r, g, b, gray, *pdat_in, *pdat_out;
  uint32_t  i, j, ibytewidth, padding, lbytewidth;
  char str        [20] ={0};
  char fname_out  [20] ={0};
  char fname_out2 [20] ={0};

  BmpFileHeader fheader;
  BmpInfoHeader iheader;

  /* printf("\n  %d \n  %s \n  %s \n", argc, argv[0], argv[1] ); */
  /*** this is kinda fancy but what the heck: ***/
  if(argc < 2)
  {
    for(i = j = 0; j < 20; i++, j++)
    {
      /* printf("%u %u, ", i, j );   for debug */
      if(argv[0][i] == '\\')
      {
        j = 0 - 1;  /* set 1 under, the next increment brings it to 0 */
      }             /* done like this because j is unsigned           */
      else
      {
        if(argv[0][i] == 0)
        {
          break;
        }
        str[j] = argv[0][i];
      }
    }
    str[j] = 0;
    printf("\n  !!! ERROR !!! Must include file !!! Usage: %s filename.bmp \n\n", str);
    return 1;
  }

  if( (fp1 = fopen(argv[1], "rb")) == NULL)
  {
    printf("input file %s failed to open , is it there?", argv[1]);
    return 1;
  };

  /*** make a new output filename out of the old one: ***/
  /* STEP1) get filename without the extension  */
  for(i = 0; i < 10; i++)
  {
    if(argv[1][i] == '.')
    {
      break;
    }
    str[i] = argv[1][i];
  }
  str[i] = 0;
  /* STEP2)  combine it with with a suffix (including the extension) */
  sprintf(fname_out, "%s_out.bmp", str);

  printf(">%s< \n", fname_out);
  /*** done ***/

  if( (fp2 = fopen(fname_out, "wb")) == NULL)
  {
    printf("!!! failed to open %s for output !!! , exiting...", fname_out);
    return 1;
  };

  /* read the file header into the structures */
  fread(&fheader, sizeof(fheader), 1, fp1 );
  fread(&iheader, sizeof(iheader), 1, fp1 );

  /* might as well write the header info into the output file now */
  fwrite(&fheader, sizeof(fheader), 1, fp2 );
  fwrite(&iheader, sizeof(iheader), 1, fp2 );

  printf("  This program reads a 24 bit color .bmp file of ?any? size, manipulates\n  that information , and writes 2 slightly different files in grayscale.\n");
  printf("\n           fheader.type: %04x    %d bytes\n", fheader.type,            sizeof(fheader.type) );
  printf("           fheader.size: %-6u  %d bytes  \n", fheader.size,            sizeof(fheader.size) );
  printf("      fheader.reserved1: %-6u  %d bytes  \n", (int)fheader.reserved1,  sizeof(fheader.reserved1) );
  printf("      fheader.reserved2: %-6u  %d bytes  \n", (int)fheader.reserved2,  sizeof(fheader.reserved2) );
  printf("         fheader.offset: %-6u  %d bytes  \n", fheader.offset,          sizeof(fheader.offset) );
  printf("           iheader.size: %-6u  %d bytes  \n", iheader.size,            sizeof(iheader.size) );
  printf("          iheader.width: %-6u  %d bytes  \n", iheader.width,           sizeof(iheader.width) );
  printf("         iheader.height: %-6u  %d bytes  \n", iheader.height,          sizeof(iheader.height) );
  printf("         iheader.planes: %-6u  %d bytes  \n", (int)iheader.planes,     sizeof(iheader.planes) );
  printf("           iheader.bits: %-6u  %d bytes  \n", (int)iheader.bits,       sizeof(iheader.bits) );
  printf("    iheader.compression: %-6u  %d bytes  \n", iheader.compression,     sizeof(iheader.compression) );
  printf("      iheader.imagesize: %-6u  %d bytes  \n", iheader.imagesize,       sizeof(iheader.imagesize) );
  printf("    iheader.xresolution: %-6u  %d bytes  \n", iheader.xresolution,     sizeof(iheader.xresolution) );
  printf("    iheader.yresolution: %-6u  %d bytes  \n", iheader.yresolution,     sizeof(iheader.yresolution) );
  printf("        iheader.ncolors: %-6u  %d bytes  \n", iheader.ncolors,         sizeof(iheader.ncolors) );
  printf("iheader.importantcolors: %-6u  %d bytes  \n", iheader.importantcolors, sizeof(iheader.importantcolors) );

  if(fheader.type != 0x4d42)
  {
    printf("Cannot read file properly.  The format is not  .bmp... \n");
  }
  /*
  if ((iheader.height != 512) || (iheader.width != 512) || (iheader.bits != 24))
  {
    printf("This only works for 512x512 24-color bitmaps\n");
    return 0;
  }
  */
  if ( iheader.bits != 24 )
  {
    printf("This only works for 24-color bitmaps\n");
    return 0;
  }
  if (fheader.offset != 54)
  {
    printf("This only works if the offset is equal to 54\n");
    return 0;
  }
  if ((iheader.imagesize %4 != 0))
  {
    printf("Imagesize is wrong \n");
    return 0;
  }
  /*** this section computes the line padding (if any is needed) and adds that
       to the image bytewidth to come up with an accurate eol value      ***/
  padding = 0;
  ibytewidth = (iheader.width * 3);

  if((ibytewidth % 4) != 0 )
  {
    padding = (4-(ibytewidth % 4)) ;
    printf("\npadding width with %u bytes\n", padding );
  }
  lbytewidth = ibytewidth + padding;
  /****
    ...but after seeing that iheader.imagesize is always correct,
    I am confident that I could just do this:
  lbytewidth = (iheader.imagesize / iheader.height);

    With a valid .bmp file this SHOULD always divide evenly
    and that result SHOULD divide evenly by 4 (bytes). Right???
    So now I know that I can use iheader.imagesize for calloc() ...duh
    It turns out that lbytewidth is not needed at all for this program,
    but it could come in handy for a future program which might alter the
    image size and would need to recalculate header size values.
    So I leave it for observation and future reference                     */

  printf("\niheader.width= %u    ibytewidth= %u    padding= %u   lbytewidth= %u\n", iheader.width, ibytewidth, padding, lbytewidth);

  /*  For reference from:  ucsd.edu/c/stdlib.html

  void *calloc(size_t nelem, size_t size);
  The function allocates an array object containing:
  nelem elements each of size size,
  stores zeros in all bytes of the array,
  and returns the address of the first element of the array if successful;
  otherwise, it returns a null pointer.
  You can safely convert the return value to an object pointer of any type
  whose size in bytes is not greater than size.
  */

  pdat_in  = calloc( (iheader.imagesize) + 1 , sizeof(uint8_t) );
  pdat_out = calloc( (iheader.imagesize) + 1 , sizeof(uint8_t) );

  /* I was getting a segfault for a file saved at 458x457 (padding=2)
     until I added the    + 1 here.  The segfault would occur at free(pdat_out);.
     I guess because at that point the OS noticed I was outa-bounds.
     I tested some other sizes but couldn't get it to re-occur.
     The following test results used a height of 457:
  wid  pad  result      wid  pad  result      wid  pad  result
  456  0    ok          524  0    ok          556  0    ok
  457  1    ok          525  1    ok          557  1    ok
  458  2    segfault    526  2    ok          558  2    ok
  459  3    ok          527  3    ok          559  3    ok
  460  0    ok          528  0    ok          560  0    ok
    If I change height to 458  width=458 works ok...
    hmm, I happened to hit a wierd one? I guess there's no harm in allocating
    an extra byte, but I still wonder why that one would fail...
    OR should they ALL have failed but slipped by!
    I think all the sizes look like they should work without the +1....
  */

  printf("\n(iheader.height * ibytewidth)= %u \n", (iheader.height * ibytewidth) );
  printf("\n(iheader.height * lbytewidth) = %u ...same as imagesize \n", (iheader.height * lbytewidth) );

  fseek(fp1, (long)fheader.offset, 0);   /* ensure fp is at right place */

  /***** ok here we go:
    step1) setup the big loop
    step2) get 3 bytes form infile and store in r,g,and b (fp automatically increments itself)
    step3) average the values stored r, g and b and store that in 'gray'
    step4) put the value of gray into 3 successive bytes of the outfile
    step4) loop ends and we go look at the gray picture,,, it works well!
  ***** /
  for(i = 0, j = 0; i < iheader.imagesize; i+=3)
  {
    r = getc(fp1);
    g = getc(fp1);
    b = getc(fp1);
    gray = (r+g+b)/3;
    putc(gray, fp2);
    putc(gray, fp2);
    putc(gray, fp2);
  }
  *** ok that was easy enough and it works goodly, but what about the unused arrays! */
  for(i = 0, j = 0; i < iheader.imagesize; )
  {
    r = getc(fp1);
    g = getc(fp1);
    b = getc(fp1);
    pdat_in[i++] = r;
    pdat_in[i++] = g;
    pdat_in[i++] = b;
    gray = (r+g+b)/3;
    putc(gray, fp2);
    putc(gray, fp2);
    putc(gray, fp2);

    /*** Play around with values a little and note the effect */
    if(gray > 20)      /* prevent from going past 0 to the Fx range */
    {
      gray -= 20;      /* darkens */
    }
    else
    {
      gray = 0;        /* maximum darkness (black) */
    }
    /*** Put the altered values into the 'out' array which goes to file2 */
    pdat_out[j++] = gray;
    pdat_out[j++] = gray;
    pdat_out[j++] = gray;

    /* This was for testing but I'll just leave it for some exitement! */
    if( (j % 10000) == 0 )
    {
      printf("%u ", i);
      /* printf("i= %u    j= %u    \n", i, j); */
    }
  }
  fclose(fp1);
  fclose(fp2);

  printf("\n  i= %u    j= %u  ...loop done.\n  pdat_in and pdat_out filled.  %s written  \n", i, j, fname_out);

  /* ok so we have it in the array, now I'll open another outfile: */
  sprintf(fname_out2, "%s_out2.bmp", str);      /* str is still as above */
  if( (fp3 = fopen(fname_out2, "wb")) == NULL )
  {
    printf("\n!!! failed to open %s for output !!! , exiting...", fname_out2);
    return 1;
  }
  else
  {
    printf("\nBegin writing pdat_out data to %s: \n", fname_out2);
  }
  /* And I'll just write the header and image as blocks...   */
  if(! fwrite(&fheader, sizeof(fheader), 1, fp3 ) )
  {
    printf("writing pdat_out fheader data to %s failed , exiting \n", fname_out2);
    return 1;
  }
  else
  {
    printf("pdat_out fheader data written to %s \n", fname_out2 );
  }

  if(! fwrite(&iheader, sizeof(iheader), 1, fp3 ) )
  {
    printf("writing pdat_out iheader data to %s failed , exiting\n", fname_out2);
    return 1;
  }
  else
  {
    printf("pdat_out iheader data written to %s \n", fname_out2 );
  }

  if(! fwrite(pdat_out, iheader.imagesize, 1, fp3 ) )
  {
    printf("writing pdat_out iheader data to %s failed , exiting\n", fname_out2);
    return 1;
  }
  else
  {
    printf("pdat_out   image data written to %s  \n", fname_out2 );
  }

  fclose(fp3);
  printf(" done with fp3\n");

  free(pdat_out);
  printf(" done with pdat_out\n");

  free(pdat_in);
  printf(" done with pdat_in\n");

  printf(" ...and we're done period. Sure is fast... \n");
  return 0;
}

/*  pretty cool...   */

  uint8_t   r, g, b...
.
.
.
    gray = (r+g+b)/3; /* overflow if r+g+b > 255 */
.
.
.

    r = (unsigned)getc(fp1); /* guard against sign extension for value > 128 */
    g = (unsigned)getc(fp1);
    b = (unsigned)getc(fp1);
    gray = (r+g+b)/3;

    grayvalue = (g + b + r)/3.0 + 0.5;

    for (row = 0; row < height; row++) { /* height from info_header */
        for (col = 0; col < width; col++) { /* width from info_header
.
.
.
            /* 
             * get g+b+r values (divided by 3) into a single byte, say graybyte.
             * Then
             */
            grayarray[row][col] = graybyte;
            for (i = 0; i < extrabytes; i++) {
                /* get padding byte from file and throw away */
            }
        }
    }

/* fixes to previous post */
/*... snip ...*/
  pdat_in  = calloc( (iheader.imagesize) , sizeof(uint8_t) );
  pdat_out = calloc( (iheader.imagesize) , sizeof(uint8_t) );
/*... snip ...*/
  isize = iheader.imagesize;       /* new! variable for shorter name */
  for(i = j = k = 0; i < isize;)
  {
    r = getc(fp1);
    g = getc(fp1);
    b = getc(fp1);
    pdat_in[i++] = r;
    if( i < isize)            /* new! */
      pdat_in[i++] = g;
    if( i < isize)            /* new! */
      pdat_in[i++] = b;
    gray = (r+g+b)/3;
    putc(gray, fp2);
    putc(gray, fp2);
    putc(gray, fp2);

    /*** Play around with values a little and note the effect */
    if(gray > 20)      /* prevent from going past 0 to the Fx range */
    {
      gray -= 20;      /* darkens */
    }
    else
    {
      gray = 0;        /* maximum darkness (black) */
    }
    /*** Put the altered values into the 'out' array which goes to file2 */
    if( j > (isize - 3)  printf("j= %u\n", i);  /* debug print */
    pdat_out[j++] = gray;
    if( j >= isize) break;          /* new! */

    if( j > (isize - 3)  printf("j= %u\n", i);  /* debug print */
    pdat_out[j++] = gray;
    if( j >= isize) break;          /* new! */

    if( j > (isize - 3)  printf("j= %u\n", i);  /* debug print */
    pdat_out[j++] = gray;
    if( j >= isize) break;          /* new! */

    /* This was for testing but I'll just leave it for some exitement! */
    if( (j % 10000) == 0 )
    {
      printf("%u ", i);
      /* printf("i= %u    j= %u    \n", i, j); */
    }
  }
  fclose(fp1);
  fclose(fp2);

#ifndef BMP_HEADERS
#define BMP_HEADERS
/*
 * 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 {
	int ciexyzX;
	int ciexyzY;
	int ciexyzZ;
} CIEXYZ;// This is 12 bytes

typedef struct {
	CIEXYZ ciexyzRed;
	CIEXYZ ciexyzGreen;
	CIEXYZ ciexyzBlue;
} CIEXYZTRIPLE;// This is 36 bytes

typedef struct {
    unsigned short type;               /* Two chars "BM" in little-endian order  */
    unsigned int size;               /*unsigned int 4 bytes File size                              */
    unsigned short reserved1;          //unsigned short 2 bytes
	unsigned short reserved2;
    unsigned int offset;             /* Bytes from start of file to pixel data */
} BmpFileHeader;

typedef struct {
    unsigned int size;               /* Size of this header  (40 bytes)= DOWRD */
    int width;                       /* Bitmap width in pixels                 */
    int height;                      /* Bitmap height in pixels                */
    unsigned short planes;             /* Must be 1                              */
	unsigned short bits;               /* Bits per pixel. (8 for 256-color bmps) */

    unsigned int compression;        /* 0 means no compression                 */
    unsigned int imagesize;          /* Number of bytes in pixel data section  */
    int  xresolution;        /* Not used by any of my functions        */
    int  yresolution;        /* Not used by any of my functions        */

	
    unsigned int ncolors;            /* 0 means use all colors                 */
    unsigned int importantcolors;    /* 0 means all are important              */

	unsigned int redMask;
	unsigned int greenMask;
	unsigned int blueMask;
	unsigned int alphaMask;
	unsigned int CSType;
	CIEXYZTRIPLE endPoints;
	unsigned int gammaRed;
	unsigned int gammaGreen;
	unsigned int gammaBlue;
	unsigned int intent;
	unsigned int profileData;
	unsigned int profileSize;
	unsigned int Reserved;


} BmpInfoHeader;
#pragma pack(pop)



#endif

#pragma once
#ifndef BMP_H
#define BMP_H
#include "bmp_headers.h"
#include <iostream>

using namespace std;
class Bmp
{
public:
	Bmp(BmpFileHeader&,BmpInfoHeader&,int&,int&,unsigned short&);
 	Bmp(void);
	~Bmp(void);
	friend ostream& operator<<(ostream&,Bmp&);
	int getWidth();
	int getHeight();
	unsigned short getBpp();
	unsigned char* getArrayPtr();
	private :
	BmpFileHeader FH;
	BmpInfoHeader IH;
	unsigned char* imageArray;
};
#endif

#include "Bmp.h"


Bmp::Bmp(BmpFileHeader &myFH,BmpInfoHeader &myIH,int &width,int &height,unsigned short&bpp):FH(myFH),IH(myIH)
{
imageArray=new unsigned char[width,height,bpp/8];
}
Bmp::Bmp()
{}

Bmp::~Bmp(void)
{
}

ostream& operator <<(ostream& output,Bmp& arg)
	{
		

		return output<<hex<<"Bmp File Type is : "<<arg.FH.type<<endl
		<<dec<<"Bmp Size is :"<<arg.FH.size<<endl
		<<"Bmp Reserved one is :"<<arg.FH.reserved1<<endl
		<<"Bmp Reserved two is :"<<arg.FH.reserved1<<endl
		<<"Bmp Header Offset is :"<<arg.FH.offset/8<<endl//Offset in bytes meaning that after byte 134 the actual pixels can be found
		<<"Bmp Header Size is :"<<arg.IH.size<<endl
		<<"Image width is : "<<arg.IH.width<<endl
		<<"Image height is : "<<arg.IH.height<<endl
		<<"Image bpp is : "<<arg.IH.bits<<endl
		<<"Image compression is : "<<arg.IH.compression<<endl
		<<"Byts in pixel data section are : "<<arg.IH.imagesize<<endl;
	}
int Bmp::getHeight()
	{
	return IH.height;
	}
int Bmp::getWidth()
	{
	return IH.width;
	}
unsigned short Bmp::getBpp()
	{
	return IH.bits;
	}
unsigned char* Bmp::getArrayPtr()
	{
	return imageArray;
	}

#include <fstream>
#include <cstdlib>
#include "Bmp.h"

int main()
	{
	ifstream myBmpFile("test2.bmp",ios::in|ios::binary);
	if(!myBmpFile)
		{
		cerr<<"File Could not be Opened."<<endl;
		exit(1);
		}
	//Bmp myBmp;
	BmpFileHeader myFH;
	BmpInfoHeader myIH;
	myBmpFile.read(reinterpret_cast<char*>(&myFH),sizeof(myFH));
	myBmpFile.read(reinterpret_cast<char*>(&myIH),sizeof(myIH));

	Bmp myBmp(myFH,myIH,myIH.width,myIH.height,myIH.bits);
	
	cout<<"Size of File Header is : "<<sizeof(myFH)<<endl
		<<"Size of Info Header is : "<<sizeof(myIH)<<endl;
	long startLocation=myBmpFile.tellg();	
	if(startLocation!=138)
		{
		cout<<"The file is corrupted"<<endl;
		exit(1);
		}	
	cout<<endl<<myBmp<<endl;
	cout<<"File pointer at the beginning of storing to the 2Darray :"<<myBmpFile.tellg()<<endl;

	for(int i=0;i<myBmp.getHeight();++i)
		{
		for(int j=0;j<myBmp.getWidth();++j)
			{
			myBmpFile.read(reinterpret_cast<char*>(myBmp.getArrayPtr()),sizeof(unsigned char));
			}
		}
	long endLocation=myBmpFile.tellg();
	cout<<"File pointer at the end of storing to the 2Darray :"<<myBmpFile.tellg()<<endl
		<<"Total number of bytes read is : "<<endLocation-startLocation<<endl;
	



	
	while(1);
	return 0;
	}