#include "FreeImage.h"

#include "Utilities.h"

#define MNG_INCLUDE_JNG

#ifdef MNG_INCLUDE_JNG

#define MNG_COLORTYPE_JPEGGRAY 8 /* JHDR */

#define MNG_COLORTYPE_JPEGCOLOR 10

#define MNG_COLORTYPE_JPEGGRAYA 12

#define MNG_COLORTYPE_JPEGCOLORA 14

#define MNG_BITDEPTH_JPEG8 8 /* JHDR */

#define MNG_BITDEPTH_JPEG12 12

#define MNG_BITDEPTH_JPEG8AND12 20

#define MNG_COMPRESSION_BASELINEJPEG 8 /* JHDR */

#define MNG_INTERLACE_SEQUENTIAL 0 /* JHDR */

#define MNG_INTERLACE_PROGRESSIVE 8

#endif /* MNG_INCLUDE_JNG */

#define JNG_SUPPORTED

const DWORD JPEG_CHUNK_SIZE = 8192;

static const BYTE g_png_signature[8] = { 137, 80, 78, 71, 13, 10, 26, 10 };

static const BYTE g_jng_signature[8] = { 139, 74, 78, 71, 13, 10, 26, 10 };

enum eChunckType {

};

typedef std::map<std::string, std::string> tEXtMAP;

static BYTE mng_MHDR[5]={ 77, 72, 68, 82, (BYTE) '\0'};

static BYTE mng_BACK[5]={ 66, 65, 67, 75, (BYTE) '\0'};

static BYTE mng_BASI[5]={ 66, 65, 83, 73, (BYTE) '\0'};

static BYTE mng_CLIP[5]={ 67, 76, 73, 80, (BYTE) '\0'};

static BYTE mng_CLON[5]={ 67, 76, 79, 78, (BYTE) '\0'};

static BYTE mng_DEFI[5]={ 68, 69, 70, 73, (BYTE) '\0'};

static BYTE mng_DHDR[5]={ 68, 72, 68, 82, (BYTE) '\0'};

static BYTE mng_DISC[5]={ 68, 73, 83, 67, (BYTE) '\0'};

static BYTE mng_ENDL[5]={ 69, 78, 68, 76, (BYTE) '\0'};

static BYTE mng_FRAM[5]={ 70, 82, 65, 77, (BYTE) '\0'};

static BYTE mng_IEND[5]={ 73, 69, 78, 68, (BYTE) '\0'};

static BYTE mng_IHDR[5]={ 73, 72, 68, 82, (BYTE) '\0'};

static BYTE mng_JHDR[5]={ 74, 72, 68, 82, (BYTE) '\0'};

static BYTE mng_LOOP[5]={ 76, 79, 79, 80, (BYTE) '\0'};

static BYTE mng_MAGN[5]={ 77, 65, 71, 78, (BYTE) '\0'};

static BYTE mng_MEND[5]={ 77, 69, 78, 68, (BYTE) '\0'};

static BYTE mng_MOVE[5]={ 77, 79, 86, 69, (BYTE) '\0'};

static BYTE mng_PAST[5]={ 80, 65, 83, 84, (BYTE) '\0'};

static BYTE mng_PLTE[5]={ 80, 76, 84, 69, (BYTE) '\0'};

static BYTE mng_SAVE[5]={ 83, 65, 86, 69, (BYTE) '\0'};

static BYTE mng_SEEK[5]={ 83, 69, 69, 75, (BYTE) '\0'};

static BYTE mng_SHOW[5]={ 83, 72, 79, 87, (BYTE) '\0'};

static BYTE mng_TERM[5]={ 84, 69, 82, 77, (BYTE) '\0'};

static BYTE mng_bKGD[5]={ 98, 75, 71, 68, (BYTE) '\0'};

static BYTE mng_cHRM[5]={ 99, 72, 82, 77, (BYTE) '\0'};

static BYTE mng_gAMA[5]={103, 65, 77, 65, (BYTE) '\0'};

static BYTE mng_iCCP[5]={105, 67, 67, 80, (BYTE) '\0'};

static BYTE mng_nEED[5]={110, 69, 69, 68, (BYTE) '\0'};

static BYTE mng_pHYg[5]={112, 72, 89, 103, (BYTE) '\0'};

static BYTE mng_vpAg[5]={118, 112, 65, 103, (BYTE) '\0'};

static BYTE mng_pHYs[5]={112, 72, 89, 115, (BYTE) '\0'};

static BYTE mng_sBIT[5]={115, 66, 73, 84, (BYTE) '\0'};

static BYTE mng_sRGB[5]={115, 82, 71, 66, (BYTE) '\0'};

static BYTE mng_tRNS[5]={116, 82, 78, 83, (BYTE) '\0'};

#if defined(JNG_SUPPORTED)

static BYTE mng_IDAT[5]={ 73, 68, 65, 84, (BYTE) '\0'};

static BYTE mng_JDAT[5]={ 74, 68, 65, 84, (BYTE) '\0'};

static BYTE mng_JDAA[5]={ 74, 68, 65, 65, (BYTE) '\0'};

static BYTE mng_JdAA[5]={ 74, 100, 65, 65, (BYTE) '\0'};

static BYTE mng_JSEP[5]={ 74, 83, 69, 80, (BYTE) '\0'};

static BYTE mng_oFFs[5]={111, 70, 70, 115, (BYTE) '\0'};

#endif

static BYTE mng_hIST[5]={104, 73, 83, 84, (BYTE) '\0'};

static BYTE mng_iTXt[5]={105, 84, 88, 116, (BYTE) '\0'};

static BYTE mng_sPLT[5]={115, 80, 76, 84, (BYTE) '\0'};

static BYTE mng_sTER[5]={115, 84, 69, 82, (BYTE) '\0'};

static BYTE mng_tEXt[5]={116, 69, 88, 116, (BYTE) '\0'};

static BYTE mng_tIME[5]={116, 73, 77, 69, (BYTE) '\0'};

static BYTE mng_zTXt[5]={122, 84, 88, 116, (BYTE) '\0'};

static eChunckType

mng_GetChunckType(const BYTE *mChunkName) {

}

inline void

mng_SwapShort(WORD *sp) {

}

inline void

mng_SwapLong(DWORD *lp) {

}

static long

mng_LOF(FreeImageIO *io, fi_handle handle) {

}

static BOOL

mng_CountPNGChunks(FreeImageIO *io, fi_handle handle, long inPos, unsigned *m_TotalBytesOfChunks) {

}

static BOOL

mng_FindChunk(FIMEMORY *hPngMemory, BYTE *chunk_name, long offset, DWORD *start_pos, DWORD *next_pos) {

}

static BOOL

mng_CopyRemoveChunks(FIMEMORY *hPngMemory, DWORD start_pos, DWORD next_pos) {

}

static BOOL

mng_CopyInsertChunks(FIMEMORY *hPngMemory, BYTE *inNextChunkName, BYTE *inInsertChunk, DWORD inChunkLength, DWORD start_pos, DWORD next_pos) {

}

static BOOL

mng_RemoveChunk(FIMEMORY *hPngMemory, BYTE *chunk_name) {

}

static BOOL

mng_InsertChunk(FIMEMORY *hPngMemory, BYTE *inNextChunkName, BYTE *inInsertChunk, unsigned chunk_length) {

}

static FIBITMAP*

mng_LoadFromMemoryHandle(FIMEMORY *hmem, int flags = 0) {

long offset = 0;

FIBITMAP *dib = NULL;

if(hmem) {

// seek to the start of the stream

FreeImage_SeekMemory(hmem, offset, SEEK_SET);

// check the file signature and deduce its format

// (the second argument is currently not used by FreeImage)

FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem, 0);

if(fif != FIF_UNKNOWN) {

dib = FreeImage_LoadFromMemory(fif, hmem, flags);

}

}

return dib;

}

static void

mng_WriteChunk(BYTE *chunk_name, BYTE *chunk_data, DWORD length, FIMEMORY *hPngMemory) {

}

static void

mng_WritePNGStream(DWORD jng_width, DWORD jng_height, BYTE jng_alpha_sample_depth, BYTE *mChunk, DWORD mLength, FIMEMORY *hPngMemory) {

}

static BOOL

mng_SetKeyValue(FREE_IMAGE_MDMODEL model, FIBITMAP *dib, const char *key, const char *value) {

}

static BOOL

mng_SetMetadata_tEXt(tEXtMAP &key_value_pair, const BYTE *mChunk, DWORD mLength) {

}

FIBITMAP*

mng_ReadChunks(int format_id, FreeImageIO *io, fi_handle handle, long Offset, int flags = 0) {

DWORD mLength = 0;

BYTE mChunkName[5];

BYTE *mChunk = NULL;

DWORD crc_file;

long LastOffset;

long mOrigPos;

BYTE *PLTE_file_chunk = NULL; // whole PLTE chunk (lentgh, name, array, crc)

DWORD PLTE_file_size = 0; // size of PLTE chunk

BOOL m_HasGlobalPalette = FALSE; // may turn to TRUE in PLTE chunk

unsigned m_TotalBytesOfChunks = 0;

FIBITMAP *dib = NULL;

FIBITMAP *dib_alpha = NULL;

FIMEMORY *hJpegMemory = NULL;

FIMEMORY *hPngMemory = NULL;

FIMEMORY *hIDATMemory = NULL;

// ---

DWORD jng_width = 0;

DWORD jng_height = 0;

BYTE jng_color_type = 0;

BYTE jng_image_sample_depth = 0;

BYTE jng_image_compression_method = 0;

BYTE jng_alpha_sample_depth = 0;

BYTE jng_alpha_compression_method = 0;

BYTE jng_alpha_filter_method = 0;

BYTE jng_alpha_interlace_method = 0;

DWORD mng_frame_width = 0;

DWORD mng_frame_height = 0;

DWORD mng_ticks_per_second = 0;

DWORD mng_nominal_layer_count = 0;

DWORD mng_nominal_frame_count = 0;

DWORD mng_nominal_play_time = 0;

DWORD mng_simplicity_profile = 0;

DWORD res_x = 2835; // 72 dpi

DWORD res_y = 2835; // 72 dpi

RGBQUAD rgbBkColor = {0, 0, 0, 0};

WORD bk_red, bk_green, bk_blue;

BOOL hasBkColor = FALSE;

BOOL mHasIDAT = FALSE;

tEXtMAP key_value_pair;

// ---

BOOL header_only = (flags & FIF_LOAD_NOPIXELS) == FIF_LOAD_NOPIXELS;

// get the file size

const long mLOF = mng_LOF(io, handle);

// go to the first chunk

io->seek_proc(handle, Offset, SEEK_SET);

try {

BOOL mEnd = FALSE;

while(mEnd == FALSE) {

// start of the chunk

LastOffset = io->tell_proc(handle);

// read length

mLength = 0;

io->read_proc(&mLength, 1, sizeof(mLength), handle);

mng_SwapLong(&mLength);

// read name

io->read_proc(&mChunkName[0], 1, 4, handle);

mChunkName[4] = '\0';

if(mLength > 0) {

mChunk = (BYTE*)realloc(mChunk, mLength);

if(!mChunk) {

FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: out of memory", mChunkName);

throw (const char*)NULL;

}

Offset = io->tell_proc(handle);

if(Offset + (long)mLength > mLOF) {

FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: unexpected end of file", mChunkName);

throw (const char*)NULL;

}

// read chunk

io->read_proc(mChunk, 1, mLength, handle);

}

// read crc

io->read_proc(&crc_file, 1, sizeof(crc_file), handle);

mng_SwapLong(&crc_file);

// check crc

DWORD crc_check = FreeImage_ZLibCRC32(0, &mChunkName[0], 4);

crc_check = FreeImage_ZLibCRC32(crc_check, mChunk, mLength);

if(crc_check != crc_file) {

FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: bad CRC", mChunkName);

throw (const char*)NULL;

}

switch( mng_GetChunckType(mChunkName) ) {

case MHDR:

// The MHDR chunk is always first in all MNG datastreams except for those

// that consist of a single PNG or JNG datastream with a PNG or JNG signature.

if(mLength == 28) {

memcpy(&mng_frame_width, &mChunk[0], 4);

memcpy(&mng_frame_height, &mChunk[4], 4);

memcpy(&mng_ticks_per_second, &mChunk[8], 4);

memcpy(&mng_nominal_layer_count, &mChunk[12], 4);

memcpy(&mng_nominal_frame_count, &mChunk[16], 4);

memcpy(&mng_nominal_play_time, &mChunk[20], 4);

memcpy(&mng_simplicity_profile, &mChunk[24], 4);

mng_SwapLong(&mng_frame_width);

mng_SwapLong(&mng_frame_height);

mng_SwapLong(&mng_ticks_per_second);

mng_SwapLong(&mng_nominal_layer_count);

mng_SwapLong(&mng_nominal_frame_count);

mng_SwapLong(&mng_nominal_play_time);

mng_SwapLong(&mng_simplicity_profile);

} else {

FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: size is %d instead of 28", mChunkName, mLength);

}

break;

case MEND:

mEnd = TRUE;

break;

case LOOP:

case ENDL:

break;

case DEFI:

break;

case SAVE:

case SEEK:

case TERM:

break;

case BACK:

break;

// Global "PLTE" and "tRNS" (if any). PNG "PLTE" will be of 0 byte, as it uses global data.

case PLTE: // Global

m_HasGlobalPalette = TRUE;

PLTE_file_size = mLength + 12; // (lentgh, name, array, crc) = (4, 4, mLength, 4)

PLTE_file_chunk = (BYTE*)realloc(PLTE_file_chunk, PLTE_file_size);

if(!PLTE_file_chunk) {

FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: out of memory", mChunkName);

throw (const char*)NULL;

} else {

mOrigPos = io->tell_proc(handle);

// seek to the start of the chunk

io->seek_proc(handle, LastOffset, SEEK_SET);

// load the whole chunk

io->read_proc(PLTE_file_chunk, 1, PLTE_file_size, handle);

// go to the start of the next chunk

io->seek_proc(handle, mOrigPos, SEEK_SET);

}

break;

case tRNS: // Global

break;

case IHDR:

Offset = LastOffset;

// parse the PNG file and get its file size

if(mng_CountPNGChunks(io, handle, Offset, &m_TotalBytesOfChunks) == FALSE) {

// reach an unexpected end of file

mEnd = TRUE;

FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: unexpected end of PNG file", mChunkName);

break;

}

// wrap the { IHDR, ..., IEND } chunks as a PNG stream

if(hPngMemory == NULL) {

hPngMemory = FreeImage_OpenMemory();

}

mOrigPos = io->tell_proc(handle);

// write PNG file signature

FreeImage_SeekMemory(hPngMemory, 0, SEEK_SET);

FreeImage_WriteMemory(g_png_signature, 1, 8, hPngMemory);

mChunk = (BYTE*)realloc(mChunk, m_TotalBytesOfChunks);

if(!mChunk) {

FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: out of memory", mChunkName);

throw (const char*)NULL;

}

// on calling CountPNGChunks earlier, we were in Offset pos,

// go back there

io->seek_proc(handle, Offset, SEEK_SET);

io->read_proc(mChunk, 1, m_TotalBytesOfChunks, handle);

// Put back to original pos

io->seek_proc(handle, mOrigPos, SEEK_SET);

// write the PNG chunks

FreeImage_WriteMemory(mChunk, 1, m_TotalBytesOfChunks, hPngMemory);

// plug in global PLTE if local PLTE exists

if(m_HasGlobalPalette) {

// ensure we remove some local chunks, so that global

// "PLTE" can be inserted right before "IDAT".

mng_RemoveChunk(hPngMemory, mng_PLTE);

mng_RemoveChunk(hPngMemory, mng_tRNS);

mng_RemoveChunk(hPngMemory, mng_bKGD);

// insert global "PLTE" chunk in its entirety before "IDAT"

mng_InsertChunk(hPngMemory, mng_IDAT, PLTE_file_chunk, PLTE_file_size);

}

if(dib) FreeImage_Unload(dib);

dib = mng_LoadFromMemoryHandle(hPngMemory, flags);

// stop after the first image

mEnd = TRUE;

break;

case JHDR:

if(mLength == 16) {

memcpy(&jng_width, &mChunk[0], 4);

memcpy(&jng_height, &mChunk[4], 4);

mng_SwapLong(&jng_width);

mng_SwapLong(&jng_height);

jng_color_type = mChunk[8];

jng_image_sample_depth = mChunk[9];

jng_image_compression_method = mChunk[10];

//BYTE jng_image_interlace_method = mChunk[11]; // for debug only

jng_alpha_sample_depth = mChunk[12];

jng_alpha_compression_method = mChunk[13];

jng_alpha_filter_method = mChunk[14];

jng_alpha_interlace_method = mChunk[15];

} else {

FreeImage_OutputMessageProc(format_id, "Error while parsing %s chunk: invalid chunk length", mChunkName);

throw (const char*)NULL;

}

break;

case JDAT:

if(hJpegMemory == NULL) {

hJpegMemory = FreeImage_OpenMemory();

}

// as there may be several JDAT chunks, concatenate them

FreeImage_WriteMemory(mChunk, 1, mLength, hJpegMemory);

break;

case IDAT:

if(!header_only && (jng_alpha_compression_method == 0)) {

// PNG grayscale IDAT format

if(hIDATMemory == NULL) {

hIDATMemory = FreeImage_OpenMemory();

mHasIDAT = TRUE;

}

// as there may be several IDAT chunks, concatenate them

FreeImage_WriteMemory(mChunk, 1, mLength, hIDATMemory);