// Parse the marker in from the JP2 file.
CNCSError CNCSJPCRGNMarker::Parse(CNCSJPC &JPC, CNCSJPCIOStream &Stream)
{
CNCSError Error;
m_bHaveMarker = true;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO(ReadUINT16(m_nLength));
UINT8 t8;
if(JPC.m_SIZ.m_nCsiz < 257) {
NCSJP2_CHECKIO(ReadUINT8(t8));
m_nCrgn = t8;
} else {
NCSJP2_CHECKIO(ReadUINT16(m_nCrgn));
}
NCSJP2_CHECKIO(ReadUINT8(t8));
if(t8 == 0x0) {
m_eSrgn = IMPLICIT;
NCSJP2_CHECKIO(ReadUINT8(m_nSPrgn));
} else {
Error = NCS_FILEIO_ERROR;
}
if(Error == NCS_SUCCESS) {
m_bValid = true;
}
NCSJP2_CHECKIO_END();
return(Error);
}
// UnParse the box to the stream
CNCSError CNCSJP2File::CNCSJP2SignatureBox::UnParse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream)
{
CNCSError Error;
Error = CNCSJP2Box::UnParse(JP2File, Stream);
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO(WriteUINT32(sm_JP2Signature));
NCSJP2_CHECKIO_END();
return(Error);
}
CNCSError JP2UUID3DNBox::UnParse(CNCSJP2File &JP2File, CNCSJPCIOStream &Stream)
{
CNCSError Error;
Error = CNCSJP2Box::UnParse(JP2File, Stream);
NCSJP2_CHECKIO_BEGIN(Error, Stream);
Stream.WriteIEEE8(_OrigMaxVal);
Stream.WriteIEEE8(_OrigMinVal);
Stream.WriteUINT32(_NormalizedMaxVal);
Stream.WriteUINT32(_NormalizedMinVal);
NCSJP2_CHECKIO_END();
return(Error);
} // JP2UUID3DNBox::UnParse
// UnParse the marker out to the stream.
CNCSError CNCSJPCSOPMarker::UnParse(CNCSJPC &JPC, CNCSJPCIOStream &Stream)
{
CNCSError Error;
m_nLength = 4;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO_ERROR(CNCSJPCMarker::UnParse(JPC, Stream));
NCSJP2_CHECKIO(WriteUINT16(m_nLength));
NCSJP2_CHECKIO(WriteUINT16(m_nNsop));
NCSJP2_CHECKIO_END();
return(Error);
}
// UnParse the marker out to the stream.
CNCSError CNCSJPCCRGMarker::UnParse(CNCSJPC &JPC, CNCSJPCIOStream &Stream)
{
CNCSError Error;
Error = CNCSJPCMarker::UnParse(JPC, Stream);
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO(WriteUINT16(m_nLength));
for(int i = 0; i < JPC.m_SIZ.m_nCsiz; i++) {
NCSJP2_CHECKIO(WriteUINT16(m_Offsets[i].m_nXcrg));
NCSJP2_CHECKIO(WriteUINT16(m_Offsets[i].m_nYcrg));
}
NCSJP2_CHECKIO_END();
return(Error);
}
// UnParse the marker out to the stream.
CNCSError CNCSJPCPPTMarker::UnParse(CNCSJPC &JPC, CNCSJPCIOStream &Stream)
{
CNCSError Error;
Error = CNCSJPCMarker::UnParse(JPC, Stream);
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO(WriteUINT16(m_nLength));
NCSJP2_CHECKIO(WriteUINT8(m_nZppt));
// for(UINT32 i = 0; i < m_Headers.size(); i++) {
// NCSJP2_CHECKIO_ERROR(m_Headers[i].UnParse(JPC, Stream));
// }
NCSJP2_CHECKIO_END();
return(Error);
}
// Unparse the box out to the stream.
CNCSError CNCSJP2File::CNCSJP2HeaderBox::CNCSJP2BitsPerComponentBox::UnParse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream)
{
CNCSError Error;
// Setup the base box members
// Write out the base box
Error = CNCSJP2Box::UnParse(JP2File, Stream);
NCSJP2_CHECKIO_BEGIN(Error, Stream);
// For each component, write out the bit depth.
for(UINT32 c = 0; c < m_Bits.size(); c++) {
m_Bits[c].UnParse(JP2File.m_Codestream, Stream);
}
NCSJP2_CHECKIO_END();
return(Error);
}
// Parse the marker in from the JP2 file.
CNCSError CNCSJPCSOPMarker::Parse(CNCSJPC &JPC, CNCSJPCIOStream &Stream)
{
CNCSError Error;
Error = CNCSJPCMarker::Parse(JPC, Stream);
if(Error == NCS_SUCCESS && m_eMarker == SOP) {
m_bHaveMarker = true;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO(ReadUINT16(m_nLength));
NCSJP2_CHECKIO(ReadUINT16(m_nNsop));
m_bValid = true;
NCSJP2_CHECKIO_END();
}
return(NCS_SUCCESS);
}
// Parse the box in from the stream
CNCSError CNCSJP2File::CNCSJP2HeaderBox::CNCSJP2BitsPerComponentBox::Parse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream)
{
CNCSError Error;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
// For each component in the image, read in the bit depth
for(int c = 0; c < JP2File.m_Header.m_ImageHeader.m_nComponents; c++) {
CNCSJPCComponentDepthType ci;
NCSJP2_CHECKIO_ERROR(ci.Parse(JP2File.m_Codestream, Stream));
// Store the bit depth into the m_Bits member.
m_Bits.push_back(ci);
}
m_bValid = true;
NCSJP2_CHECKIO_END();
return(Error);
}
// UnParse the color spec box out to the stream.
CNCSError CNCSJP2File::CNCSJP2UUIDInfoBox::CNCSJP2UUIDListBox::UnParse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream)
{
CNCSError Error;
// Setup the base box.
m_nTBox = sm_nTBox;
m_nXLBox = 8 + sizeof(UINT16) + m_nEntries * sizeof(m_UUIDs[0].m_UUID);
// Write out the base box first
Error = CNCSJP2Box::UnParse(JP2File, Stream);
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO(WriteUINT16(m_nEntries));
for(int c = 0; c < m_nEntries; c++) {
NCSJP2_CHECKIO(Write(m_UUIDs[c].m_UUID, sizeof(m_UUIDs[0].m_UUID)));
}
NCSJP2_CHECKIO_END();
return(Error);
}
// Parse the box in from the stream.
CNCSError CNCSJP2File::CNCSJP2UUIDInfoBox::CNCSJP2UUIDListBox::Parse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream)
{
CNCSError Error;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
// Get the fields in
NCSJP2_CHECKIO(ReadUINT16(m_nEntries));
for(int e = 0; e < m_nEntries; e++) {
NCSUUID uuid;
NCSJP2_CHECKIO(Read(&uuid.m_UUID, sizeof(uuid.m_UUID)));
m_UUIDs.push_back(uuid);
}
m_bValid = true;
NCSJP2_CHECKIO_END();
return(Error);
}
// UnParse the marker out to the stream.
CNCSError CNCSJPCComponentDepthType::UnParse(CNCSJPC &JPC, CNCSJPCIOStream &Stream)
{
&JPC;//Keep compiler happy
CNCSError Error;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
if(m_nBits != 255) {
UINT8 nSsiz = m_nBits - 1;
if(m_bSigned) {
nSsiz |= 0x80;
}
NCSJP2_CHECKIO(WriteUINT8(nSsiz));
} else {
NCSJP2_CHECKIO(WriteUINT8(255));
}
NCSJP2_CHECKIO_END();
return(Error);
}
// UnParse the box to the stream
CNCSError CNCSJP2File::CNCSJP2GMLGeoLocationBox::UnParse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream)
{
#ifdef NCS_BUILD_WITH_STDERR_DEBUG_INFO
fprintf(stderr,"UnParsing GML box information\n");
#endif
char buf[1024];
CNCSError Error = FormatXML(buf, sizeof(buf));
if(Error == NCS_SUCCESS) {
Error = CNCSJP2Box::UnParse(JP2File, Stream);
NCSJP2_CHECKIO_BEGIN(Error, Stream);
Stream.Write(buf, (UINT32)strlen(buf));
NCSJP2_CHECKIO_END();
}
return(Error);
}
// Parse the marker in from the JP2 file.
CNCSError CNCSJPCComponentDepthType::Parse(CNCSJPC &JPC, CNCSJPCIOStream &Stream)
{
&JPC;//Keep compiler happy
CNCSError Error;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO(ReadUINT8(m_nBits));
if(m_nBits != 255) {
if(m_nBits & 0x80) {
m_bSigned = true;
} else {
m_bSigned = false;
}
m_nBits = (m_nBits & 0x7f) + 1;
}
NCSJP2_CHECKIO_END();
return(Error);
}
// UnParse the marker out to the stream.
CNCSError CNCSJPCRGNMarker::UnParse(CNCSJPC &JPC, CNCSJPCIOStream &Stream)
{
CNCSError Error;
Error = CNCSJPCMarker::UnParse(JPC, Stream);
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO(WriteUINT16(m_nLength));
if(JPC.m_SIZ.m_nCsiz < 257) {
NCSJP2_CHECKIO(WriteUINT8((UINT8)m_nCrgn));
} else {
NCSJP2_CHECKIO(WriteUINT16(m_nCrgn));
}
NCSJP2_CHECKIO(WriteUINT8((UINT8)m_eSrgn));
NCSJP2_CHECKIO(WriteUINT8(m_nSPrgn));
NCSJP2_CHECKIO_END();
return(Error);
}
// Parse the marker in from the JP2 file.
CNCSError CNCSJPCPPTMarker::Parse(CNCSJPC &JPC, CNCSJPCIOStream &Stream)
{
&JPC;//Keep compiler happy
CNCSError Error;
m_bHaveMarker = true;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO(ReadUINT16(m_nLength));
NCSJP2_CHECKIO(ReadUINT8(m_nZppt));
NCSJP2_CHECKIO(Seek(m_nLength - (sizeof(UINT16) + sizeof(UINT8))));
if(Error == NCS_SUCCESS) {
m_bValid = true;
}
NCSJP2_CHECKIO_END();
return(Error);
}
CNCSError JP2UUID3DNBox::Parse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream)
{
CNCSError Error;
//See NCSJPCIOStream.h to get an understanding of these macros
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO(Read(m_UUID.m_UUID, sizeof(m_UUID.m_UUID)));
if (m_UUID == sm_UUID)
{
Stream.ReadIEEE8(_OrigMaxVal);
Stream.ReadIEEE8(_OrigMinVal);
Stream.ReadUINT32(_NormalizedMaxVal);
Stream.ReadUINT32(_NormalizedMinVal);
} // if
NCSJP2_CHECKIO_END();
return(Error);
} // JP2UUID3DNBox::Parse
// Parse the box from the stream
CNCSError CNCSJP2File::CNCSJP2SignatureBox::Parse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream)
{
CNCSError Error;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
// UINT8 buf[4];
// Read in the signature
// NCSJP2_CHECKIO(Read(buf, 4));
UINT32 buf;
NCSJP2_CHECKIO(ReadUINT32(buf));
if(memcmp(&sm_JP2Signature, &buf, sizeof(buf)) == 0) {
// Signature is valid
m_bValid = true;
} else {
Error = NCS_FILE_INVALID;
}
NCSJP2_CHECKIO_END();
return(Error);
}
// Parse the marker in from the JP2 file.
CNCSError CNCSJPCCRGMarker::Parse(CNCSJPC &JPC, CNCSJPCIOStream &Stream)
{
CNCSError Error;
m_bHaveMarker = true;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO(ReadUINT16(m_nLength));
for(int i = 0; i < JPC.m_SIZ.m_nCsiz; i++) {
Registration reg;
NCSJP2_CHECKIO(ReadUINT16(reg.m_nXcrg));
NCSJP2_CHECKIO(ReadUINT16(reg.m_nYcrg));
m_Offsets.push_back(reg);
}
if(Error == NCS_SUCCESS) {
m_bValid = true;
}
NCSJP2_CHECKIO_END();
return(Error);
}
// UnParse the marker out to the stream.
CNCSError CNCSJPCMainHeader::UnParse(CNCSJPC &JPC, CNCSJPCIOStream &Stream)
{
CNCSError Error;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
NCSJP2_CHECKIO_ERROR(m_SOC.UnParse(JPC, Stream));
NCSJP2_CHECKIO_ERROR(m_SIZ.UnParse(JPC, Stream));
NCSJP2_CHECKIO_ERROR(m_COD.UnParse(JPC, Stream));
NCSJP2_CHECKIO_ERROR(m_QCD.UnParse(JPC, Stream));
NCSJP2_CHECKIO_ERROR(m_COM.UnParse(JPC, Stream));
if(false && m_COD.m_SGcod.m_bMCT) {
CNCSJPCQCCMarker QCC = m_QuantizationStyles[1];
QCC.m_nCqcc = 1;
// if(
QCC.m_nLength = 5 + 3 * JPC.m_CodingStyles[1].m_SPcod.m_nLevels;
NCSJP2_CHECKIO_ERROR(QCC.UnParse(JPC, Stream));
QCC = m_QuantizationStyles[2];
QCC.m_nCqcc = 2;
NCSJP2_CHECKIO_ERROR(QCC.UnParse(JPC, Stream));
}
NCSJP2_CHECKIO_END();
return(Error);
}
// Parse the marker in from the JP2 file.
CNCSError CNCSJPCMainHeader::Parse(CNCSJPC &JPC, CNCSJPCIOStream &Stream)
{
CNCSError Error;
CNCSJPCMarker marker;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
Error = marker.Parse(JPC, Stream);
if(Error == NCS_SUCCESS) {
if(marker.m_eMarker == CNCSJPCMarker::SOC) {
(CNCSJPCMarker&)m_SOC = marker;
NCSJP2_CHECKIO_ERROR(m_SOC.Parse(JPC, Stream));
NCSJP2_CHECKIO_ERROR(marker.Parse(JPC, Stream));
if(marker.m_eMarker == CNCSJPCMarker::SIZ) {
(CNCSJPCMarker&)m_SIZ = marker;
NCSJP2_CHECKIO_ERROR(m_SIZ.Parse(JPC, Stream));
//initialize JPC.m_Tiles
if( JPC.m_Tiles.size() == 0 ) {
INT32 nNumTiles = JPC.GetNumXTiles() * JPC.GetNumYTiles();
JPC.m_Tiles.reserve( nNumTiles );
for( int i=0; i < nNumTiles; i++ ) {
JPC.m_Tiles.push_back(NULL);
}
}
while(Error == NCS_SUCCESS && !m_EOC.m_bValid) {
NCSJP2_CHECKIO_ERROR(marker.Parse(JPC, Stream));
switch(marker.m_eMarker) {
case CNCSJPCMarker::COD:
if(!m_COD.m_bHaveMarker) {
(CNCSJPCMarker&)m_COD = marker;
NCSJP2_CHECKIO_ERROR(m_COD.Parse(JPC, Stream));
// Setup default coding style for each component
m_CodingStyles.resize(m_SIZ.m_nCsiz, m_COD);
} else {
Error = NCS_FILEIO_ERROR;
}
break;
case CNCSJPCMarker::COC:
if(m_COD.m_bValid) {
CNCSJPCCOCMarker COC;
(CNCSJPCMarker&)COC = marker;
NCSJP2_CHECKIO_ERROR(COC.Parse(JPC, Stream));
// Over-ride coding style for this component
m_CodingStyles[COC.m_nCcoc] = COC;
} else {
// COD *must* be before COC
Error = NCS_FILEIO_ERROR;
}
break;
case CNCSJPCMarker::QCD:
if(!m_QCD.m_bHaveMarker) {
(CNCSJPCMarker&)m_QCD = marker;
NCSJP2_CHECKIO_ERROR(m_QCD.Parse(JPC, Stream));
// Setup default coding style for each component
m_QuantizationStyles.resize(m_SIZ.m_nCsiz, m_QCD);
} else {
Error = NCS_FILEIO_ERROR;
}
break;
case CNCSJPCMarker::QCC:
if(m_QCD.m_bValid) {
CNCSJPCQCCMarker QCC;
(CNCSJPCMarker&)QCC = marker;
NCSJP2_CHECKIO_ERROR(QCC.Parse(JPC, Stream));
// Over-ride quantization style for this component
m_QuantizationStyles[QCC.m_nCqcc] = QCC;
} else {
// QCD *must* be before QCC
Error = NCS_FILEIO_ERROR;
}
break;
case CNCSJPCMarker::RGN:
{
CNCSJPCRGNMarker RGN;
(CNCSJPCMarker&)RGN = marker;
NCSJP2_CHECKIO_ERROR(RGN.Parse(JPC, Stream));
m_RGNs.resize(m_SIZ.m_nCsiz);
m_RGNs[RGN.m_nCrgn] = RGN;
}
break;
case CNCSJPCMarker::POC:
if(!m_POC.m_bHaveMarker) {
(CNCSJPCMarker&)m_POC = marker;
NCSJP2_CHECKIO_ERROR(m_POC.Parse(JPC, Stream));
} else {
Error = NCS_FILEIO_ERROR;
}
break;
case CNCSJPCMarker::PPM:
if(true)
{
m_bFilePPMs = true;
CNCSJPCPPMMarker PPM;
(CNCSJPCMarker&)PPM = marker;
NCSJP2_CHECKIO_ERROR(PPM.Parse(JPC, Stream));
m_PPMs.resize(NCSMax(m_PPMs.size(), (UINT32)PPM.m_nZppm + 1));
m_PPMs[PPM.m_nZppm] = PPM;
} else {
Error = NCS_FILEIO_ERROR;
}
break;
case CNCSJPCMarker::TLM:
{
CNCSJPCTLMMarker TLM;
(CNCSJPCMarker&)TLM = marker;
NCSJP2_CHECKIO_ERROR(TLM.Parse(JPC, Stream));
m_TLMs.resize(NCSMax(m_TLMs.size(), (UINT32)TLM.m_nZtlm + 1));
m_TLMs[TLM.m_nZtlm] = TLM;
}
break;
case CNCSJPCMarker::PLM:
{
CNCSJPCPLMMarker PLM;
(CNCSJPCMarker&)PLM = marker;
NCSJP2_CHECKIO_ERROR(PLM.Parse(JPC, Stream));
m_PLMs.resize(NCSMax(m_PLMs.size(), (UINT32)PLM.m_nZplm + 1));
m_PLMs[PLM.m_nZplm] = PLM;
}
break;
case CNCSJPCMarker::CRG:
if(!m_CRG.m_bHaveMarker) {
(CNCSJPCMarker&)m_CRG = marker;
NCSJP2_CHECKIO_ERROR(m_CRG.Parse(JPC, Stream));
} else {
// Can only have one CRG marker in the codestream
Error = NCS_FILEIO_ERROR;
}
break;
case CNCSJPCMarker::SOT:
{
CNCSJPCTilePartHeader *pTP = new CNCSJPCTilePartHeader(&JPC);
if(pTP) {
(CNCSJPCMarker&)pTP->m_SOT = marker;
JPC.m_pCurrentTilePart = pTP;
NCSJP2_CHECKIO_ERROR(pTP->Parse(JPC, Stream));
if( pTP->m_SOT.m_nTPsot == 0 ) { //first tile part
if( JPC.m_Tiles[pTP->m_SOT.m_nIsot] == NULL ) {
JPC.m_Tiles[pTP->m_SOT.m_nIsot] = pTP;
} else {
// Got TP twice, just ignore.
delete pTP;
}
} else if( JPC.m_Tiles[pTP->m_SOT.m_nIsot] ) { // other parts
if( (JPC.m_Tiles[pTP->m_SOT.m_nIsot]->m_TileParts.size() >= (pTP->m_SOT.m_nTPsot)) &&
(JPC.m_Tiles[pTP->m_SOT.m_nIsot]->m_TileParts[pTP->m_SOT.m_nTPsot] != NULL) )
{
// Got TP twice, just ignore.
delete pTP;
} else {
JPC.m_Tiles[pTP->m_SOT.m_nIsot]->m_TileParts.push_back(pTP);
}
} else {
// this shouldn't happen
Error = NCS_COULDNT_ALLOC_MEMORY;
}
} else {
Error = NCS_COULDNT_ALLOC_MEMORY;
}
}
break;
case CNCSJPCMarker::COM:
{
CNCSJPCCOMMarker COM;
(CNCSJPCMarker&)COM = marker;
NCSJP2_CHECKIO_ERROR(COM.Parse(JPC, Stream));
}
break;
case CNCSJPCMarker::EOC:
if(!m_EOC.m_bHaveMarker) {
(CNCSJPCMarker&)m_EOC = marker;
NCSJP2_CHECKIO_ERROR(m_EOC.Parse(JPC, Stream));
} else {
Error = NCS_FILEIO_ERROR;
}
break;
default:
if(marker.m_eMarker >= 0xff30 && marker.m_eMarker <= 0xff3f) {
// Skip
} else {
Error = NCS_FILEIO_ERROR;
}
break;
}
}
// if(Error == NCS_SUCCESS) {
if(m_SOC.m_bValid && m_SIZ.m_bValid && m_COD.m_bValid &&
(JPC.m_pStream->IsPacketStream() ||
(JPC.m_pCurrentTilePart && JPC.m_pCurrentTilePart->m_SOT.m_bValid))) {
m_bValid = true;
Error = NCS_SUCCESS;
}
// }
CNCSJPCTilePartHeader *pTP = JPC.GetTile(0);
while(pTP) {
if(pTP->m_bFilePPTs) {
JPC.m_pCurrentTilePart = pTP;
bool bComplete = false;
CNCSJPCPacketList Packets;
Error = Packets.Parse(JPC, Stream, bComplete, (UINT64)-1);
if(Error == NCS_SUCCESS) {
Error = Packets.GenDynamicPLTs(pTP);
Packets.clear();
}
}
pTP = JPC.GetTile(pTP->m_SOT.m_nIsot + 1);
}
} else {
Error = NCS_FILE_INVALID;
}
} else {
Error = NCS_FILE_INVALID;
}
}
if(Error == NCS_SUCCESS) {
for(int y = 0; y < GetNumYTiles(); y++) {
for(int x = 0; x < GetNumXTiles(); x++) {
CNCSJPCTilePartHeader *pTP = JPC.GetTile(x + y * GetNumXTiles());
if(pTP) {
pTP->m_nCurPacket = pTP->GetFirstPacketNr();
}
}
}
}
NCSJP2_CHECKIO_END();
return(Error);
}
// Parse the box from the stream
CNCSError CNCSJP2File::CNCSJP2GMLGeoLocationBox::Parse(class CNCSJP2File &JP2File, CNCSJPCIOStream &Stream)
{
#ifdef NCS_BUILD_WITH_STDERR_DEBUG_INFO
fprintf(stderr,"Parsing GML box information\n");
#endif
CNCSError Error(NCS_SUCCESS);
m_bValid = false;
double dRegX = 0.0;
double dRegY = 0.0;
double p1[3];
double p2[3];
UINT32 nEPSGCode = 0;
int nResults = 0;
bool bSRSAttributePresent = false;
UINT32 nImageWidth = JP2File.m_FileInfo.nSizeX;
UINT32 nImageHeight = JP2File.m_FileInfo.nSizeY;
NCSJP2_CHECKIO_BEGIN(Error, Stream);
char buf[1024 + 1];
Stream.Read(buf, NCSMin((UINT32)m_nLDBox, sizeof(buf)-1));
buf[NCSMin((UINT32)m_nLDBox, sizeof(buf)-1)] = '\0';
TiXmlDocument doc;
doc.Parse(buf);
TiXmlHandle docHandle(&doc);
TiXmlElement *GeoLocation_1 = docHandle.FirstChild("JPEG2000_GeoLocation").FirstChild("gml:RectifiedGrid").Element();//.FirstChild( "Element" ).Child( "Child", 1 ).Element();
if(GeoLocation_1 && GeoLocation_1->Attribute("gml:id") && !stricmp(GeoLocation_1->Attribute("gml:id"), "JPEG2000_GeoLocation_1")) {
TiXmlElement *OriginPoint = docHandle.FirstChild("JPEG2000_GeoLocation").FirstChild("gml:RectifiedGrid").FirstChild("gml:origin").FirstChild("gml:Point").Element();
if(OriginPoint && OriginPoint->Attribute("gml:id") && !stricmp(OriginPoint->Attribute("gml:id"), "JPEG2000_Origin")) {
const char *pTxt = OriginPoint->Attribute("srsName");
if(pTxt) {
nResults += sscanf(pTxt, "epsg:%u", &nEPSGCode);
bSRSAttributePresent = true;
}
TiXmlText *Coords = docHandle.FirstChild("JPEG2000_GeoLocation").FirstChild("gml:RectifiedGrid").FirstChild("gml:origin").FirstChild("gml:Point").FirstChild("gml:coordinates").FirstChild().Text();
if(Coords) {
pTxt = Coords->Value();
if(pTxt) {
nResults += sscanf(pTxt, "%lf,%lf", &dRegX, &dRegY);
}
}
}
TiXmlElement *offsetVector = docHandle.FirstChild("JPEG2000_GeoLocation").FirstChild("gml:RectifiedGrid").FirstChild("gml:offsetVector").Element();
if(offsetVector && offsetVector->Attribute("gml:id") && !stricmp(offsetVector->Attribute("gml:id"), "p1")) {
TiXmlText *Coords = docHandle.FirstChild("JPEG2000_GeoLocation").FirstChild("gml:RectifiedGrid").FirstChild("gml:offsetVector").FirstChild().Text();
if(Coords) {
const char *pTxt = Coords->Value();
if(pTxt) {
nResults += sscanf(pTxt, "%lf,%lf,%lf", &p1[0], &p1[1], &p1[2]);
}
}
offsetVector = (TiXmlElement*)offsetVector->NextSibling("gml:offsetVector");
if(offsetVector && offsetVector->Attribute("gml:id") && !stricmp(offsetVector->Attribute("gml:id"), "p2")) {
TiXmlText *Coords = ((TiXmlElement*)offsetVector->FirstChild())->ToText();
if(Coords) {
const char *pTxt = Coords->Value();
if(pTxt) {
nResults += sscanf(pTxt, "%lf,%lf,%lf", &p2[0], &p2[1], &p2[2]);
}
}
}
}
}
NCSJP2_CHECKIO_END();
if((nResults == 9 && bSRSAttributePresent) || (nResults == 8 && !bSRSAttributePresent)) {
IEEE8 dRegistrationX = dRegX + nImageHeight * p1[0];
IEEE8 dRegistrationY = dRegY + nImageHeight * p1[1];
if(p1[2] == 0.0 && p2[2] == 0.0) {
// p1[0] = sin(Deg2Rad(dCWRotationDegrees)) * dCellSizeX;
// p1[1] = cos(Deg2Rad(dCWRotationDegrees)) * dCellSizeY;
// p2[0] = cos(Deg2Rad(dCWRotationDegrees)) * dCellSizeX;
// p2[1] = -sin(Deg2Rad(dCWRotationDegrees)) * dCellSizeY;
double dCWRotationDegrees = Rad2Deg(atan(p1[0] / p2[0]));
double dCellSizeX = p2[0] / cos(atan(p1[0] / p2[0]));
double dCellSizeY = p1[1] / cos(atan(p1[0] / p2[0]));
m_GMLFileInfo.fOriginX = dRegistrationX;
m_GMLFileInfo.fOriginY = dRegistrationY;
m_GMLFileInfo.fCellIncrementX = dCellSizeX;
m_GMLFileInfo.fCellIncrementY = dCellSizeY;
m_GMLFileInfo.fCWRotationDegrees = dCWRotationDegrees;
CNCSGDTEPSG& Epsg = *CNCSGDTEPSG::Instance();
char *pProjection = NULL;
char *pDatum = NULL;
NCSFree(m_GMLFileInfo.szProjection);
NCSFree(m_GMLFileInfo.szDatum);
if (bSRSAttributePresent && nEPSGCode &&
(Epsg.GetProjectionAndDatum(nEPSGCode, &pProjection, &pDatum) == NCS_SUCCESS))
{
if(pProjection && pDatum)
{
m_GMLFileInfo.szProjection= NCSStrDup(pProjection);
m_GMLFileInfo.szDatum = NCSStrDup(pDatum);
NCSFree(pProjection);
NCSFree(pDatum);
}
else if (nEPSGCode) //EPSG code present but invalid or unrecognised?
{
char szEPSG[32];
*szEPSG = '\0';
sprintf(szEPSG,"epsg:%u",nEPSGCode);
m_GMLFileInfo.szProjection = NCSStrDup(szEPSG);
m_GMLFileInfo.szDatum = NCSStrDup(szEPSG);
}
}
else
{
m_GMLFileInfo.szDatum = NCSStrDup("RAW");
m_GMLFileInfo.szProjection = NCSStrDup("RAW");
}
if(stricmp(m_GMLFileInfo.szProjection, "GEODETIC") == 0)
m_GMLFileInfo.eCellSizeUnits = ECW_CELL_UNITS_DEGREES;
else
m_GMLFileInfo.eCellSizeUnits = ECW_CELL_UNITS_METERS;
}
else return NCS_JP2_GEODATA_READ_ERROR;
}
else return NCS_JP2_GEODATA_READ_ERROR;
m_bValid = true;
NCSStandardizeFileInfoEx(&m_GMLFileInfo);
return NCS_SUCCESS;
}
