/******************************************************************************/
/*                                                                            */
/* File: code.cpp                                                             */
/*                                                                            */
/* Simple png image file format dump program - dumps out the contents of a    */
/* png file to a text output file (output.txt) that you can then look at.     */
/* Only dumps the chunk sizes and ids, then goes on to dump more extended     */
/* information about the IDAT chunk which contains the actual image           */
/* image information                                                          */
/*                                                                            */
/* Quote: Anyone can code!                                                    */
/*                                                                            */
/******************************************************************************/

// Dump Contents of png image file

#include <string.h>        // memset(..)
#include <stdio.h>        // fopen, fread, sprintf etc
#include <stdarg.h>     // So we can use ... (in dprintf)
#include <stdlib.h>


#include "zlib.h"
#pragma comment(lib, "zdll.lib")


// Saving debug information to a txt file
void dprintf(const char *fmt, ...) 
{
    va_list parms;
    char buf[256];

    // Try to print in the allocated space.
    va_start(parms, fmt);
    vsprintf (buf, fmt, parms);
    va_end(parms);

    // Write the information out to a txt file
    FILE *fp = fopen("output.txt", "a+");
    fprintf(fp, "%s", buf);
    fclose(fp);

}// End dprintf(..)


inline void SwapEndian(unsigned short *data)
{
    *data=((*data&0x00ff)<<8)
         |((*data&0xff00)>>8);
}

inline void SwapEndian(short *data)
{
    *data=((*data&0x00ff)<<8)
         |((*data&0xff00)>>8);
}

inline void SwapEndian(unsigned int *data)
{
    *data=((*data&0x000000ff)<<24)
         |((*data&0x0000ff00)<< 8)
         |((*data&0x00ff0000)>> 8)
         |((*data&0xff000000)>>24);
}

inline void SwapEndian(int *data)
{
    *data=((*data&0x000000ff)<<24)
         |((*data&0x0000ff00)<< 8)
         |((*data&0x00ff0000)>> 8)
         |((*data&0xff000000)>>24);
}


static void *png_zalloc(void *opaque, unsigned int items, unsigned int size)
{
    return malloc(items * size);
}

static void png_zfree(void *opaque, void *ptr)
{
    free(ptr);
}


void ReadImageData(FILE *fp, int sizeData)
{
    static z_stream zstream;
    memset(&zstream, 0, sizeof(zstream));

    // init the zlib
    zstream.zalloc = png_zalloc;
    zstream.zfree = png_zfree;
    zstream.opaque = NULL;
    int okay = inflateInit(&zstream);
    dprintf("InflateInit Z_OK(0) : %d\n", okay);


    dprintf("\t[IDAT]Reading Image Data\n");
    dprintf("\t SizeData %d\n", sizeData);

    unsigned char* buf = new unsigned char[sizeData + 100];
    fread(buf, 1, sizeData, fp);

    
    int i = 0;
    dprintf("Compression Flags: 0x%02X\n", buf[i]);    i++;
    dprintf("Additional  Flags: 0x%02X\n", buf[i]);    i++;
    dprintf("Misc Bytes: 0x%02X\n", buf[i]);        i++;
    dprintf("Misc Bytes: 0x%02X\n", buf[i]);        i++;
    dprintf("Misc Bytes: 0x%02X\n", buf[i]);        i++;
    dprintf("Misc Bytes: 0x%02X\n", buf[i]);        i++;
    dprintf("Misc Bytes: 0x%02X\n", buf[i]);        i++;

    for (int y=0; y<8; y++)
    {
        dprintf("Data: ");
        dprintf("0x%02X   - ", buf[i]); i++;

        int lineWidth = 3*8;

        for (int x=0; x<lineWidth; x++)
        {
            dprintf("0x%02X ", buf[i]); i++;
        
        }
        dprintf("\n");
    }


    unsigned int cv = ((unsigned int)buf[i+0] | 
                      ((unsigned int)buf[i+1]<<8) | 
                      ((unsigned int)buf[i+2]<<16) | 
                      ((unsigned int)buf[i+3]<<24));
    SwapEndian(&cv);
    dprintf("Check Value: 0x%08X\n", cv);    i+=4;
    dprintf("i = %d\n\n", i);


    // Decompressed using zlib
    unsigned char outBuf[1024]= {0};

    dprintf("Compressed Data:\n\n");
    unsigned char compressedData[1024] = {0};
    for (int i=0; i<sizeData; i++)
    {
        compressedData[i] = buf[i];

        if (i%(8*3)==0) dprintf("\n");
        dprintf("0x%02X, ", buf[i]);
    }
    dprintf("\n\n");


    int ret = 0;
    zstream.avail_in = sizeData;
    zstream.next_in = compressedData;

    zstream.avail_out = sizeof(outBuf);
    zstream.next_out = (Bytef*)outBuf;


    // decode one line if possible
    while (zstream.avail_in > 0) 
    {
        ret = inflate(&zstream, Z_SYNC_FLUSH); //Z_PARTIAL_FLUSH);
        if (ret != Z_OK && ret != Z_STREAM_END) 
        {
            dprintf("Problem with zlib inflate\n");
            return;
        }
    }

    // Finished!..release zlib
    inflateEnd(&zstream);


    dprintf("-Decompressed Image:\n");
    for (int y=0; y<8; y++)
    {
        int lineWidth = 3*8 + 1;

        dprintf("Data: ");
        dprintf("0x%02X   - ", outBuf[y*lineWidth + 0]);

        for (int x=0; x<lineWidth-1; x++)
        {
            dprintf("0x%02X ", outBuf[y*lineWidth + x + 1]);
        
        }
        dprintf("\n");
    }

    delete[] buf;
}



void ReadPngFile(char* szFileName)
{
    dprintf("Png Dump File: %s\n\n", szFileName);

    FILE *fp;
    fp = fopen(szFileName, "rb");

    // Read 8 byte PNG signature first
    unsigned char sig[8];
    fread(sig, 1, 8, fp);

    // Should be, for a valid PNG file:
    // [0x89, (0x50)'P', (0x4E)'N', (0xD)'G', 0xD, 0xA, 0x1A, 0xA]
    dprintf("First 8 bytes: [0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X]\n",
            sig[0],sig[1],sig[2],sig[3],sig[4],sig[5],sig[6],sig[7]);


    // Next comes the chunks of data which contain the image data
    while (true)
    {
        unsigned int chunkSize;
        unsigned int chunkID;

        
        fread(&chunkSize, 1, sizeof(chunkSize), fp);
        fread(&chunkID,   1, sizeof(chunkID),   fp);

        SwapEndian(&chunkSize); // Get Size of this Chunk
        SwapEndian(&chunkID);    // Get Its Chunk ID Type

        dprintf("[Chunk] ID:0x%X  (Size:% 6d)\n", chunkID, chunkSize);
        bool doneAllChunks = false;

        long chunkPos = ftell(fp);

        switch (chunkID)
        {
            case 0x49444154:    // 'I', 'D', 'A', 'T'
            {
                ReadImageData(fp, chunkSize);
            }
            break;
            case 0x49454e44:    // 'I', 'E', 'N', 'D'
            {
                doneAllChunks=true; // No More Chunks
            }
            break;
            default:
            {
            }
        }

        fseek(fp, chunkPos, SEEK_SET);
        // Jump over this chunk
        fseek(fp, chunkSize, SEEK_CUR); // Skip over its contents

        unsigned int crc;
        fread(&crc,   1, sizeof(crc),   fp); // Read CRC Value
        dprintf("CRC: 0x%08X\n", crc);

        if (doneAllChunks) break;
    }

    // All done extracting information, close file
    fclose(fp);

    dprintf("Finished\n");
}// End ReadPngFile(..)



void main()
{
    ReadPngFile("output.png");
}// End main()

/******************************************************************************/
/*                                                                            */
/* File: png_tiny_raw_creator.cpp                                             */
/*                                                                            */
/* Simple tutorial file, that allows you to see whats in a raw png file, and  */
/* then creates it.  Creates a file, and writes out the raw byte data to it.  */
/* The image is a 8x8 image of a cross. Using no compression and RGB values.  */
/*                                                                            */
/******************************************************************************/

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


#define WIDTH 0x8
#define HEIGHT 0x8

static
unsigned char head[] = {
/* PNG signature */
        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,

/* IHDR -- Image header */

        0, 0, 0, 0x0d,
        'I', 'H', 'D', 'R',
        0, 0, 0, WIDTH, // width
        0, 0, 0, HEIGHT,// height
        8,              // bit depth
        2,              // colour type: 2=rgb-colour
        0,              // compression method: 0=deflate
        0,              // filter method
        0,              // interlace method
        0x4B, 0x6D, 0x29, 0xDC, // CRC-32

/* IDAT */

        0, 0, 0, 211,
        'I', 'D', 'A', 'T',

        // CMF = 0x28 
        //  .CM = %1000 = 8 (compression method: 8 deflate)
        //  .CINFO = %0010 (window size: 1024)
        // FLG = 0xcf
        //  .FCHECK %01111 (checksum: 0x28cf = 10447 = 337 * 31 OK)
        //  .FDICT = %0 = no dictionary
        //  .FLEVEL = %11 = max compression

        0x08,
        0x1D,
        0x01,
        0xC8,
        0x00,
        0x37,
        0xFF,

        // Filter Byte  --- >   Raw RGB Pixel Data
        0x01,  0x00,0x00,0x00,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,
        0x02,  0xFF,0xFF,0xFF,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0xFF,0xFF,0xFF,
        0x02,  0x00,0x00,0x00,0xFF,0xFF,0xFF,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0xFF,0xFF,0xFF,0x00,0x00,0x00,
        0x01,  0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,
        0x02,  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x02,  0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
        0x02,  0x00,0x00,0x00,0x01,0x01,0x01,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0x01,0x01,0x01,0x00,0x00,0x00,
        0x01,  0x00,0x00,0x00,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,
                                
        0x9F, 0x79, 0x24, 0x0B, // Adler CRC

        0x43, 0xD1, 0x11, 0x33, // CRC-32

/* IEND */

        0, 0, 0, 0,
        'I', 'E', 'N', 'D',
        // no data
        0xae, 0x42, 0x60, 0x82, // CRC-32
};


int main(void)
{
    FILE *fp = fopen("test.png", "wb");
    fwrite(head, 1, sizeof head, fp);
    fclose (fp);
}

/******************************************************************************/
/*                                                                            */
/* File: tinyPng.cpp                                                          */
/*                                                                            */
/* Simple Png File Write (Exporter) - Takes raw RGB pixel values and then     */
/* writes them out to a png file.                                             */
/* Only does Uncompressed PNG so that its kept as simple as possible, and     */
/* doesn't require any external libs...so you don't need to use zlib..        */
/*                                                                            */
/* Quote: Code can drive you crazy!                                           */
/*                                                                            */
/******************************************************************************/

#include <stdio.h>


void SavePng(char* fileName);
void SaveIhdrChunk();
void SaveChunk(int chunkType, int chunkSize, unsigned char* data);
void SavePhysChunk();
void SaveIendChunk();
void SaveImage();


FILE* g_fp     = NULL;
int   g_width  = 16;
int   g_height = 16;


/******************************************************************************/
/*                                                                            */
/* Program Entry Point                                                        */
/*                                                                            */
/******************************************************************************/
void main()
{
    SavePng("output.png");

}// End main(..)


/******************************************************************************/
/*                                                                            */
/* Various common PNG File Format Defines                                     */
/*                                                                            */
/******************************************************************************/
const int CHUNK_CRC32_IEND = 0xae426082;
const int CHUNK_SIZE_IHDR = 0x0000000d;
const int CHUNK_TYPE_IDAT = 0x49444154;
const int CHUNK_TYPE_IEND = 0x49454e44;
const int CHUNK_TYPE_IHDR = 0x49484452;
const int CHUNK_TYPE_PLTE = 0x504c5445;
const int CHUNK_TYPE_tEXt = 0x74455874;
const int CHUNK_TYPE_pHYs = 0x70485973;
const int COLOR_TYPE_GRAY = 0;
const int COLOR_TYPE_GRAY_ALPHA = 4;
const int COLOR_TYPE_INDEXED = 3;
const int COLOR_TYPE_RGB = 2;
const int COLOR_TYPE_RGB_ALPHA = 6;
const int COLOR_TYPE_ALPHA = 4;
const int FILTER_TYPE_NONE = 0;
const int FILTER_TYPE_SUB = 1;
const int FILTER_TYPE_UP = 2;
const int FILTER_TYPE_AVERAGE = 3;
const int FILTER_TYPE_PAETH = 4;
const int COMPRESSION_DEFLATE = 0;
const int INTERLACING_NONE = 0;
const int INTERLACING_ADAM7 = 1;
const int FILTERING_ADAPTIVE = 0;
const int MAX_TEXT_SIZE = 512;
const int ADAM7_NUM_PASSES = 7;
const int ADAM7_COLUMN_INCREMENT[] = {8, 8, 4, 4, 2, 2, 1};
const int ADAM7_FIRST_COLUMN[] = {0, 4, 0, 2, 0, 1, 0};
const int ADAM7_FIRST_ROW[] = {0, 0, 4, 0, 2, 0, 1};
const int ADAM7_ROW_INCREMENT[] = {8, 8, 8, 4, 4, 2, 2};
const unsigned char MAGIC_BYTES[8] = {0x89, 0x50, 0x4e, 0x47,0x0d, 0x0a, 0x1a, 0x0a};


/******************************************************************************/
/*                                                                            */
/* SwapEndian(..)                                                             */
/* A lot of the data needs to be put into BigEndian, so a common function     */
/* is created to make it easier :)                                            */
/*                                                                            */
/******************************************************************************/
inline void SwapEndian(unsigned int *data)
{
    *data=((*data&0x000000ff)<<24)
         |((*data&0x0000ff00)<< 8)
         |((*data&0x00ff0000)>> 8)
         |((*data&0xff000000)>>24);
}


/******************************************************************************/
/*                                                                            */
/* File Writing Functions                                                     */
/*                                                                            */
/******************************************************************************/
void WriteBytes(const unsigned char* data, int numBytes) 
{
    fwrite(data, 1, numBytes, g_fp);
}// End WriteByte(..)


void WriteDword(const unsigned int data) 
{
    SwapEndian((unsigned int*)&data);
    fwrite(&data, 1, sizeof(unsigned int), g_fp);
}// End WriteByte(..)



void SavePng(char* outputFileName)
{
    g_fp = fopen(outputFileName, "wb+");

    // write 8 byte PNG signature
    WriteBytes(MAGIC_BYTES, sizeof(MAGIC_BYTES));
    // write IHDR (image header) chunk
    SaveIhdrChunk();
    // write IDAT chunk
    SaveImage();
    // write IEND chunk
    SaveIendChunk();

    fclose(g_fp);
}


void SaveIhdrChunk()
{
    unsigned char buffer[CHUNK_SIZE_IHDR];

    *(unsigned int*)&buffer[0] = g_width;
    *(unsigned int*)&buffer[4] = g_height;

    SwapEndian((unsigned int*)&buffer[0]);
    SwapEndian((unsigned int*)&buffer[4]);

    buffer[8]  = 8;                        // 8 bit per component
    buffer[9]  = COLOR_TYPE_RGB;        // rgb 24bit
    buffer[10] = COMPRESSION_DEFLATE;    // non-compressed
    buffer[11] = FILTER_TYPE_NONE;
    buffer[12] = INTERLACING_NONE;

    SaveChunk(CHUNK_TYPE_IHDR, CHUNK_SIZE_IHDR, buffer);
}//End SaveIhdrChunk(..)



unsigned int crctab[256] = {
    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
    0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
    0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
    0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
    0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
    0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
    0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
    0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
    0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
    0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
    0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
    0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
    0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
    0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
    0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
    0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
    0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
    0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
    0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
    0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
    0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
    0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
    0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
    0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
    0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
    0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
    0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
    0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
    0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
    0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
    0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
    0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
    0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
    0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
    0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
    0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
    0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
    0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
    0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
    0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
    0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
    0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
    0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};


unsigned int CRC32(unsigned int crc, unsigned char * buf, unsigned int len)
{
    unsigned int sum;
    unsigned int s0 = crc ^ 0xffffffffL;
    for (unsigned int i = 0; i < len; i++) 
    {
        s0 = (s0 >> 8) ^ crctab[(unsigned char) (s0 & 0xFF) ^ buf[i]];
    }
    sum = ~s0;
    return sum;
}

class CRC
{
public:
    unsigned int m_sum;
    void Reset()
    {
        m_sum = ~0;
    }

    void Update(unsigned char * buf, unsigned int len)
    {
        for (unsigned int i = 0; i < len; i++) 
        {
            m_sum = (m_sum >> 8) ^ crctab[(unsigned char) (m_sum & 0xFF) ^ buf[i]];
        }
    }

    unsigned int GetCRC()
    {
        return (~m_sum);
    }
};

void SaveChunk(int chunkType, int chunkDataSize, unsigned char* chunkData)
{
    // Write out the Chunk Size
    WriteDword(chunkDataSize);

    // Write out the Chunk Type
    WriteDword(chunkType);

    // Write out the actual data
    WriteBytes(chunkData, chunkDataSize);

    // Work out the 4 byte CRC value on the end which is generated from
    // the data and the chunkType
    CRC crcVal;
    crcVal.Reset();
    unsigned int chunkTypeEndian = chunkType;
    SwapEndian(&chunkTypeEndian);
    crcVal.Update((unsigned char*)&chunkTypeEndian, 4);
    crcVal.Update(chunkData,  chunkDataSize);
    unsigned int checkSum = crcVal.GetCRC();

    // Or using function based CRC, instead of a class
    unsigned int crc = CRC32(0,   (unsigned char*)&chunkTypeEndian, 4);
                 crc = CRC32(crc, chunkData, chunkDataSize);


    // Writing the Checksum
    WriteDword(checkSum);
}


void SaveIendChunk()
{
    // Write out the 12 byte end chunk
    WriteDword(0);
    WriteDword(CHUNK_TYPE_IEND);
    WriteDword(CHUNK_CRC32_IEND);
}



unsigned int adler = 1; // Reset it back to 1
unsigned int UpdateAdler32(unsigned long adler, unsigned char* buf, int sizeBuf)
{
    const unsigned int BASE = 65521;
    unsigned int s1 = adler & 0xffff;
    unsigned int s2 = (adler>>16) & 0xffff;
    
    for (int n=0; n<sizeBuf; n++)
    {
        s1 = (s1 + buf[n]) % BASE;
        s2 = (s2 + s1)     % BASE;
    }
    return (s2<<16) + s1;
}

/******************************************************************************/
/*                                                                            */
/*  SaveImage()                                                               */
/*                                                                            */
/*  Heart of the work goes here.  As we can't just save out the RGB values    */
/*  as you'd think!  Even thought we've chosen uncompressed RGB it still      */
/*  passes the data to zlib, which adds on some extra information.            */
/*  We can still make our image export raw data, but we have to add a few     */
/*  extra bytes which which the zlib compression would usually add to define  */
/*  how the data is stored, and extra parity checks.                          */
/*                                                                            */
/******************************************************************************/
void SaveImage()
{
    int imageWidth  = g_width;
    int imageHeight = g_height;

    // Image Data is
    int lineWidth      = (imageWidth*3) + 1;            // +1 is the Filter Byte (RGB*width)
    int imageChunkSize = lineWidth * imageHeight;        // Our RGB's are stored in this
    int IDATChunkSize  = imageChunkSize + 2 + 5 + 4;    // +3 is for the Compression Flags
                                                        // +4 Size Chunk and Size Chunks Complement
                                                        // +4 ADLER CheckSum

    // Create a big temp array for our generated data
    unsigned char* imageData = new unsigned char[IDATChunkSize];

    // Create a temp pointer to our array, and increment it as we fill our buffer
    // with data
    unsigned char* destPtr = imageData;
    
    // 3 Bytes
    *destPtr++ = 0x08; // Default compression (CMF)
    *destPtr++ = 0x1D; // 
    *destPtr++ = 0x01; // parity bit (FLG)

    // 4 Bytes
    *((unsigned short *)(destPtr))=imageChunkSize;    destPtr+=2;    // Not endian flipped!
    int sizeComplement = imageChunkSize^0xffffffff;                // Complement follows
    *((unsigned short *)(destPtr))=sizeComplement;    destPtr+=2;    // Not endian flipped!


    // Our Actual Pixle values are wrote out here
    for (int y=0; y<imageHeight; y++)
    {
        // Single Filter byte at the start of each scanline
        *destPtr++ = 0;

        // RGB Image Data For a Row
        for (int x=0; x<imageWidth; x++)
        {
            *destPtr++ = 0x0;
            *destPtr++ = 0xff;
            *destPtr++ = 0x0;
        }
    }


    // +7 is so we Calculate the Adler for the size of our image data (including 
    // filter byte) only
    unsigned int adler32 = UpdateAdler32(adler, imageData+7, imageChunkSize);

    SwapEndian(&adler32);
    *(unsigned int *)destPtr = adler32; // Adler


    // Create our buffer full of data which we'll now save out.
    SaveChunk(CHUNK_TYPE_IDAT, IDATChunkSize, imageData);


    // Delete temp buffer
    delete[] imageData;
}// End SaveImage(..)