/*
 * The copyright in this software is being made available under the 2-clauses 
 * BSD License, included below. This software may be subject to other third 
 * party and contributor rights, including patent rights, and no such rights
 * are granted under this license.
 *
 * Copyright (c) 2007, Digital Signal Processing Laboratory, Università degli studi di Perugia (UPG), Italy
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#include "OPJViewer.h"

/* defines */
#define SHORT_DESCR_LEN        32
#define LONG_DESCR_LEN         256

/* enumeration for file formats */
#define J2FILENUM              4
typedef enum {

        JP2_FILE,
        J2K_FILE,
		MJ2_FILE,
		UNK_FILE

} j2filetype;

/* enumeration for the box types */
#define j22boxNUM                23
typedef enum {

			FILE_BOX,
			JP_BOX,
			FTYP_BOX,
			JP2H_BOX,
			IHDR_BOX,
			COLR_BOX,
			JP2C_BOX,
			JP2I_BOX,
			XML_BOX,
			UUID_BOX,
			UINF_BOX,
			MOOV_BOX,
			MVHD_BOX,
			TRAK_BOX,
			TKHD_BOX,
			MDIA_BOX,
			MDHD_BOX,
			HDLR_BOX,
			MINF_BOX,
			VMHD_BOX,
			STBL_BOX,
			STSD_BOX,
			STSZ_BOX,
			MJP2_BOX,
			MDAT_BOX,
			ANY_BOX,
			UNK_BOX

} j22boxtype;

/* the box structure itself */
struct boxdef {

        char                  value[5];                 /* hexadecimal value/string*/
		char                  name[SHORT_DESCR_LEN];    /* short description       */
		char                  descr[LONG_DESCR_LEN];    /* long  description       */
		int                   sbox;                     /* is it a superbox?       */
		int                   req[J2FILENUM];           /* mandatory box           */
		j22boxtype             ins;                      /* contained in box...     */

};


/* jp2 family box signatures */
#define FILE_SIGN           ""
#define JP_SIGN             "jP\040\040"
#define FTYP_SIGN           "ftyp"
#define JP2H_SIGN           "jp2h"
#define IHDR_SIGN           "ihdr"
#define COLR_SIGN           "colr"
#define JP2C_SIGN           "jp2c"
#define JP2I_SIGN           "jp2i"
#define XML_SIGN            "xml\040"
#define UUID_SIGN           "uuid"
#define UINF_SIGN           "uinf"
#define MOOV_SIGN           "moov"
#define MVHD_SIGN           "mvhd"
#define TRAK_SIGN           "trak"
#define TKHD_SIGN           "tkhd"
#define MDIA_SIGN           "mdia"
#define MDHD_SIGN           "mdhd"
#define HDLR_SIGN           "hdlr"
#define MINF_SIGN           "minf"
#define VMHD_SIGN           "vmhd"
#define STBL_SIGN           "stbl"
#define STSD_SIGN           "stsd"
#define STSZ_SIGN           "stsz"
#define MJP2_SIGN           "mjp2"
#define MDAT_SIGN           "mdat"
#define ANY_SIGN 			""
#define UNK_SIGN            ""

/* the possible boxes */
struct boxdef j22box[] =
{
/* sign */	{FILE_SIGN,
/* short */	"placeholder for nothing",
/* long */	"Nothing to say",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	FILE_BOX},

/* sign */	{JP_SIGN,
/* short */	"JPEG 2000 Signature box",
/* long */	"This box uniquely identifies the file as being part of the JPEG 2000 family of files",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	FILE_BOX},

/* sign */	{FTYP_SIGN,
/* short */	"File Type box",
/* long */	"This box specifies file type, version and compatibility information, including specifying if this file "
			"is a conforming JP2 file or if it can be read by a conforming JP2 reader",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	FILE_BOX},

/* sign */	{JP2H_SIGN,
/* short */	"JP2 Header box",
/* long */	"This box contains a series of boxes that contain header-type information about the file",
/* sbox */	1,
/* req */	{1, 1, 1},
/* ins */	FILE_BOX},

/* sign */	{IHDR_SIGN,
/* short */	"Image Header box",
/* long */	"This box specifies the size of the image and other related fields",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	JP2H_BOX},

/* sign */	{COLR_SIGN,
/* short */	"Colour Specification box",
/* long */	"This box specifies the colourspace of the image",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	JP2H_BOX},

/* sign */	{JP2C_SIGN,
/* short */	"Contiguous Codestream box",
/* long */	"This box contains the codestream as defined by Annex A",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	FILE_BOX},

/* sign */	{JP2I_SIGN,
/* short */	"Intellectual Property box",
/* long */	"This box contains intellectual property information about the image",
/* sbox */	0,
/* req */	{0, 0, 0},
/* ins */	FILE_BOX},

/* sign */	{XML_SIGN,
/* short */	"XML box",
/* long */	"This box provides a tool by which vendors can add XML formatted information to a JP2 file",
/* sbox */	0,
/* req */	{0, 0, 0},
/* ins */	FILE_BOX},

/* sign */	{UUID_SIGN,
/* short */	"UUID box",
/* long */	"This box provides a tool by which vendors can add additional information to a file "
			"without risking conflict with other vendors",
/* sbox */	0,
/* req */	{0, 0, 0},
/* ins */	FILE_BOX},

/* sign */	{UINF_SIGN,
/* short */	"UUID Info box",
/* long */	"This box provides a tool by which a vendor may provide access to additional information associated with a UUID",
/* sbox */	0,
/* req */	{0, 0, 0},
/* ins */	FILE_BOX},

/* sign */	{MOOV_SIGN,
/* short */	"Movie box",
/* long */	"This box contains the media data. In video tracks, this box would contain JPEG2000 video frames",
/* sbox */	1,
/* req */	{1, 1, 1},
/* ins */	FILE_BOX},

/* sign */	{MVHD_SIGN,
/* short */	"Movie Header box",
/* long */	"This box defines overall information which is media-independent, and relevant to the entire presentation "
			"considered as a whole",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	MOOV_BOX},

/* sign */	{TRAK_SIGN,
/* short */	"Track box",
/* long */	"This is a container box for a single track of a presentation. A presentation may consist of one or more tracks",
/* sbox */	1,
/* req */	{1, 1, 1},
/* ins */	MOOV_BOX},

/* sign */	{TKHD_SIGN,
/* short */	"Track Header box",
/* long */	"This box specifies the characteristics of a single track. Exactly one Track Header Box is contained in a track",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	TRAK_BOX},

/* sign */	{MDIA_SIGN,
/* short */	"Media box",
/* long */	"The media declaration container contains all the objects which declare information about the media data "
			"within a track",
/* sbox */	1,
/* req */	{1, 1, 1},
/* ins */	TRAK_BOX},

/* sign */	{MDHD_SIGN,
/* short */	"Media Header box",
/* long */	"The media header declares overall information which is media-independent, and relevant to characteristics "
			"of the media in a track",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	MDIA_BOX},

/* sign */	{HDLR_SIGN,
/* short */	"Handler Reference box",
/* long */	"This box within a Media Box declares the process by which the media-data in the track may be presented, "
			"and thus, the nature of the media in a track",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	MDIA_BOX},

/* sign */	{MINF_SIGN,
/* short */	"Media Information box",
/* long */	"This box contains all the objects which declare characteristic information of the media in the track",
/* sbox */	1,
/* req */	{1, 1, 1},
/* ins */	MDIA_BOX},

/* sign */	{VMHD_SIGN,
/* short */	"Video Media Header box",
/* long */	"The video media header contains general presentation information, independent of the coding, for video media",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	MINF_BOX},

/* sign */	{STBL_SIGN,
/* short */	"Sample Table box",
/* long */	"The sample table contains all the time and data indexing of the media samples in a track",
/* sbox */	1,
/* req */	{1, 1, 1},
/* ins */	MINF_BOX},

/* sign */	{STSD_SIGN,
/* short */	"STSD Sample Description box",
/* long */	"The sample description table gives detailed information about the coding type used, and any initialization "
			"information needed for that coding",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	MINF_BOX},

/* sign */	{STSZ_SIGN,
/* short */	"Sample Size box",
/* long */	"This box contains the sample count and a table giving the size of each sample",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	STBL_BOX},

/* sign */	{MJP2_SIGN,
/* short */	"MJP2 Sample Description box",
/* long */	"The MJP2 sample description table gives detailed information about the coding type used, and any initialization "
			"information needed for that coding",
/* sbox */	0,
/* req */	{1, 1, 1},
/* ins */	MINF_BOX},

/* sign */	{MDAT_SIGN,
/* short */	"Media Data box",
/* long */	"The meta-data for a presentation is stored in the single Movie Box which occurs at the top-level of a file",
/* sbox */	1,
/* req */	{1, 1, 1},
/* ins */	FILE_BOX},

/* sign */	{ANY_SIGN,
/* short */	"Any box",
/* long */	"All the existing boxes",
/* sbox */	0,
/* req */	{0, 0, 0},
/* ins */	FILE_BOX},

/* sign */	{UNK_SIGN,
/* short */	"Unknown Type box",
/* long */	"The signature is not recognised to be that of an existing box",
/* sbox */	0,
/* req */	{0, 0, 0},
/* ins */	ANY_BOX}

};


/* macro functions */
/* From little endian to big endian, 2 and 4 bytes */
#define	BYTE_SWAP2(X)	((X & 0x00FF) << 8) | ((X & 0xFF00) >> 8)
#define	BYTE_SWAP4(X)	((X & 0x000000FF) << 24) | ((X & 0x0000FF00) << 8) | ((X & 0x00FF0000) >> 8) | ((X & 0xFF000000) >> 24)

#ifdef __WXGTK__
#define	BYTE_SWAP8(X)	((X & 0x00000000000000FFULL) << 56) | ((X & 0x000000000000FF00ULL) << 40) | \
                        ((X & 0x0000000000FF0000ULL) << 24) | ((X & 0x00000000FF000000ULL) << 8) | \
						((X & 0x000000FF00000000ULL) >> 8)  | ((X & 0x0000FF0000000000ULL) >> 24) | \
						((X & 0x00FF000000000000ULL) >> 40) | ((X & 0xFF00000000000000ULL) >> 56)
#else
#define	BYTE_SWAP8(X)	((X & 0x00000000000000FF) << 56) | ((X & 0x000000000000FF00) << 40) | \
                        ((X & 0x0000000000FF0000) << 24) | ((X & 0x00000000FF000000) << 8) | \
						((X & 0x000000FF00000000) >> 8)  | ((X & 0x0000FF0000000000) >> 24) | \
						((X & 0x00FF000000000000) >> 40) | ((X & 0xFF00000000000000) >> 56)
#endif

/* From codestream to int values */
#define STREAM_TO_UINT32(C, P)	(((unsigned long int) (C)[(P) + 0] << 24) + \
								((unsigned long int) (C)[(P) + 1] << 16) + \
								((unsigned long int) (C)[(P) + 2] << 8) + \
								((unsigned long int) (C)[(P) + 3] << 0))

#define STREAM_TO_UINT16(C, P)	(((unsigned long int) (C)[(P) + 0] << 8) + \
								((unsigned long int) (C)[(P) + 1] << 0))

#define OPJREAD_LONG(F,L,N) { \
							if (F->Read(fourbytes, 4) < 4) { \
								wxLogMessage(wxT("Problem reading " N " from the file (file ended?)")); \
								return -1; \
							}; \
							L = STREAM_TO_UINT32(fourbytes, 0); \
							}

/* handling functions */
#define ITEM_PER_ROW	10

//#define indprint	if (0) printf("%.*s", 2 * level + 9, indent), printf
char    indent[] =  "                                                                   "
					"                                                                   "
					"                                                                   "
					"                                                                   ";

void indprint(wxString printout, int level)
{
	wxLogMessage(/*wxString::Format(wxT("%.*s"), 2 * level + 9, indent) + */printout);
}

/* Box handler function */
int OPJParseThread::box_handler_function(int boxtype, wxFile *fileid, wxFileOffset filepoint, wxFileOffset filelimit,
						 wxTreeItemId parentid, int level, char *scansign, unsigned long int *scanpoint)
{
	switch ((j22boxtype) boxtype) {


	/* JPEG 2000 Signature box */
	case (JP_BOX): {

			unsigned long int checkdata = 0;
			fileid->Read(&checkdata, sizeof(unsigned long int));
			checkdata = BYTE_SWAP4(checkdata);

			// add info
			wxTreeItemId currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Check data: %X -> %s"), checkdata, (checkdata == 0x0D0A870A) ? wxT("OK") : wxT("KO")),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);

		};
		break;


	/* JPEG 2000 codestream box */
	case (JP2C_BOX): {

			// add info
			wxTreeItemId currid = m_tree->AppendItem(parentid,
				wxString(wxT("Codestream")),
				m_tree->TreeCtrlIcon_Folder, m_tree->TreeCtrlIcon_Folder + 1,
				new OPJMarkerData(wxT("INFO-CSTREAM"), m_tree->m_fname.GetFullPath(), filepoint, filelimit)
				);

			m_tree->SetItemHasChildren(currid);

			// parse the file
			//ParseJ2KFile(fileid, filepoint, filelimit, currid);

		};
		break;





	/* File Type box */
	case (FTYP_BOX): {

			char BR[4], CL[4];
			unsigned long int MinV, numCL, i;
			fileid->Read(BR, sizeof(char) * 4);
			fileid->Read(&MinV, sizeof(unsigned long int));
			MinV = BYTE_SWAP4(MinV);
			numCL = (filelimit - fileid->Tell()) / 4;				

			// add info
			wxTreeItemId currid = m_tree->AppendItem(parentid,
				wxT("Brand/Minor version: ") +
				wxString::FromAscii(BR).Truncate(4) +
				wxString::Format(wxT("/%d"), MinV),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);

			currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Compatibility list")),
				m_tree->TreeCtrlIcon_Folder, m_tree->TreeCtrlIcon_Folder + 1,
				new OPJMarkerData(wxT("INFO"))
				);

			for (i = 0; i < numCL; i++) {
				fileid->Read(CL, sizeof(char) * 4);
				m_tree->AppendItem(currid,
					wxString::FromAscii(CL).Truncate(4),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
			};
			
		};
		break;



	/* JP2 Header box */
	case (IHDR_BOX): {

			unsigned long int height, width;
			unsigned short int nc;
			unsigned char bpc, C, UnkC, IPR;
			fileid->Read(&height, sizeof(unsigned long int));
			height = BYTE_SWAP4(height);
			fileid->Read(&width, sizeof(unsigned long int));
			width = BYTE_SWAP4(width);
			fileid->Read(&nc, sizeof(unsigned short int));
			nc = BYTE_SWAP2(nc);
			fileid->Read(&bpc, sizeof(unsigned char));
			fileid->Read(&C, sizeof(unsigned char));
			fileid->Read(&UnkC, sizeof(unsigned char));
			fileid->Read(&IPR, sizeof(unsigned char));
			
			// add info
			wxTreeItemId currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Dimensions: %d x %d x %d @ %d bpc"), width, height, nc, bpc + 1),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);

			currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Compression type: %d"), C),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);

			currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Colourspace unknown: %d"), UnkC),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);

			currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Intellectual Property Rights: %d"), IPR),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);
			
		};
		break;



	/* Colour Specification box */
	case (COLR_BOX): {

			unsigned char METH, PREC, APPROX;
			char methdescr[80], enumcsdescr[80];
			unsigned long int EnumCS;
			fileid->Read(&METH, sizeof(unsigned char));
			switch (METH) {
			case 1:
				strcpy(methdescr, "Enumerated Colourspace");
				break;
			case 2:
				strcpy(methdescr, "Restricted ICC profile");
				break;
			default:
				strcpy(methdescr, "Unknown");
				break;
			};
			fileid->Read(&PREC, sizeof(unsigned char));
			fileid->Read(&APPROX, sizeof(unsigned char));
			if (METH != 2) {
				fileid->Read(&EnumCS, sizeof(unsigned long int));
				EnumCS = BYTE_SWAP4(EnumCS);
				switch (EnumCS) {
				case 16:
					strcpy(enumcsdescr, "sRGB");
					break;
				case 17:
					strcpy(enumcsdescr, "greyscale");
					break;
				case 18:
					strcpy(enumcsdescr, "sYCC");
					break;
				default:
					strcpy(enumcsdescr, "Unknown");
					break;
				};
			};

			// add info
			wxTreeItemId currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Specification method: %d ("), METH) +
				wxString::FromAscii(methdescr) +
				wxT(")"),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);

			currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Precedence: %d"), PREC),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);

			currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Colourspace approximation: %d"), APPROX),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);

			if (METH != 2)
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Enumerated colourspace: %d ("), EnumCS) +
					wxString::FromAscii(enumcsdescr) +
					wxT(")"),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);

			if (METH != 1)
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("ICC profile: there is one")),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);


		};
		break;




		

	/* Movie Header Box */
	case (MVHD_BOX): {

			unsigned long int version, rate, matrix[9], next_track_ID;
			unsigned short int volume;
			fileid->Read(&version, sizeof(unsigned long int));
			version = BYTE_SWAP4(version);
			if (version == 0) {
				unsigned long int creation_time, modification_time, timescale, duration;
				fileid->Read(&creation_time, sizeof(unsigned long int));
				creation_time = BYTE_SWAP4(creation_time);
				fileid->Read(&modification_time, sizeof(unsigned long int));
				modification_time = BYTE_SWAP4(modification_time);
				fileid->Read(&timescale, sizeof(unsigned long int));
				timescale = BYTE_SWAP4(timescale);
				fileid->Read(&duration, sizeof(unsigned long int));
				duration = BYTE_SWAP4(duration);
				const long unix_time = creation_time - 2082844800L;
				wxTreeItemId currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Creation time: %u (%.24s)"), creation_time, ctime(&unix_time)),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
				const long unix_time1 = modification_time - 2082844800L;
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Modification time: %u (%.24s)"), modification_time, ctime(&unix_time1)),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Timescale: %u (%.6fs)"), timescale, 1.0 / (float) timescale),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Duration: %u (%.3fs)"), duration, (float) duration / (float) timescale),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
			} else {
				int8byte creation_time, modification_time, duration;
				unsigned long int timescale;
				fileid->Read(&creation_time, sizeof(int8byte));
				creation_time = BYTE_SWAP8(creation_time);
				fileid->Read(&modification_time, sizeof(int8byte));
				modification_time = BYTE_SWAP8(modification_time);
				fileid->Read(&timescale, sizeof(unsigned long int));
				timescale = BYTE_SWAP4(timescale);
				fileid->Read(&duration, sizeof(int8byte));
				duration = BYTE_SWAP8(duration);
				wxTreeItemId currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Creation time: %u"), creation_time),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Modification time: %u"), modification_time),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Timescale: %u"), timescale),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Duration: %u"), duration),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
			};
			fileid->Read(&rate, sizeof(unsigned long int));
			rate = BYTE_SWAP4(rate);
			fileid->Read(&volume, sizeof(unsigned short int));
			volume = BYTE_SWAP2(volume);
			fileid->Seek(6, wxFromCurrent);
			fileid->Read(&matrix, sizeof(unsigned char) * 9);
			fileid->Seek(4, wxFromCurrent);
			fileid->Read(&next_track_ID, sizeof(unsigned long int));
			next_track_ID = BYTE_SWAP4(next_track_ID);
			wxTreeItemId currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Rate: %d (%d.%d)"), rate, rate >> 16, rate & 0x0000FFFF),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);
			currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Volume: %d (%d.%d)"), volume, volume >> 8, volume & 0x00FF),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);
			currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Next track ID: %d"), next_track_ID),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);
		};
		break;


			/* Sample Description box */
	case (STSD_BOX): {

			unsigned long int version, entry_count;
			fileid->Read(&version, sizeof(unsigned long int));
			version = BYTE_SWAP4(version);
			fileid->Read(&entry_count, sizeof(unsigned long int));
			entry_count = BYTE_SWAP4(entry_count);
			wxTreeItemId currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Entry count: %d"), entry_count),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"), m_tree->m_fname.GetFullPath(), filepoint, filelimit)
				);
			jpeg2000parse(fileid, filepoint + 8, filelimit, parentid, level + 1, scansign, scanpoint);
		};
		break;


			/* Sample Size box */
	case (STSZ_BOX): {

			unsigned long int version, sample_size, sample_count, entry_size;
			
			fileid->Read(&version, sizeof(unsigned long int));
			version = BYTE_SWAP4(version);
			
			fileid->Read(&sample_size, sizeof(unsigned long int));
			sample_size = BYTE_SWAP4(sample_size);

			if (sample_size == 0) {
				fileid->Read(&sample_count, sizeof(unsigned long int));
				sample_count = BYTE_SWAP4(sample_count);

				wxTreeItemId currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Sample count: %d"), sample_count),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"), m_tree->m_fname.GetFullPath(), filepoint, filelimit)
					);

				currid = m_tree->AppendItem(parentid,
					wxT("Entries size (bytes)"),
					m_tree->TreeCtrlIcon_Folder, m_tree->TreeCtrlIcon_Folder + 1,
					new OPJMarkerData(wxT("INFO"), m_tree->m_fname.GetFullPath(), filepoint, filelimit)
					);

				wxString text;
				for (unsigned int s = 0; s < sample_count; s++) {
					fileid->Read(&entry_size, sizeof(unsigned long int));
					entry_size = BYTE_SWAP4(entry_size);
					
					text << wxString::Format(wxT("%d, "), entry_size);

					if (((s % 10) == (ITEM_PER_ROW - 1)) || (s == (sample_count - 1))) {
						m_tree->AppendItem(currid,
							text,
							m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
							new OPJMarkerData(wxT("INFO"), m_tree->m_fname.GetFullPath(), filepoint, filelimit)
							);
						text = wxT("");
					}

				}
				
			}

		};
		break;


			/* Video Media Header box */
	case (VMHD_BOX): {

			unsigned long int version;
			unsigned short int graphicsmode, opcolor[3];
			char graphicsdescr[100];

			fileid->Read(&version, sizeof(unsigned long int));
			version = BYTE_SWAP4(version);

			fileid->Read(&graphicsmode, sizeof(unsigned short int));
			graphicsmode = BYTE_SWAP2(graphicsmode);
			switch (graphicsmode) {
			case (0x00):
					strcpy(graphicsdescr, "copy");
					break;
			case (0x24):
					strcpy(graphicsdescr, "transparent");
					break;
			case (0x0100):
					strcpy(graphicsdescr, "alpha");
					break;
			case (0x0101):
					strcpy(graphicsdescr, "whitealpha");
					break;
			case (0x0102):
					strcpy(graphicsdescr, "blackalpha");
					break;
			default:
					strcpy(graphicsdescr, "unknown");
					break;
			};

			fileid->Read(opcolor, 3 * sizeof(unsigned short int));
			opcolor[0] = BYTE_SWAP2(opcolor[0]);
			opcolor[1] = BYTE_SWAP2(opcolor[1]);
			opcolor[2] = BYTE_SWAP2(opcolor[2]);

			wxTreeItemId currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Composition mode: %d (")) + 
				wxString::FromAscii(graphicsdescr) +
				wxT(")"),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"), m_tree->m_fname.GetFullPath(), filepoint, filelimit)
				);

			currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("OP color: %d %d %d"), opcolor[0], opcolor[1], opcolor[2]),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"), m_tree->m_fname.GetFullPath(), filepoint, filelimit)
				);
		};
		break;



			/* MJP2 Sample Description box */
	case (MJP2_BOX): {

			unsigned short int height, width, depth;
			unsigned long int horizresolution, vertresolution;
			char compressor_name[32];
			fileid->Seek(24, wxFromCurrent);
			fileid->Read(&width, sizeof(unsigned short int));
			width = BYTE_SWAP2(width);
			fileid->Read(&height, sizeof(unsigned short int));
			height = BYTE_SWAP2(height);
			fileid->Read(&horizresolution, sizeof(unsigned long int));
			horizresolution = BYTE_SWAP4(horizresolution);
			fileid->Read(&vertresolution, sizeof(unsigned long int));
			vertresolution = BYTE_SWAP4(vertresolution);
			fileid->Seek(6, wxFromCurrent);
			fileid->Read(compressor_name, sizeof(char) * 32);
			fileid->Read(&depth, sizeof(unsigned short int));
			depth = BYTE_SWAP2(depth);
			wxTreeItemId currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Dimensions: %d x %d @ %d bpp"), width, height, depth),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"), m_tree->m_fname.GetFullPath(), filepoint, filelimit)
				);
			currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Resolution: %d.%d x %d.%d"), horizresolution >> 16, horizresolution & 0x0000FFFF,
				vertresolution >> 16, vertresolution & 0x0000FFFF),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);
			currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Compressor: %.32s"), compressor_name),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);
			jpeg2000parse(fileid, filepoint + 78, filelimit, parentid, level + 1, scansign, scanpoint);

		};
		break;

		/* Media Header box */
	case (MDHD_BOX): {
			unsigned long int version;
			unsigned short int language;
			fileid->Read(&version, sizeof(unsigned long int));
			version = BYTE_SWAP4(version);
			if (version == 0) {
				unsigned long int creation_time, modification_time, timescale, duration;
				fileid->Read(&creation_time, sizeof(unsigned long int));
				creation_time = BYTE_SWAP4(creation_time);
				fileid->Read(&modification_time, sizeof(unsigned long int));
				modification_time = BYTE_SWAP4(modification_time);
				fileid->Read(&timescale, sizeof(unsigned long int));
				timescale = BYTE_SWAP4(timescale);
				fileid->Read(&duration, sizeof(unsigned long int));
				duration = BYTE_SWAP4(duration);
				const long unix_time = creation_time - 2082844800L;
				wxTreeItemId currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Creation time: %u (%.24s)"), creation_time, ctime(&unix_time)),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
				const long unix_time1 = modification_time - 2082844800L;
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Modification time: %u (%.24s)"), modification_time, ctime(&unix_time1)),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Timescale: %u (%.6fs)"), timescale, 1.0 / (float) timescale),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Duration: %u (%.3fs)"), duration, (float) duration / (float) timescale),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
			} else {
				int8byte creation_time, modification_time, duration;
				unsigned long int timescale;
				fileid->Read(&creation_time, sizeof(int8byte));
				creation_time = BYTE_SWAP8(creation_time);
				fileid->Read(&modification_time, sizeof(int8byte));
				modification_time = BYTE_SWAP8(modification_time);
				fileid->Read(&timescale, sizeof(unsigned long int));
				timescale = BYTE_SWAP4(timescale);
				fileid->Read(&duration, sizeof(int8byte));
				duration = BYTE_SWAP8(duration);
				wxTreeItemId currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Creation time: %u"), creation_time),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Modification time: %u"), modification_time),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Timescale: %u"), timescale),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
				currid = m_tree->AppendItem(parentid,
					wxString::Format(wxT("Duration: %u"), duration),
					m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
					new OPJMarkerData(wxT("INFO"))
					);
			}
			fileid->Read(&language, sizeof(unsigned short int));

			wxTreeItemId currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Language: %d (%c%c%c)"), language & 0xEFFF,
				0x60 + (char) ((language >> 10) & 0x001F), 0x60 + (char) ((language >> 5) & 0x001F), 0x60 + (char) ((language >> 0) & 0x001F)),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);
		};
		break;
		
		/* Media Handler box */
	case (HDLR_BOX): {
			unsigned long int version, predefined, temp[3];
			char handler[4], name[256];
			int namelen = wxMin(256, (filelimit - filepoint - 24));
			fileid->Read(&version, sizeof(unsigned long int));
			version = BYTE_SWAP4(version);
			fileid->Read(&predefined, sizeof(unsigned long int));
			fileid->Read(handler, 4 * sizeof(char));
			fileid->Read(&temp, 3 * sizeof(unsigned long int));
			fileid->Read(name, namelen * sizeof(char));

			wxTreeItemId currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Handler: %.4s"), handler),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);
					 
			currid = m_tree->AppendItem(parentid,
				wxString::Format(wxT("Name: %.255s"), name),
				m_tree->TreeCtrlIcon_File, m_tree->TreeCtrlIcon_File + 1,
				new OPJMarkerData(wxT("INFO"))
				);
					 				 
		}
		break;

	/* not yet implemented */
	default:
		break;

	};

	return (0);
}


void OPJParseThread::ParseJP2File(wxFile *fileid, wxFileOffset filepoint, wxFileOffset filelimit, wxTreeItemId parentid)
{
	unsigned long int scanpoint;

	jpeg2000parse(fileid, filepoint, filelimit, parentid, 0, NULL, &scanpoint);
}

/* the parsing function itself */
/*
  fileid    = fid of the file to scan (you should open it by yourself)
  filepoint = first byte where to start to scan from (usually 0)
  filelimit = first byte where to stop to scan from (usually the file size)
  level     = set this to 0
  scansign  = signature to scan for (NULL avoids search, returns "    " if successful)
  scanpoint = point where the scan signature lies
*/
int OPJParseThread::jpeg2000parse(wxFile *fileid, wxFileOffset filepoint, wxFileOffset filelimit,
								  wxTreeItemId parentid, int level, char *scansign, unsigned long int *scanpoint)
{
	unsigned long int       LBox = 0x00000000;
	//int                     LBox_read;
	char                    TBox[5] = "\0\0\0\0";
	//int                     TBox_read;
	int8byte				XLBox = 0x0000000000000000;
	//int                     XLBox_read;
	unsigned long int       box_length = 0;
	int                     last_box = 0, box_num = 0;
	int                     box_type = ANY_BOX;
	unsigned char           /*onebyte[1], twobytes[2],*/ fourbytes[4];

	/* cycle all over the file */
	box_num = 0;
	last_box = 0;
	while (!last_box) {

		/* do not exceed file limit */
		if (filepoint >= filelimit)
			return (0);

		/* seek on file */
		if (fileid->Seek(filepoint, wxFromStart) == wxInvalidOffset)
			return (-1);

		/* read the mandatory LBox, 4 bytes */
		if (fileid->Read(fourbytes, 4) < 4) {
			WriteText(wxT("Problem reading LBox from the file (file ended?)"));
			return -1;
		};
		LBox = STREAM_TO_UINT32(fourbytes, 0);

		/* read the mandatory TBox, 4 bytes */
		if (fileid->Read(TBox, 4) < 4) {
			WriteText(wxT("Problem reading TBox from the file (file ended?)"));
			return -1;
		};

		/* look if scansign is got */
		if ((scansign != NULL) && (memcmp(TBox, scansign, 4) == 0)) {
			memcpy(scansign, "    ", 4);
			*scanpoint = filepoint;

			/* hack/exploit */
			// stop as soon as you find the codebox
			return (0);

		};

		/* determine the box type */
		for (box_type = JP_BOX; box_type < UNK_BOX; box_type++)
			if (memcmp(TBox, j22box[box_type].value, 4) == 0)
				break;	

		/* read the optional XLBox, 8 bytes */
		if (LBox == 1) {

			if (fileid->Read(&XLBox, 8) < 8) {
				WriteText(wxT("Problem reading XLBox from the file (file ended?)"));
				return -1;
			};
			box_length = (unsigned long int) BYTE_SWAP8(XLBox);

		} else if (LBox == 0x00000000) {

			/* last box in file */
			last_box = 1; 
			box_length = filelimit - filepoint;

		} else

			box_length = LBox;

		/* show box info */

		// append the marker
		int image, imageSel;
		image = m_tree->TreeCtrlIcon_Folder;
		imageSel = image + 1;
		wxTreeItemId currid = m_tree->AppendItem(parentid,
			wxString::Format(wxT("%03d: "), box_num) +
			wxString::FromAscii(TBox) +
			wxString::Format(wxT(" (0x%04X)"),
				((unsigned long int) TBox[3]) + ((unsigned long int) TBox[2] << 8) +
				((unsigned long int) TBox[1] << 16) + ((unsigned long int) TBox[0] << 24)
			),
			image, imageSel,
			new OPJMarkerData(wxT("BOX"), m_tree->m_fname.GetFullPath(), filepoint, filepoint + box_length)
			);

		// append some info
		image = m_tree->TreeCtrlIcon_File;
		imageSel = image + 1;

		// box name
		wxTreeItemId subcurrid1 = m_tree->AppendItem(currid,
			wxT("*** ") + wxString::FromAscii(j22box[box_type].name) + wxT(" ***"),
			image, imageSel,
			new OPJMarkerData(wxT("INFO"))
			);
		m_tree->SetItemFont(subcurrid1, *wxITALIC_FONT);

		// position and length
		wxTreeItemId subcurrid2 = m_tree->AppendItem(currid,
			wxLongLong(filepoint).ToString() + wxT(" > ") + wxLongLong(filepoint + box_length - 1).ToString() + 
			wxT(", ") + wxString::Format(wxT("%d + 8 (%d)"), box_length, box_length + 8),
			image, imageSel,
			new OPJMarkerData(wxT("INFO"))
			);

		/* go deep in the box */
		box_handler_function((int) box_type, fileid, (LBox == 1) ? (filepoint + 16) : (filepoint + 8), filepoint + box_length,
			currid, level, scansign, scanpoint);

		/* if it's a superbox go inside it */
		if (j22box[box_type].sbox)
			jpeg2000parse(fileid, (LBox == 1) ? (filepoint + 16) : (filepoint + 8), filepoint + box_length,
				currid, level + 1, scansign, scanpoint);

		/* increment box number and filepoint*/
		box_num++;
		filepoint += box_length;

	};

	/* all good */
	return (0);
}

