static short ReadShort(VSILFILE* fp, int bOzi3 = FALSE, int nKeyInit = 0) { short nVal; VSIFReadL(&nVal, 1, 2, fp); if (bOzi3) OZIDecrypt(&nVal, 2, (GByte) nKeyInit); CPL_LSBPTR16(&nVal); return nVal; }
static short ReadShort(GByte**pptr) { short nVal; memcpy(&nVal, *pptr, 2); *pptr += 2; CPL_LSBPTR16(&nVal); return nVal; }
bool TerragenDataset::get(GUInt16& value) { if(1 == VSIFReadL(&value, sizeof(value), 1, m_fp)) { CPL_LSBPTR16(&value); return true; } return false; }
static unsigned short readUShort( VSILFILE* fp, bool *pbSuccess = nullptr ) { unsigned short val; if (VSIFReadL( &val, 1, 2, fp ) != 2) { if (pbSuccess) *pbSuccess = false; return 0; } if (pbSuccess) *pbSuccess = true; CPL_LSBPTR16(&val); return val; }
static void WriteShort(VSILFILE* fp, GInt16 val) { CPL_LSBPTR16(&val); VSIFWriteL(&val, 2, 1, fp); }
GDALDataset *HF2Dataset::Open( GDALOpenInfo * poOpenInfo ) { CPLString osOriginalFilename(poOpenInfo->pszFilename); if (!Identify(poOpenInfo)) return NULL; GDALOpenInfo* poOpenInfoToDelete = NULL; /* GZipped .hf2 files are common, so automagically open them */ /* if the /vsigzip/ has not been explicitly passed */ CPLString osFilename(poOpenInfo->pszFilename); if ((EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "hfz") || (strlen(poOpenInfo->pszFilename) > 6 && EQUAL(poOpenInfo->pszFilename + strlen(poOpenInfo->pszFilename) - 6, "hf2.gz"))) && !EQUALN(poOpenInfo->pszFilename, "/vsigzip/", 9)) { osFilename = "/vsigzip/"; osFilename += poOpenInfo->pszFilename; poOpenInfo = poOpenInfoToDelete = new GDALOpenInfo(osFilename.c_str(), GA_ReadOnly, poOpenInfo->GetSiblingFiles()); } /* -------------------------------------------------------------------- */ /* Parse header */ /* -------------------------------------------------------------------- */ int nXSize, nYSize; memcpy(&nXSize, poOpenInfo->pabyHeader + 6, 4); CPL_LSBPTR32(&nXSize); memcpy(&nYSize, poOpenInfo->pabyHeader + 10, 4); CPL_LSBPTR32(&nYSize); GUInt16 nTileSize; memcpy(&nTileSize, poOpenInfo->pabyHeader + 14, 2); CPL_LSBPTR16(&nTileSize); float fVertPres, fHorizScale; memcpy(&fVertPres, poOpenInfo->pabyHeader + 16, 4); CPL_LSBPTR32(&fVertPres); memcpy(&fHorizScale, poOpenInfo->pabyHeader + 20, 4); CPL_LSBPTR32(&fHorizScale); GUInt32 nExtendedHeaderLen; memcpy(&nExtendedHeaderLen, poOpenInfo->pabyHeader + 24, 4); CPL_LSBPTR32(&nExtendedHeaderLen); delete poOpenInfoToDelete; poOpenInfoToDelete = NULL; if (nTileSize < 8) return NULL; if (nXSize <= 0 || nXSize > INT_MAX - nTileSize || nYSize <= 0 || nYSize > INT_MAX - nTileSize) return NULL; /* To avoid later potential int overflows */ if (nExtendedHeaderLen > 1024 * 65536) return NULL; if (!GDALCheckDatasetDimensions(nXSize, nYSize)) { return NULL; } /* -------------------------------------------------------------------- */ /* Parse extended blocks */ /* -------------------------------------------------------------------- */ VSILFILE* fp = VSIFOpenL(osFilename.c_str(), "rb"); if (fp == NULL) return NULL; VSIFSeekL(fp, 28, SEEK_SET); int bHasExtent = FALSE; double dfMinX = 0, dfMaxX = 0, dfMinY = 0, dfMaxY = 0; int bHasUTMZone = FALSE; GInt16 nUTMZone = 0; int bHasEPSGDatumCode = FALSE; GInt16 nEPSGDatumCode = 0; int bHasEPSGCode = FALSE; GInt16 nEPSGCode = 0; int bHasRelativePrecision = FALSE; float fRelativePrecision = 0; char szApplicationName[256]; szApplicationName[0] = 0; GUInt32 nExtendedHeaderOff = 0; while(nExtendedHeaderOff < nExtendedHeaderLen) { char pabyBlockHeader[24]; VSIFReadL(pabyBlockHeader, 24, 1, fp); char szBlockName[16 + 1]; memcpy(szBlockName, pabyBlockHeader + 4, 16); szBlockName[16] = 0; GUInt32 nBlockSize; memcpy(&nBlockSize, pabyBlockHeader + 20, 4); CPL_LSBPTR32(&nBlockSize); if (nBlockSize > 65536) break; nExtendedHeaderOff += 24 + nBlockSize; if (strcmp(szBlockName, "georef-extents") == 0 && nBlockSize == 34) { char pabyBlockData[34]; VSIFReadL(pabyBlockData, 34, 1, fp); memcpy(&dfMinX, pabyBlockData + 2, 8); CPL_LSBPTR64(&dfMinX); memcpy(&dfMaxX, pabyBlockData + 2 + 8, 8); CPL_LSBPTR64(&dfMaxX); memcpy(&dfMinY, pabyBlockData + 2 + 8 + 8, 8); CPL_LSBPTR64(&dfMinY); memcpy(&dfMaxY, pabyBlockData + 2 + 8 + 8 + 8, 8); CPL_LSBPTR64(&dfMaxY); bHasExtent = TRUE; } else if (strcmp(szBlockName, "georef-utm") == 0 && nBlockSize == 2) { VSIFReadL(&nUTMZone, 2, 1, fp); CPL_LSBPTR16(&nUTMZone); CPLDebug("HF2", "UTM Zone = %d", nUTMZone); bHasUTMZone = TRUE; } else if (strcmp(szBlockName, "georef-datum") == 0 && nBlockSize == 2) { VSIFReadL(&nEPSGDatumCode, 2, 1, fp); CPL_LSBPTR16(&nEPSGDatumCode); CPLDebug("HF2", "EPSG Datum Code = %d", nEPSGDatumCode); bHasEPSGDatumCode = TRUE; } else if (strcmp(szBlockName, "georef-epsg-prj") == 0 && nBlockSize == 2) { VSIFReadL(&nEPSGCode, 2, 1, fp); CPL_LSBPTR16(&nEPSGCode); CPLDebug("HF2", "EPSG Code = %d", nEPSGCode); bHasEPSGCode = TRUE; } else if (strcmp(szBlockName, "precis-rel") == 0 && nBlockSize == 4) { VSIFReadL(&fRelativePrecision, 4, 1, fp); CPL_LSBPTR32(&fRelativePrecision); bHasRelativePrecision = TRUE; } else if (strcmp(szBlockName, "app-name") == 0 && nBlockSize < 256) { VSIFReadL(szApplicationName, nBlockSize, 1, fp); szApplicationName[nBlockSize] = 0; } else { CPLDebug("HF2", "Skipping block %s", szBlockName); VSIFSeekL(fp, nBlockSize, SEEK_CUR); } } /* -------------------------------------------------------------------- */ /* Create a corresponding GDALDataset. */ /* -------------------------------------------------------------------- */ HF2Dataset *poDS; poDS = new HF2Dataset(); poDS->fp = fp; poDS->nRasterXSize = nXSize; poDS->nRasterYSize = nYSize; poDS->nTileSize = nTileSize; CPLDebug("HF2", "nXSize = %d, nYSize = %d, nTileSize = %d", nXSize, nYSize, nTileSize); if (bHasExtent) { poDS->adfGeoTransform[0] = dfMinX; poDS->adfGeoTransform[3] = dfMaxY; poDS->adfGeoTransform[1] = (dfMaxX - dfMinX) / nXSize; poDS->adfGeoTransform[5] = -(dfMaxY - dfMinY) / nYSize; } else { poDS->adfGeoTransform[1] = fHorizScale; poDS->adfGeoTransform[5] = fHorizScale; } if (bHasEPSGCode) { OGRSpatialReference oSRS; if (oSRS.importFromEPSG(nEPSGCode) == OGRERR_NONE) oSRS.exportToWkt(&poDS->pszWKT); } else { int bHasSRS = FALSE; OGRSpatialReference oSRS; oSRS.SetGeogCS("unknown", "unknown", "unknown", SRS_WGS84_SEMIMAJOR, SRS_WGS84_INVFLATTENING); if (bHasEPSGDatumCode) { if (nEPSGDatumCode == 23 || nEPSGDatumCode == 6326) { bHasSRS = TRUE; oSRS.SetWellKnownGeogCS("WGS84"); } else if (nEPSGDatumCode >= 6000) { char szName[32]; sprintf( szName, "EPSG:%d", nEPSGDatumCode-2000 ); oSRS.SetWellKnownGeogCS( szName ); bHasSRS = TRUE; } } if (bHasUTMZone && ABS(nUTMZone) >= 1 && ABS(nUTMZone) <= 60) { bHasSRS = TRUE; oSRS.SetUTM(ABS(nUTMZone), nUTMZone > 0); } if (bHasSRS) oSRS.exportToWkt(&poDS->pszWKT); } /* -------------------------------------------------------------------- */ /* Create band information objects. */ /* -------------------------------------------------------------------- */ poDS->nBands = 1; int i; for( i = 0; i < poDS->nBands; i++ ) { poDS->SetBand( i+1, new HF2RasterBand( poDS, i+1, GDT_Float32 ) ); poDS->GetRasterBand(i+1)->SetUnitType("m"); } if (szApplicationName[0] != '\0') poDS->SetMetadataItem("APPLICATION_NAME", szApplicationName); poDS->SetMetadataItem("VERTICAL_PRECISION", CPLString().Printf("%f", fVertPres)); if (bHasRelativePrecision) poDS->SetMetadataItem("RELATIVE_VERTICAL_PRECISION", CPLString().Printf("%f", fRelativePrecision)); /* -------------------------------------------------------------------- */ /* Initialize any PAM information. */ /* -------------------------------------------------------------------- */ poDS->SetDescription( osOriginalFilename.c_str() ); poDS->TryLoadXML(); /* -------------------------------------------------------------------- */ /* Support overviews. */ /* -------------------------------------------------------------------- */ poDS->oOvManager.Initialize( poDS, osOriginalFilename.c_str() ); return( poDS ); }
bool TerragenDataset::put(GInt16 n) { CPL_LSBPTR16(&n); return (1 == VSIFWriteL(&n, sizeof(n), 1, m_fp)); }
void appendUShort(void* pBuffer, unsigned short val) { CPL_LSBPTR16(&val); memcpy(pBuffer, &val, 2); }
void writeUShort(VSILFILE* fp, unsigned short val) { CPL_LSBPTR16(&val); VSIFWriteL(&val, 1, 2, fp); }
void LANDataset::CheckForStatistics() { /* -------------------------------------------------------------------- */ /* Do we have a statistics file? */ /* -------------------------------------------------------------------- */ osSTAFilename = CPLResetExtension(GetDescription(),"sta"); VSILFILE *fpSTA = VSIFOpenL( osSTAFilename, "r" ); if( fpSTA == NULL && VSIIsCaseSensitiveFS(osSTAFilename) ) { osSTAFilename = CPLResetExtension(GetDescription(),"STA"); fpSTA = VSIFOpenL( osSTAFilename, "r" ); } if( fpSTA == NULL ) { osSTAFilename = ""; return; } /* -------------------------------------------------------------------- */ /* Read it one band at a time. */ /* -------------------------------------------------------------------- */ GByte abyBandInfo[1152] = { '\0' }; for( int iBand = 0; iBand < nBands; iBand++ ) { if( VSIFReadL( abyBandInfo, 1152, 1, fpSTA ) != 1 ) break; const int nBandNumber = abyBandInfo[7]; GDALRasterBand *poBand = GetRasterBand(nBandNumber); if( poBand == NULL ) break; GInt16 nMin = 0; GInt16 nMax = 0; if( poBand->GetRasterDataType() != GDT_Byte ) { memcpy( &nMin, abyBandInfo + 28, 2 ); memcpy( &nMax, abyBandInfo + 30, 2 ); CPL_LSBPTR16( &nMin ); CPL_LSBPTR16( &nMax ); } else { nMin = abyBandInfo[9]; nMax = abyBandInfo[8]; } float fMean = 0.0; float fStdDev = 0.0; memcpy( &fMean, abyBandInfo + 12, 4 ); memcpy( &fStdDev, abyBandInfo + 24, 4 ); CPL_LSBPTR32( &fMean ); CPL_LSBPTR32( &fStdDev ); poBand->SetStatistics( nMin, nMax, fMean, fStdDev ); } CPL_IGNORE_RET_VAL(VSIFCloseL( fpSTA )); }
GDALDataset *LANDataset::Open( GDALOpenInfo * poOpenInfo ) { /* -------------------------------------------------------------------- */ /* We assume the user is pointing to the header (.pcb) file. */ /* Does this appear to be a pcb file? */ /* -------------------------------------------------------------------- */ if( poOpenInfo->nHeaderBytes < ERD_HEADER_SIZE ) return NULL; if( !STARTS_WITH_CI( reinterpret_cast<char *>(poOpenInfo->pabyHeader), "HEADER" ) && !STARTS_WITH_CI( reinterpret_cast<char *>(poOpenInfo->pabyHeader), "HEAD74" ) ) return NULL; /* -------------------------------------------------------------------- */ /* Create a corresponding GDALDataset. */ /* -------------------------------------------------------------------- */ LANDataset *poDS = new LANDataset(); poDS->eAccess = poOpenInfo->eAccess; /* -------------------------------------------------------------------- */ /* Adopt the openinfo file pointer for use with this file. */ /* -------------------------------------------------------------------- */ if( poOpenInfo->eAccess == GA_ReadOnly ) poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" ); else poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb+" ); if( poDS->fpImage == NULL ) { delete poDS; return NULL; } /* -------------------------------------------------------------------- */ /* Do we need to byte swap the headers to local machine order? */ /* -------------------------------------------------------------------- */ int bBigEndian = poOpenInfo->pabyHeader[8] == 0; memcpy( poDS->pachHeader, poOpenInfo->pabyHeader, ERD_HEADER_SIZE ); #ifdef CPL_LSB const int bNeedSwap = bBigEndian; #else const int bNeedSwap = !bBigEndian; #endif if( bNeedSwap ) { CPL_SWAP16PTR( poDS->pachHeader + 6 ); CPL_SWAP16PTR( poDS->pachHeader + 8 ); CPL_SWAP32PTR( poDS->pachHeader + 16 ); CPL_SWAP32PTR( poDS->pachHeader + 20 ); CPL_SWAP32PTR( poDS->pachHeader + 24 ); CPL_SWAP32PTR( poDS->pachHeader + 28 ); CPL_SWAP16PTR( poDS->pachHeader + 88 ); CPL_SWAP16PTR( poDS->pachHeader + 90 ); CPL_SWAP16PTR( poDS->pachHeader + 106 ); CPL_SWAP32PTR( poDS->pachHeader + 108 ); CPL_SWAP32PTR( poDS->pachHeader + 112 ); CPL_SWAP32PTR( poDS->pachHeader + 116 ); CPL_SWAP32PTR( poDS->pachHeader + 120 ); CPL_SWAP32PTR( poDS->pachHeader + 124 ); } /* -------------------------------------------------------------------- */ /* Capture some information from the file that is of interest. */ /* -------------------------------------------------------------------- */ if( STARTS_WITH_CI(poDS->pachHeader,"HEADER") ) { float fTmp = 0.0; memcpy(&fTmp, poDS->pachHeader + 16, 4); CPL_LSBPTR32(&fTmp); poDS->nRasterXSize = (int) fTmp; memcpy(&fTmp, poDS->pachHeader + 20, 4); CPL_LSBPTR32(&fTmp); poDS->nRasterYSize = (int) fTmp; } else { GInt32 nTmp = 0; memcpy(&nTmp, poDS->pachHeader + 16, 4); CPL_LSBPTR32(&nTmp); poDS->nRasterXSize = nTmp; memcpy(&nTmp, poDS->pachHeader + 20, 4); CPL_LSBPTR32(&nTmp); poDS->nRasterYSize = nTmp; } GInt16 nTmp16 = 0; memcpy(&nTmp16, poDS->pachHeader + 6, 2); CPL_LSBPTR16(&nTmp16); int nPixelOffset = 0; GDALDataType eDataType = GDT_Unknown; if( nTmp16 == 0 ) { eDataType = GDT_Byte; nPixelOffset = 1; } else if( nTmp16 == 1 ) // 4 bit { eDataType = GDT_Byte; nPixelOffset = -1; } else if( nTmp16 == 2 ) { nPixelOffset = 2; eDataType = GDT_Int16; } else { CPLError( CE_Failure, CPLE_AppDefined, "Unsupported pixel type (%d).", nTmp16 ); delete poDS; return NULL; } memcpy(&nTmp16, poDS->pachHeader + 8, 2); CPL_LSBPTR16(&nTmp16); const int nBandCount = nTmp16; if( !GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) || !GDALCheckBandCount(nBandCount, FALSE) ) { delete poDS; return NULL; } if( nPixelOffset != -1 && poDS->nRasterXSize > INT_MAX / (nPixelOffset * nBandCount) ) { CPLError( CE_Failure, CPLE_AppDefined, "Int overflow occurred." ); delete poDS; return NULL; } /* -------------------------------------------------------------------- */ /* Create band information object. */ /* -------------------------------------------------------------------- */ CPLErrorReset(); for( int iBand = 1; iBand <= nBandCount; iBand++ ) { if( nPixelOffset == -1 ) /* 4 bit case */ poDS->SetBand( iBand, new LAN4BitRasterBand( poDS, iBand ) ); else poDS->SetBand( iBand, new RawRasterBand( poDS, iBand, poDS->fpImage, ERD_HEADER_SIZE + (iBand-1) * nPixelOffset * poDS->nRasterXSize, nPixelOffset, poDS->nRasterXSize*nPixelOffset*nBandCount, eDataType, !bNeedSwap, TRUE )); if( CPLGetLastErrorType() != CE_None ) { delete poDS; return NULL; } } /* -------------------------------------------------------------------- */ /* Initialize any PAM information. */ /* -------------------------------------------------------------------- */ poDS->SetDescription( poOpenInfo->pszFilename ); poDS->CheckForStatistics(); poDS->TryLoadXML(); /* -------------------------------------------------------------------- */ /* Check for overviews. */ /* -------------------------------------------------------------------- */ poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename ); /* -------------------------------------------------------------------- */ /* Try to interpret georeferencing. */ /* -------------------------------------------------------------------- */ float fTmp = 0.0; memcpy(&fTmp, poDS->pachHeader + 112, 4); CPL_LSBPTR32(&fTmp); poDS->adfGeoTransform[0] = fTmp; memcpy(&fTmp, poDS->pachHeader + 120, 4); CPL_LSBPTR32(&fTmp); poDS->adfGeoTransform[1] = fTmp; poDS->adfGeoTransform[2] = 0.0; memcpy(&fTmp, poDS->pachHeader + 116, 4); CPL_LSBPTR32(&fTmp); poDS->adfGeoTransform[3] = fTmp; poDS->adfGeoTransform[4] = 0.0; memcpy(&fTmp, poDS->pachHeader + 124, 4); CPL_LSBPTR32(&fTmp); poDS->adfGeoTransform[5] = - fTmp; // adjust for center of pixel vs. top left corner of pixel. poDS->adfGeoTransform[0] -= poDS->adfGeoTransform[1] * 0.5; poDS->adfGeoTransform[3] -= poDS->adfGeoTransform[5] * 0.5; /* -------------------------------------------------------------------- */ /* If we didn't get any georeferencing, try for a worldfile. */ /* -------------------------------------------------------------------- */ if( poDS->adfGeoTransform[1] == 0.0 || poDS->adfGeoTransform[5] == 0.0 ) { if( !GDALReadWorldFile( poOpenInfo->pszFilename, NULL, poDS->adfGeoTransform ) ) GDALReadWorldFile( poOpenInfo->pszFilename, ".wld", poDS->adfGeoTransform ); } /* -------------------------------------------------------------------- */ /* Try to come up with something for the coordinate system. */ /* -------------------------------------------------------------------- */ memcpy(&nTmp16, poDS->pachHeader + 88, 2); CPL_LSBPTR16(&nTmp16); int nCoordSys = nTmp16; if( nCoordSys == 0 ) { poDS->pszProjection = CPLStrdup(SRS_WKT_WGS84); } else if( nCoordSys == 1 ) { poDS->pszProjection = CPLStrdup( "LOCAL_CS[\"UTM - Zone Unknown\",UNIT[\"Meter\",1]]" ); } else if( nCoordSys == 2 ) { poDS->pszProjection = CPLStrdup( "LOCAL_CS[\"State Plane - Zone Unknown\"," "UNIT[\"US survey foot\",0.3048006096012192]]" ); } else { poDS->pszProjection = CPLStrdup( "LOCAL_CS[\"Unknown\",UNIT[\"Meter\",1]]" ); } /* -------------------------------------------------------------------- */ /* Check for a trailer file with a colormap in it. */ /* -------------------------------------------------------------------- */ char *pszPath = CPLStrdup( CPLGetPath(poOpenInfo->pszFilename) ); char *pszBasename = CPLStrdup( CPLGetBasename(poOpenInfo->pszFilename) ); const char *pszTRLFilename = CPLFormCIFilename( pszPath, pszBasename, "trl" ); VSILFILE *fpTRL = VSIFOpenL( pszTRLFilename, "rb" ); if( fpTRL != NULL ) { char szTRLData[896] = { '\0' }; CPL_IGNORE_RET_VAL(VSIFReadL( szTRLData, 1, 896, fpTRL )); CPL_IGNORE_RET_VAL(VSIFCloseL( fpTRL )); GDALColorTable *poCT = new GDALColorTable(); for( int iColor = 0; iColor < 256; iColor++ ) { GDALColorEntry sEntry = { 0, 0, 0, 0}; sEntry.c2 = reinterpret_cast<GByte *>(szTRLData)[iColor+128]; sEntry.c1 = reinterpret_cast<GByte *>(szTRLData)[iColor+128+256]; sEntry.c3 = reinterpret_cast<GByte *>(szTRLData)[iColor+128+512]; sEntry.c4 = 255; poCT->SetColorEntry( iColor, &sEntry ); // Only 16 colors in 4bit files. if( nPixelOffset == -1 && iColor == 15 ) break; } poDS->GetRasterBand(1)->SetColorTable( poCT ); poDS->GetRasterBand(1)->SetColorInterpretation( GCI_PaletteIndex ); delete poCT; } CPLFree( pszPath ); CPLFree( pszBasename ); return poDS; }
CPLErr NWT_GRDRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff, void *pImage ) { NWT_GRDDataset *poGDS = (NWT_GRDDataset *) poDS; char *pszRecord; int nRecordSize = nBlockXSize * 2; int i; unsigned short raw1; VSIFSeekL( poGDS->fp, 1024 + nRecordSize * (vsi_l_offset)nBlockYOff, SEEK_SET ); pszRecord = (char *) CPLMalloc( nRecordSize ); VSIFReadL( pszRecord, 1, nRecordSize, poGDS->fp ); if( nBand == 4 ) //Z values { for( i = 0; i < nBlockXSize; i++ ) { memcpy( (void *) &raw1, (void *)(pszRecord + 2 * i), 2 ); CPL_LSBPTR16(&raw1); if( raw1 == 0 ) { ((float *)pImage)[i] = (float)-1.e37; // null value } else { ((float *)pImage)[i] = (float) (dfOffset + ((raw1 - 1) * dfScale)); } } } else if( nBand == 1 ) // red values { for( i = 0; i < nBlockXSize; i++ ) { memcpy( (void *) &raw1, (void *)(pszRecord + 2 * i), 2 ); CPL_LSBPTR16(&raw1); ((char *)pImage)[i] = poGDS->ColorMap[raw1 / 16].r; } } else if( nBand == 2 ) // green { for( i = 0; i < nBlockXSize; i++ ) { memcpy( (void *) &raw1, (void *)(pszRecord + 2 * i), 2 ); CPL_LSBPTR16(&raw1); ((char *) pImage)[i] = poGDS->ColorMap[raw1 / 16].g; } } else if( nBand == 3 ) // blue { for( i = 0; i < nBlockXSize; i++ ) { memcpy( (void *) &raw1, (void *) (pszRecord + 2 * i), 2 ); CPL_LSBPTR16(&raw1); ((char *) pImage)[i] = poGDS->ColorMap[raw1 / 16].b; } } else { CPLError( CE_Failure, CPLE_IllegalArg, "No band number %d", nBand ); if( pszRecord != NULL ) CPLFree( pszRecord ); return CE_Failure; } if( pszRecord != NULL ) { CPLFree( pszRecord ); } return CE_None; }
CPLErr NWT_GRDRasterBand::IReadBlock( CPL_UNUSED int nBlockXOff, int nBlockYOff, void *pImage ) { NWT_GRDDataset *poGDS = reinterpret_cast<NWT_GRDDataset *>( poDS ); if( nBlockXSize > INT_MAX / 2 ) return CE_Failure; const int nRecordSize = nBlockXSize * 2; unsigned short raw1; VSIFSeekL( poGDS->fp, 1024 + nRecordSize * static_cast<vsi_l_offset>( nBlockYOff ), SEEK_SET ); GByte *pabyRecord = reinterpret_cast<GByte *>( VSI_MALLOC_VERBOSE( nRecordSize ) ); if( pabyRecord == NULL ) return CE_Failure; if( (int)VSIFReadL( pabyRecord, 1, nRecordSize, poGDS->fp ) != nRecordSize ) { CPLFree( pabyRecord ); return CE_Failure; } if( nBand == 4 ) //Z values { for( int i = 0; i < nBlockXSize; i++ ) { memcpy( reinterpret_cast<void *>( &raw1 ), reinterpret_cast<void *>(pabyRecord + 2 * i), 2 ); CPL_LSBPTR16(&raw1); if( raw1 == 0 ) { reinterpret_cast<float *>( pImage )[i] = -1.e37f; // null value } else { reinterpret_cast<float *>( pImage )[i] = static_cast<float>( dfOffset + ((raw1 - 1) * dfScale) ); } } } else if( nBand == 1 ) // red values { for( int i = 0; i < nBlockXSize; i++ ) { memcpy( reinterpret_cast<void *>( &raw1 ), reinterpret_cast<void *>(pabyRecord + 2 * i), 2 ); CPL_LSBPTR16(&raw1); reinterpret_cast<char *>( pImage )[i] = poGDS->ColorMap[raw1 / 16].r; } } else if( nBand == 2 ) // green { for( int i = 0; i < nBlockXSize; i++ ) { memcpy( reinterpret_cast<void *> ( &raw1 ), reinterpret_cast<void *> ( pabyRecord + 2 * i ), 2 ); CPL_LSBPTR16(&raw1); reinterpret_cast<char *>( pImage )[i] = poGDS->ColorMap[raw1 / 16].g; } } else if( nBand == 3 ) // blue { for( int i = 0; i < nBlockXSize; i++ ) { memcpy( reinterpret_cast<void *>( &raw1 ), reinterpret_cast<void *>( pabyRecord + 2 * i ), 2 ); CPL_LSBPTR16(&raw1); reinterpret_cast<char *>( pImage )[i] = poGDS->ColorMap[raw1 / 16].b; } } else { CPLError( CE_Failure, CPLE_IllegalArg, "No band number %d", nBand ); CPLFree( pabyRecord ); return CE_Failure; } CPLFree( pabyRecord ); return CE_None; }
int nwt_ParseHeader( NWT_GRID * pGrd, char *nwtHeader ) { int i; unsigned short usTmp; /* double dfTmp; */ unsigned char cTmp[256]; if( nwtHeader[4] == '1' ) pGrd->cFormat = 0x00; // grd - surface type else if( nwtHeader[4] == '8' ) pGrd->cFormat = 0x80; // grc classified type pGrd->stClassDict = NULL; memcpy( (void *) &pGrd->fVersion, (void *) &nwtHeader[5], sizeof(pGrd->fVersion) ); CPL_LSBPTR32(&pGrd->fVersion); memcpy( (void *) &usTmp, (void *) &nwtHeader[9], 2 ); CPL_LSBPTR16(&usTmp); pGrd->nXSide = (unsigned int) usTmp; if( pGrd->nXSide == 0 ) { memcpy( (void *) &pGrd->nXSide, (void *) &nwtHeader[128], sizeof(pGrd->nXSide) ); CPL_LSBPTR32(&pGrd->nXSide); } memcpy( (void *) &usTmp, (void *) &nwtHeader[11], 2 ); CPL_LSBPTR16(&usTmp); pGrd->nYSide = (unsigned int) usTmp; if( pGrd->nYSide == 0 ) { memcpy( (void *) &pGrd->nYSide, (void *) &nwtHeader[132], sizeof(pGrd->nYSide) ); CPL_LSBPTR32(&pGrd->nYSide); } memcpy( (void *) &pGrd->dfMinX, (void *) &nwtHeader[13], sizeof(pGrd->dfMinX) ); CPL_LSBPTR64(&pGrd->dfMinX); memcpy( (void *) &pGrd->dfMaxX, (void *) &nwtHeader[21], sizeof(pGrd->dfMaxX) ); CPL_LSBPTR64(&pGrd->dfMaxX); memcpy( (void *) &pGrd->dfMinY, (void *) &nwtHeader[29], sizeof(pGrd->dfMinY) ); CPL_LSBPTR64(&pGrd->dfMinY); memcpy( (void *) &pGrd->dfMaxY, (void *) &nwtHeader[37], sizeof(pGrd->dfMaxY) ); CPL_LSBPTR64(&pGrd->dfMaxY); pGrd->dfStepSize = (pGrd->dfMaxX - pGrd->dfMinX) / (pGrd->nXSide - 1); /* dfTmp = (pGrd->dfMaxY - pGrd->dfMinY) / (pGrd->nYSide - 1); */ memcpy( (void *) &pGrd->fZMin, (void *) &nwtHeader[45], sizeof(pGrd->fZMin) ); CPL_LSBPTR32(&pGrd->fZMin); memcpy( (void *) &pGrd->fZMax, (void *) &nwtHeader[49], sizeof(pGrd->fZMax) ); CPL_LSBPTR32(&pGrd->fZMax); memcpy( (void *) &pGrd->fZMinScale, (void *) &nwtHeader[53], sizeof(pGrd->fZMinScale) ); CPL_LSBPTR32(&pGrd->fZMinScale); memcpy( (void *) &pGrd->fZMaxScale, (void *) &nwtHeader[57], sizeof(pGrd->fZMaxScale) ); CPL_LSBPTR32(&pGrd->fZMaxScale); memcpy( (void *) &pGrd->cDescription, (void *) &nwtHeader[61], sizeof(pGrd->cDescription) ); memcpy( (void *) &pGrd->cZUnits, (void *) &nwtHeader[93], sizeof(pGrd->cZUnits) ); memcpy( (void *) &i, (void *) &nwtHeader[136], 4 ); CPL_LSBPTR32(&i); if( i == 1129336130 ) { //BMPC if( nwtHeader[140] & 0x01 ) { pGrd->cHillShadeBrightness = nwtHeader[144]; pGrd->cHillShadeContrast = nwtHeader[145]; } } memcpy( (void *) &pGrd->cMICoordSys, (void *) &nwtHeader[256], sizeof(pGrd->cMICoordSys) ); pGrd->cMICoordSys[sizeof(pGrd->cMICoordSys)-1] = '\0'; pGrd->iZUnits = nwtHeader[512]; if( nwtHeader[513] & 0x80 ) pGrd->bShowGradient = true; if( nwtHeader[513] & 0x40 ) pGrd->bShowHillShade = true; if( nwtHeader[513] & 0x20 ) pGrd->bHillShadeExists = true; memcpy( (void *) &pGrd->iNumColorInflections, (void *) &nwtHeader[516], 2 ); CPL_LSBPTR16(&pGrd->iNumColorInflections); if (pGrd->iNumColorInflections > 32) { CPLError(CE_Failure, CPLE_AppDefined, "Corrupt header"); pGrd->iNumColorInflections = (unsigned short)i; return FALSE; } for( i = 0; i < pGrd->iNumColorInflections; i++ ) { memcpy( (void *) &pGrd->stInflection[i].zVal, (void *) &nwtHeader[518 + (7 * i)], 4 ); CPL_LSBPTR32(&pGrd->stInflection[i].zVal); memcpy( (void *) &pGrd->stInflection[i].r, (void *) &nwtHeader[522 + (7 * i)], 1 ); memcpy( (void *) &pGrd->stInflection[i].g, (void *) &nwtHeader[523 + (7 * i)], 1 ); memcpy( (void *) &pGrd->stInflection[i].b, (void *) &nwtHeader[524 + (7 * i)], 1 ); } memcpy( (void *) &pGrd->fHillShadeAzimuth, (void *) &nwtHeader[966], sizeof(pGrd->fHillShadeAzimuth) ); CPL_LSBPTR32(&pGrd->fHillShadeAzimuth); memcpy( (void *) &pGrd->fHillShadeAngle, (void *) &nwtHeader[970], sizeof(pGrd->fHillShadeAngle) ); CPL_LSBPTR32(&pGrd->fHillShadeAngle); pGrd->cFormat += nwtHeader[1023]; // the msb for grd/grc was already set // there are more types than this - need to build other types for testing if( pGrd->cFormat & 0x80 ) { if( nwtHeader[1023] == 0 ) pGrd->nBitsPerPixel = 16; else pGrd->nBitsPerPixel = nwtHeader[1023] * 4; } else pGrd->nBitsPerPixel = nwtHeader[1023] * 8; if( pGrd->cFormat & 0x80 ) // if is GRC load the Dictionary { VSIFSeekL( pGrd->fp, 1024 + (pGrd->nXSide * pGrd->nYSide) * (pGrd->nBitsPerPixel/8), SEEK_SET ); if( !VSIFReadL( &usTmp, 2, 1, pGrd->fp) ) { CPLError( CE_Failure, CPLE_FileIO, "Read failure, file short?" ); return FALSE; } CPL_LSBPTR16(&usTmp); pGrd->stClassDict = (NWT_CLASSIFIED_DICT *) calloc( sizeof(NWT_CLASSIFIED_DICT), 1 ); pGrd->stClassDict->nNumClassifiedItems = usTmp; pGrd->stClassDict->stClassifedItem = (NWT_CLASSIFIED_ITEM **) calloc( sizeof(NWT_CLASSIFIED_ITEM *), pGrd-> stClassDict->nNumClassifiedItems + 1 ); //load the dictionary for( usTmp=0; usTmp < pGrd->stClassDict->nNumClassifiedItems; usTmp++ ) { NWT_CLASSIFIED_ITEM *psItem = pGrd->stClassDict->stClassifedItem[usTmp] = (NWT_CLASSIFIED_ITEM *) calloc(sizeof(NWT_CLASSIFIED_ITEM), 1); if( !VSIFReadL( &cTmp, 9, 1, pGrd->fp ) ) { CPLError( CE_Failure, CPLE_FileIO, "Read failure, file short?" ); return FALSE; } memcpy( (void *) &psItem->usPixVal, (void *) &cTmp[0], 2 ); CPL_LSBPTR16(&psItem->usPixVal); memcpy( (void *) &psItem->res1, (void *) &cTmp[2], 1 ); memcpy( (void *) &psItem->r, (void *) &cTmp[3], 1 ); memcpy( (void *) &psItem->g, (void *) &cTmp[4], 1 ); memcpy( (void *) &psItem->b, (void *) &cTmp[5], 1 ); memcpy( (void *) &psItem->res2, (void *) &cTmp[6], 1 ); memcpy( (void *) &psItem->usLen, (void *) &cTmp[7], 2 ); CPL_LSBPTR16(&psItem->usLen); if ( psItem->usLen > sizeof(psItem->szClassName)-1 ) { CPLError( CE_Failure, CPLE_AppDefined, "Unexpected long class name, %d characters long - unable to read file.", psItem->usLen ); return FALSE; } if( !VSIFReadL( &psItem->szClassName, psItem->usLen, 1, pGrd->fp ) ) return FALSE; } } return TRUE; }
void LANDataset::CheckForStatistics() { /* -------------------------------------------------------------------- */ /* Do we have a statistics file? */ /* -------------------------------------------------------------------- */ osSTAFilename = CPLResetExtension(GetDescription(),"sta"); FILE *fpSTA = VSIFOpenL( osSTAFilename, "r" ); #ifndef WIN32 if( fpSTA == NULL ) { osSTAFilename = CPLResetExtension(GetDescription(),"STA"); fpSTA = VSIFOpenL( osSTAFilename, "r" ); } #endif if( fpSTA == NULL ) { osSTAFilename = ""; return; } /* -------------------------------------------------------------------- */ /* Read it one band at a time. */ /* -------------------------------------------------------------------- */ GByte abyBandInfo[1152]; int iBand; for( iBand = 0; iBand < nBands; iBand++ ) { if( VSIFReadL( abyBandInfo, 1152, 1, fpSTA ) != 1 ) break; int nBandNumber = abyBandInfo[7]; GDALRasterBand *poBand = GetRasterBand(nBandNumber); if( poBand == NULL ) break; float fMean, fStdDev; GInt16 nMin, nMax; if( poBand->GetRasterDataType() != GDT_Byte ) { memcpy( &nMin, abyBandInfo + 28, 2 ); memcpy( &nMax, abyBandInfo + 30, 2 ); CPL_LSBPTR16( &nMin ); CPL_LSBPTR16( &nMax ); } else { nMin = abyBandInfo[9]; nMax = abyBandInfo[8]; } memcpy( &fMean, abyBandInfo + 12, 4 ); memcpy( &fStdDev, abyBandInfo + 24, 4 ); CPL_LSBPTR32( &fMean ); CPL_LSBPTR32( &fStdDev ); poBand->SetStatistics( nMin, nMax, fMean, fStdDev ); } VSIFCloseL( fpSTA ); }