OGRGPSBabelDataSource::~OGRGPSBabelDataSource()
{
CPLFree(pszName);
CPLFree(pszGPSBabelDriverName);
CPLFree(pszFilename);
CloseDependentDatasets();
if (osTmpFileName.size() > 0)
VSIUnlink(osTmpFileName.c_str());
}
void CPLUnlockFile( void *hLock )
{
char *pszLockFilename = (char *) hLock;
if( hLock == NULL )
return;
VSIUnlink( pszLockFilename );
CPLFree( pszLockFilename );
}
OGRSQLiteExecuteSQLLayer::~OGRSQLiteExecuteSQLLayer()
{
/* This is a bit peculiar: we must "finalize" the OGRLayer, since */
/* it has objects that depend on the datasource, that we are just */
/* going to destroy afterwards. The issue here is that we destroy */
/* our own datasource ! */
Finalize();
delete poDS;
VSIUnlink(pszTmpDBName);
CPLFree(pszTmpDBName);
}
QgsFields QgsOgrUtils::stringToFields( const QString& string, QTextCodec* encoding )
{
QgsFields fields;
if ( string.isEmpty() )
return fields;
QString randomFileName = QString( "/vsimem/%1" ).arg( QUuid::createUuid().toString() );
// create memory file system object from buffer
QByteArray ba = string.toUtf8();
VSIFCloseL( VSIFileFromMemBuffer( TO8( randomFileName ), reinterpret_cast< GByte* >( ba.data() ),
static_cast< vsi_l_offset >( ba.size() ), FALSE ) );
OGRDataSourceH hDS = OGROpen( TO8( randomFileName ), false, nullptr );
if ( !hDS )
{
VSIUnlink( TO8( randomFileName ) );
return fields;
}
OGRLayerH ogrLayer = OGR_DS_GetLayer( hDS, 0 );
if ( !ogrLayer )
{
OGR_DS_Destroy( hDS );
VSIUnlink( TO8( randomFileName ) );
return fields;
}
OGRFeatureH oFeat;
//read in the first feature only
if (( oFeat = OGR_L_GetNextFeature( ogrLayer ) ) )
{
fields = readOgrFields( oFeat, encoding );
OGR_F_Destroy( oFeat );
}
OGR_DS_Destroy( hDS );
VSIUnlink( TO8( randomFileName ) );
return fields;
}
//
// Uses GDAL to create a temporary TIF file, using the band create options
// copies the content to the destination buffer then erases the temp TIF
//
CPLErr CompressTIF(buf_mgr &dst, buf_mgr &src, const ILImage &img, char **papszOptions)
{
CPLErr ret;
GDALDriver *poTiffDriver = GetGDALDriverManager()->GetDriverByName("GTiff");
VSIStatBufL statb;
CPLString fname = uniq_memfname("mrf_tif_write");
GDALDataset *poTiff = poTiffDriver->Create(fname, img.pagesize.x, img.pagesize.y,
img.pagesize.c, img.dt, papszOptions );
// Read directly to avoid double caching in GDAL
// Unfortunately not possible for multiple bands
if (img.pagesize.c == 1) {
ret = poTiff->GetRasterBand(1)->WriteBlock(0,0,src.buffer);
} else {
ret = poTiff->RasterIO(GF_Write, 0,0,img.pagesize.x,img.pagesize.y,
src.buffer, img.pagesize.x, img.pagesize.y, img.dt, img.pagesize.c,
NULL, 0,0,0);
}
if (CE_None != ret) return ret;
GDALClose(poTiff);
// Check that we can read the file
if (VSIStatL(fname, &statb))
{
CPLError(CE_Failure,CPLE_AppDefined,
CPLString().Printf("MRF: TIFF, can't stat %s", fname.c_str()));
return CE_Failure;
}
if (statb.st_size > dst.size)
{
CPLError(CE_Failure,CPLE_AppDefined,
CPLString().Printf("MRF: TIFF, Tiff generated is too large"));
return CE_Failure;
}
VSILFILE *pf = VSIFOpenL(fname,"rb");
if (pf == NULL)
{
CPLError(CE_Failure,CPLE_AppDefined,
CPLString().Printf("MRF: TIFF, can't open %s", fname.c_str()));
return CE_Failure;
}
VSIFReadL(dst.buffer, statb.st_size, 1, pf);
dst.size = statb.st_size;
VSIFCloseL(pf);
VSIUnlink(fname);
return CE_None;
}
QgsFields QgsOgrUtils::stringToFields( const QString &string, QTextCodec *encoding )
{
QgsFields fields;
if ( string.isEmpty() )
return fields;
QString randomFileName = QStringLiteral( "/vsimem/%1" ).arg( QUuid::createUuid().toString() );
// create memory file system object from buffer
QByteArray ba = string.toUtf8();
VSIFCloseL( VSIFileFromMemBuffer( randomFileName.toUtf8().constData(), reinterpret_cast< GByte * >( ba.data() ),
static_cast< vsi_l_offset >( ba.size() ), FALSE ) );
gdal::ogr_datasource_unique_ptr hDS( OGROpen( randomFileName.toUtf8().constData(), false, nullptr ) );
if ( !hDS )
{
VSIUnlink( randomFileName.toUtf8().constData() );
return fields;
}
OGRLayerH ogrLayer = OGR_DS_GetLayer( hDS.get(), 0 );
if ( !ogrLayer )
{
hDS.reset();
VSIUnlink( randomFileName.toUtf8().constData() );
return fields;
}
gdal::ogr_feature_unique_ptr oFeat;
//read in the first feature only
if ( oFeat.reset( OGR_L_GetNextFeature( ogrLayer ) ), oFeat )
{
fields = readOgrFields( oFeat.get(), encoding );
}
hDS.reset();
VSIUnlink( randomFileName.toUtf8().constData() );
return fields;
}
OGRGPSBabelDataSource::~OGRGPSBabelDataSource()
{
CPLFree(pszName);
CPLFree(pszGPSBabelDriverName);
CPLFree(pszFilename);
if (poGPXDS)
OGRDataSource::DestroyDataSource(poGPXDS);
if (osTmpFileName.size() > 0)
VSIUnlink(osTmpFileName.c_str());
}
OGRErr OGRMILayerAttrIndex::DropIndex( int iField )
{
/* -------------------------------------------------------------------- */
/* Do we have this field indexed already? */
/* -------------------------------------------------------------------- */
OGRFieldDefn *poFldDefn=poLayer->GetLayerDefn()->GetFieldDefn(iField);
int i = 0;
for( ; i < nIndexCount; i++ )
{
if( papoIndexList[i]->iField == iField )
break;
}
if( i == nIndexCount )
{
CPLError( CE_Failure, CPLE_AppDefined,
"DROP INDEX on field (%s) that doesn't have an index.",
poFldDefn->GetNameRef() );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Remove from the list. */
/* -------------------------------------------------------------------- */
OGRMIAttrIndex *poAI = papoIndexList[i];
memmove( papoIndexList + i, papoIndexList + i + 1,
sizeof(void*) * (nIndexCount - i - 1) );
delete poAI;
nIndexCount--;
/* -------------------------------------------------------------------- */
/* Save the new configuration, or if there is nothing left try */
/* to clean up the index files. */
/* -------------------------------------------------------------------- */
if( nIndexCount > 0 )
return SaveConfigToXML();
else
{
bUnlinkINDFile = TRUE;
VSIUnlink( pszMetadataFilename );
return OGRERR_NONE;
}
}
int OGRGPSBabelWriteDataSource::Convert()
{
int nRet = -1;
if (osTmpFileName.size() > 0 && pszFilename != NULL && pszGPSBabelDriverName != NULL)
{
if (OGRGPSBabelDataSource::IsSpecialFile(pszFilename))
{
/* Special file : don't try to open it */
const char* const argv[] = { "gpsbabel", "-i", "gpx", "-f", "-",
"-o", pszGPSBabelDriverName, "-F", pszFilename, NULL };
VSILFILE* tmpfp = VSIFOpenL(osTmpFileName.c_str(), "rb");
if (tmpfp)
{
nRet = CPLSpawn(argv, tmpfp, NULL, TRUE);
VSIFCloseL(tmpfp);
tmpfp = NULL;
}
}
else
{
VSILFILE* fp = VSIFOpenL(pszFilename, "wb");
if (fp == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot open file %s", pszFilename);
}
else
{
const char* const argv[] = { "gpsbabel", "-i", "gpx", "-f", "-",
"-o", pszGPSBabelDriverName, "-F", "-", NULL };
VSILFILE* tmpfp = VSIFOpenL(osTmpFileName.c_str(), "rb");
if (tmpfp)
{
nRet = CPLSpawn(argv, tmpfp, fp, TRUE);
VSIFCloseL(tmpfp);
tmpfp = NULL;
}
VSIFCloseL(fp);
fp = NULL;
}
}
VSIUnlink(osTmpFileName.c_str());
osTmpFileName = "";
}
return nRet == 0;
}
CPLErr PAuxDelete( const char * pszBasename )
{
VSILFILE *fp;
const char *pszLine;
fp = VSIFOpenL( CPLResetExtension( pszBasename, "aux" ), "r" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not appear to be a PAux dataset, there is no .aux file.",
pszBasename );
return CE_Failure;
}
pszLine = CPLReadLineL( fp );
VSIFCloseL( fp );
if( pszLine == NULL || !EQUALN(pszLine,"AuxilaryTarget",14) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not appear to be a PAux dataset,\n"
"the .aux file does not start with AuxilaryTarget",
pszBasename );
return CE_Failure;
}
if( VSIUnlink( pszBasename ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"OS unlinking file %s.", pszBasename );
return CE_Failure;
}
VSIUnlink( CPLResetExtension( pszBasename, "aux" ) );
return CE_None;
}
void DTEDPtStreamTrimEdgeOnlyTiles( void *hStream )
{
DTEDPtStream *psStream = (DTEDPtStream *) hStream;
int iFile;
for( iFile = psStream->nOpenFiles-1; iFile >= 0; iFile-- )
{
DTEDInfo *psInfo = psStream->pasCF[iFile].psInfo;
GInt16 **papanProfiles = psStream->pasCF[iFile].papanProfiles;
int iProfile, iPixel, bGotNonEdgeData = FALSE;
for( iProfile = 1; iProfile < psInfo->nXSize-1; iProfile++ )
{
if( papanProfiles[iProfile] == NULL )
continue;
for( iPixel = 1; iPixel < psInfo->nYSize-1; iPixel++ )
{
if( papanProfiles[iProfile][iPixel] != DTED_NODATA_VALUE )
{
bGotNonEdgeData = TRUE;
break;
}
}
}
if( bGotNonEdgeData )
continue;
/* Remove this tile */
for( iProfile = 0; iProfile < psInfo->nXSize; iProfile++ )
{
if( papanProfiles[iProfile] != NULL )
CPLFree( papanProfiles[iProfile] );
}
CPLFree( papanProfiles );
DTEDClose( psInfo );
VSIUnlink( psStream->pasCF[iFile].pszFilename );
CPLFree( psStream->pasCF[iFile].pszFilename );
memmove( psStream->pasCF + iFile,
psStream->pasCF + iFile + 1,
sizeof(DTEDCachedFile) * (psStream->nOpenFiles-iFile-1) );
psStream->nOpenFiles--;
}
}
static CPLErr PAuxDelete( const char * pszBasename )
{
VSILFILE *fp = VSIFOpenL( CPLResetExtension( pszBasename, "aux" ), "r" );
if( fp == nullptr )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not appear to be a PAux dataset: "
"there is no .aux file.",
pszBasename );
return CE_Failure;
}
const char *pszLine = CPLReadLineL( fp );
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
if( pszLine == nullptr || !STARTS_WITH_CI(pszLine, "AuxilaryTarget") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not appear to be a PAux dataset:"
"the .aux file does not start with AuxilaryTarget",
pszBasename );
return CE_Failure;
}
if( VSIUnlink( pszBasename ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"OS unlinking file %s.", pszBasename );
return CE_Failure;
}
VSIUnlink( CPLResetExtension( pszBasename, "aux" ) );
return CE_None;
}
~GdalTestData()
{
/* SrtmFetch may leave a file */
if( CPLCheckForFile( (char*) pszFilename.c_str(), NULL ) )
{
VSIUnlink( pszFilename.c_str() );
}
if( NULL != fetch )
{
delete fetch;
}
if( NULL != poDS )
{
GDALClose( (GDALDatasetH) poDS );
}
}
void CleanVSIDir( const char *pszDir )
{
char **papszFiles = CPLReadDir( pszDir );
int i, nFileCount = CSLCount( papszFiles );
for( i = 0; i < nFileCount; i++ ) {
if( strcasecmp(papszFiles[i],".") == 0
|| strcasecmp(papszFiles[i],"..") == 0 )
continue;
VSIUnlink( papszFiles[i] );
}
CSLDestroy( papszFiles );
}
static int NomadsFetchVsi( const char *pszUrl, const char *pszFilename )
{
int rc;
const char *pszVsiUrl;
VSILFILE *fin, *fout;
vsi_l_offset nOffset, nBytesWritten, nVsiBlockSize;
char *pabyBuffer;
nVsiBlockSize = atoi( CPLGetConfigOption( "NOMADS_VSI_BLOCK_SIZE", "512" ) );
if( !EQUALN( pszUrl, "/vsicurl/", 9 ) )
{
pszVsiUrl = CPLSPrintf( "/vsicurl/%s", pszUrl );
}
fin = VSIFOpenL( pszVsiUrl, "rb" );
if( !fin )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to download file." );
return NOMADS_ERR;
}
fout = VSIFOpenL( pszFilename, "wb" );
if( !fout )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to open file for writing." );
VSIFCloseL( fin );
return NOMADS_ERR;
}
nBytesWritten = 0;
pabyBuffer = CPLMalloc( sizeof( char ) * nVsiBlockSize );
rc = 0;
do
{
nOffset = VSIFReadL( pabyBuffer, 1, nVsiBlockSize, fin );
nBytesWritten += nOffset;
VSIFWriteL( pabyBuffer, 1, nOffset, fout );
} while ( nOffset != 0 );
VSIFCloseL( fin );
VSIFCloseL( fout );
if( nBytesWritten == 0 )
{
VSIUnlink( pszFilename );
rc = NOMADS_ERR;
}
CPLFree( (void*)pabyBuffer );
return rc;
}
/*!
\brief VFKReaderSQLite destructor
*/
VFKReaderSQLite::~VFKReaderSQLite()
{
/* close tmp SQLite DB */
if (SQLITE_OK != sqlite3_close(m_poDB)) {
CPLError(CE_Failure, CPLE_AppDefined,
"Closing SQLite DB failed\n %s",
sqlite3_errmsg(m_poDB));
}
CPLDebug("OGR-VFK", "Internal DB (%s) closed",
m_pszDBname);
/* delete tmp SQLite DB if requested */
if (CSLTestBoolean(CPLGetConfigOption("OGR_VFK_DB_DELETE", "NO"))) {
CPLDebug("OGR-VFK", "Internal DB (%s) deleted",
m_pszDBname);
VSIUnlink(m_pszDBname);
}
}
/* which would be an undesired effect... */
CPLErr VRTDataset::Delete( const char * pszFilename )
{
GDALDriverH hDriver = GDALIdentifyDriver(pszFilename, NULL);
if (hDriver && EQUAL(GDALGetDriverShortName(hDriver), "VRT"))
{
if( VSIUnlink( pszFilename ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Deleting %s failed:\n%s",
pszFilename,
VSIStrerror(errno) );
return CE_Failure;
}
return CE_None;
}
else
return CE_Failure;
}
OGRMILayerAttrIndex::~OGRMILayerAttrIndex()
{
if( poINDFile != nullptr )
{
poINDFile->Close();
delete poINDFile;
poINDFile = nullptr;
}
if (bUnlinkINDFile)
VSIUnlink( pszMIINDFilename );
for( int i = 0; i < nIndexCount; i++ )
delete papoIndexList[i];
CPLFree( papoIndexList );
CPLFree( pszMIINDFilename );
CPLFree( pszMetadataFilename );
}
void OGRTigerDataSource::DeleteModuleFiles( const char *pszModule )
{
char **papszDirFiles = VSIReadDir( GetDirPath() );
const int nCount = CSLCount(papszDirFiles);
for( int i = 0; i < nCount; i++ )
{
if( EQUALN(pszModule,papszDirFiles[i],strlen(pszModule)) )
{
const char *pszFilename = CPLFormFilename( GetDirPath(),
papszDirFiles[i],
nullptr );
if( VSIUnlink( pszFilename ) != 0 )
{
CPLDebug( "OGR_TIGER", "Failed to unlink %s", pszFilename );
}
}
}
CSLDestroy( papszDirFiles );
}
static bool OGRGPSBabelDriverIdentifyInternal(
GDALOpenInfo* poOpenInfo,
const char** ppszGSPBabelDriverName )
{
if( STARTS_WITH_CI(poOpenInfo->pszFilename, "GPSBABEL:") )
return true;
const char* pszGPSBabelDriverName = NULL;
if( poOpenInfo->fpL == NULL )
return false;
if (memcmp(poOpenInfo->pabyHeader, "MsRcd", 5) == 0)
pszGPSBabelDriverName = "mapsource";
else if (memcmp(poOpenInfo->pabyHeader, "MsRcf", 5) == 0)
pszGPSBabelDriverName = "gdb";
else if (strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "<osm") != NULL)
pszGPSBabelDriverName = "osm";
else if (strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "$GPGSA") != NULL ||
strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "$GPGGA") != NULL)
pszGPSBabelDriverName = "nmea";
else if (STARTS_WITH_CI((const char*)poOpenInfo->pabyHeader, "OziExplorer"))
pszGPSBabelDriverName = "ozi";
else if (strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "Grid") &&
strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "Datum") &&
strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "Header"))
pszGPSBabelDriverName = "garmin_txt";
else if (poOpenInfo->pabyHeader[0] == 13 && poOpenInfo->pabyHeader[10] == 'M' && poOpenInfo->pabyHeader[11] == 'S' &&
(poOpenInfo->pabyHeader[12] >= '0' && poOpenInfo->pabyHeader[12] <= '9') &&
(poOpenInfo->pabyHeader[13] >= '0' && poOpenInfo->pabyHeader[13] <= '9') &&
poOpenInfo->pabyHeader[12] * 10 + poOpenInfo->pabyHeader[13] >= 30 &&
(poOpenInfo->pabyHeader[14] == 1 || poOpenInfo->pabyHeader[14] == 2) && poOpenInfo->pabyHeader[15] == 0 &&
poOpenInfo->pabyHeader[16] == 0 && poOpenInfo->pabyHeader[17] == 0)
pszGPSBabelDriverName = "mapsend";
else if (strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "$PMGNWPL") != NULL ||
strstr(reinterpret_cast<const char*>(poOpenInfo->pabyHeader), "$PMGNRTE") != NULL)
pszGPSBabelDriverName = "magellan";
else if (poOpenInfo->pabyHeader[0] == 'A' &&
poOpenInfo->pabyHeader[1] >= 'A' && poOpenInfo->pabyHeader[1] <= 'Z' &&
poOpenInfo->pabyHeader[2] >= 'A' && poOpenInfo->pabyHeader[2] <= 'Z' &&
poOpenInfo->pabyHeader[3] >= 'A' && poOpenInfo->pabyHeader[3] <= 'Z' &&
EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "igc") )
pszGPSBabelDriverName = "igc";
static int bGPSBabelFound = -1;
if( pszGPSBabelDriverName != NULL && bGPSBabelFound < 0 )
{
#ifndef WIN32
VSIStatBufL sStat;
bGPSBabelFound = VSIStatL("/usr/bin/gpsbabel", &sStat) == 0;
if( !bGPSBabelFound )
#endif
{
const char* const apszArgs[] = { "gpsbabel", "-V", NULL };
CPLString osTmpFileName("/vsimem/gpsbabel_tmp.tmp");
VSILFILE* tmpfp = VSIFOpenL(osTmpFileName, "wb");
bGPSBabelFound = (CPLSpawn(apszArgs, NULL, tmpfp, FALSE) == 0);
VSIFCloseL(tmpfp);
VSIUnlink(osTmpFileName);
}
}
if( bGPSBabelFound )
*ppszGSPBabelDriverName = pszGPSBabelDriverName;
return *ppszGSPBabelDriverName != NULL;
}
GDALDataset *
WEBPDataset::CreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
/* -------------------------------------------------------------------- */
/* WEBP library initialization */
/* -------------------------------------------------------------------- */
WebPPicture sPicture;
if (!WebPPictureInit(&sPicture))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureInit() failed");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
if( nXSize > 16383 || nYSize > 16383 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"WEBP maximum image dimensions are 16383 x 16383.");
return NULL;
}
if( nBands != 3
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
&& nBands != 4
#endif
)
{
CPLError( CE_Failure, CPLE_NotSupported,
"WEBP driver doesn't support %d bands. Must be 3 (RGB) "
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
"or 4 (RGBA) "
#endif
"bands.",
nBands );
return NULL;
}
GDALDataType eDT = poSrcDS->GetRasterBand(1)->GetRasterDataType();
if( eDT != GDT_Byte )
{
CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
"WEBP driver doesn't support data type %s. "
"Only eight bit byte bands supported.",
GDALGetDataTypeName(
poSrcDS->GetRasterBand(1)->GetRasterDataType()) );
if (bStrict)
return NULL;
}
/* -------------------------------------------------------------------- */
/* What options has the user selected? */
/* -------------------------------------------------------------------- */
float fQuality = 75.0f;
const char* pszQUALITY = CSLFetchNameValue(papszOptions, "QUALITY");
if( pszQUALITY != NULL )
{
fQuality = (float) CPLAtof(pszQUALITY);
if( fQuality < 0.0f || fQuality > 100.0f )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"%s=%s is not a legal value.", "QUALITY", pszQUALITY);
return NULL;
}
}
WebPPreset nPreset = WEBP_PRESET_DEFAULT;
const char* pszPRESET = CSLFetchNameValueDef(papszOptions, "PRESET", "DEFAULT");
if (EQUAL(pszPRESET, "DEFAULT"))
nPreset = WEBP_PRESET_DEFAULT;
else if (EQUAL(pszPRESET, "PICTURE"))
nPreset = WEBP_PRESET_PICTURE;
else if (EQUAL(pszPRESET, "PHOTO"))
nPreset = WEBP_PRESET_PHOTO;
else if (EQUAL(pszPRESET, "PICTURE"))
nPreset = WEBP_PRESET_PICTURE;
else if (EQUAL(pszPRESET, "DRAWING"))
nPreset = WEBP_PRESET_DRAWING;
else if (EQUAL(pszPRESET, "ICON"))
nPreset = WEBP_PRESET_ICON;
else if (EQUAL(pszPRESET, "TEXT"))
nPreset = WEBP_PRESET_TEXT;
else
{
CPLError( CE_Failure, CPLE_IllegalArg,
"%s=%s is not a legal value.", "PRESET", pszPRESET );
return NULL;
}
WebPConfig sConfig;
if (!WebPConfigInitInternal(&sConfig, nPreset, fQuality, WEBP_ENCODER_ABI_VERSION))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPConfigInit() failed");
return NULL;
}
#define FETCH_AND_SET_OPTION_INT(name, fieldname, minval, maxval) \
{ \
const char* pszVal = CSLFetchNameValue(papszOptions, name); \
if (pszVal != NULL) \
{ \
sConfig.fieldname = atoi(pszVal); \
if (sConfig.fieldname < minval || sConfig.fieldname > maxval) \
{ \
CPLError( CE_Failure, CPLE_IllegalArg, \
"%s=%s is not a legal value.", name, pszVal ); \
return NULL; \
} \
} \
}
FETCH_AND_SET_OPTION_INT("TARGETSIZE", target_size, 0, INT_MAX);
const char* pszPSNR = CSLFetchNameValue(papszOptions, "PSNR");
if (pszPSNR)
{
sConfig.target_PSNR = CPLAtof(pszPSNR);
if (sConfig.target_PSNR < 0)
{
CPLError( CE_Failure, CPLE_IllegalArg,
"PSNR=%s is not a legal value.", pszPSNR );
return NULL;
}
}
FETCH_AND_SET_OPTION_INT("METHOD", method, 0, 6);
FETCH_AND_SET_OPTION_INT("SEGMENTS", segments, 1, 4);
FETCH_AND_SET_OPTION_INT("SNS_STRENGTH", sns_strength, 0, 100);
FETCH_AND_SET_OPTION_INT("FILTER_STRENGTH", filter_strength, 0, 100);
FETCH_AND_SET_OPTION_INT("FILTER_SHARPNESS", filter_sharpness, 0, 7);
FETCH_AND_SET_OPTION_INT("FILTER_TYPE", filter_type, 0, 1);
FETCH_AND_SET_OPTION_INT("AUTOFILTER", autofilter, 0, 1);
FETCH_AND_SET_OPTION_INT("PASS", pass, 1, 10);
FETCH_AND_SET_OPTION_INT("PREPROCESSING", preprocessing, 0, 1);
FETCH_AND_SET_OPTION_INT("PARTITIONS", partitions, 0, 3);
#if WEBP_ENCODER_ABI_VERSION >= 0x0002
FETCH_AND_SET_OPTION_INT("PARTITION_LIMIT", partition_limit, 0, 100);
#endif
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
sConfig.lossless = CSLFetchBoolean(papszOptions, "LOSSLESS", FALSE);
if (sConfig.lossless)
sPicture.use_argb = 1;
#endif
if (!WebPValidateConfig(&sConfig))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPValidateConfig() failed");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Allocate memory */
/* -------------------------------------------------------------------- */
GByte *pabyBuffer;
pabyBuffer = (GByte *) VSIMalloc( nBands * nXSize * nYSize );
if (pabyBuffer == NULL)
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the dataset. */
/* -------------------------------------------------------------------- */
VSILFILE *fpImage;
fpImage = VSIFOpenL( pszFilename, "wb" );
if( fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create WEBP file %s.\n",
pszFilename );
VSIFree(pabyBuffer);
return NULL;
}
WebPUserData sUserData;
sUserData.fp = fpImage;
sUserData.pfnProgress = pfnProgress ? pfnProgress : GDALDummyProgress;
sUserData.pProgressData = pProgressData;
/* -------------------------------------------------------------------- */
/* WEBP library settings */
/* -------------------------------------------------------------------- */
sPicture.width = nXSize;
sPicture.height = nYSize;
sPicture.writer = WEBPDatasetWriter;
sPicture.custom_ptr = &sUserData;
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
sPicture.progress_hook = WEBPDatasetProgressHook;
#endif
if (!WebPPictureAlloc(&sPicture))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureAlloc() failed");
VSIFree(pabyBuffer);
VSIFCloseL( fpImage );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Acquire source imagery. */
/* -------------------------------------------------------------------- */
CPLErr eErr = CE_None;
eErr = poSrcDS->RasterIO( GF_Read, 0, 0, nXSize, nYSize,
pabyBuffer, nXSize, nYSize, GDT_Byte,
nBands, NULL,
nBands, nBands * nXSize, 1, NULL );
/* -------------------------------------------------------------------- */
/* Import and write to file */
/* -------------------------------------------------------------------- */
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
if (eErr == CE_None && nBands == 4)
{
if (!WebPPictureImportRGBA(&sPicture, pabyBuffer, nBands * nXSize))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureImportRGBA() failed");
eErr = CE_Failure;
}
}
else
#endif
if (eErr == CE_None &&
!WebPPictureImportRGB(&sPicture, pabyBuffer, nBands * nXSize))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureImportRGB() failed");
eErr = CE_Failure;
}
if (eErr == CE_None && !WebPEncode(&sConfig, &sPicture))
{
const char* pszErrorMsg = NULL;
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
switch(sPicture.error_code)
{
case VP8_ENC_ERROR_OUT_OF_MEMORY: pszErrorMsg = "Out of memory"; break;
case VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY: pszErrorMsg = "Out of memory while flushing bits"; break;
case VP8_ENC_ERROR_NULL_PARAMETER: pszErrorMsg = "A pointer parameter is NULL"; break;
case VP8_ENC_ERROR_INVALID_CONFIGURATION: pszErrorMsg = "Configuration is invalid"; break;
case VP8_ENC_ERROR_BAD_DIMENSION: pszErrorMsg = "Picture has invalid width/height"; break;
case VP8_ENC_ERROR_PARTITION0_OVERFLOW: pszErrorMsg = "Partition is bigger than 512k. Try using less SEGMENTS, or increase PARTITION_LIMIT value"; break;
case VP8_ENC_ERROR_PARTITION_OVERFLOW: pszErrorMsg = "Partition is bigger than 16M"; break;
case VP8_ENC_ERROR_BAD_WRITE: pszErrorMsg = "Error while flusing bytes"; break;
case VP8_ENC_ERROR_FILE_TOO_BIG: pszErrorMsg = "File is bigger than 4G"; break;
case VP8_ENC_ERROR_USER_ABORT: pszErrorMsg = "User interrupted"; break;
default: break;
}
#endif
if (pszErrorMsg)
CPLError(CE_Failure, CPLE_AppDefined, "WebPEncode() failed : %s", pszErrorMsg);
else
CPLError(CE_Failure, CPLE_AppDefined, "WebPEncode() failed");
eErr = CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Cleanup and close. */
/* -------------------------------------------------------------------- */
CPLFree( pabyBuffer );
WebPPictureFree(&sPicture);
VSIFCloseL( fpImage );
if( eErr != CE_None )
{
VSIUnlink( pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Re-open dataset, and copy any auxiliary pam information. */
/* -------------------------------------------------------------------- */
GDALOpenInfo oOpenInfo(pszFilename, GA_ReadOnly);
/* If outputing to stdout, we can't reopen it, so we'll return */
/* a fake dataset to make the caller happy */
CPLPushErrorHandler(CPLQuietErrorHandler);
WEBPDataset *poDS = (WEBPDataset*) WEBPDataset::Open( &oOpenInfo );
CPLPopErrorHandler();
if( poDS )
{
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
return poDS;
}
return NULL;
}
GDALDataset *ARGDataset::CreateCopy( const char *pszFilename,
GDALDataset *poSrcDS,
int /* bStrict */ ,
char ** /* papszOptions */ ,
GDALProgressFunc /* pfnProgress */ ,
void * /*pProgressData */ )
{
const int nBands = poSrcDS->GetRasterCount();
if( nBands != 1 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"ARG driver doesn't support %d bands. Must be 1 band.", nBands );
return nullptr;
}
CPLString pszDataType;
int nPixelOffset = 0;
GDALDataType eType = poSrcDS->GetRasterBand(1)->GetRasterDataType();
if( eType == GDT_Unknown ||
eType == GDT_CInt16 ||
eType == GDT_CInt32 ||
eType == GDT_CFloat32 ||
eType == GDT_CFloat64 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"ARG driver doesn't support data type %s.",
GDALGetDataTypeName(eType) );
return nullptr;
}
else if (eType == GDT_Int16) {
pszDataType = "int16";
nPixelOffset = 2;
}
else if (eType == GDT_Int32) {
pszDataType = "int32";
nPixelOffset = 4;
}
else if (eType == GDT_Byte) {
pszDataType = "uint8";
nPixelOffset = 1;
}
else if (eType == GDT_UInt16) {
pszDataType = "uint16";
nPixelOffset = 2;
}
else if (eType == GDT_UInt32) {
pszDataType = "uint32";
nPixelOffset = 4;
}
else if (eType == GDT_Float32) {
pszDataType = "float32";
nPixelOffset = 4;
}
else if (eType == GDT_Float64) {
pszDataType = "float64";
nPixelOffset = 8;
}
double adfTransform[6];
poSrcDS->GetGeoTransform( adfTransform );
const char *pszWKT = poSrcDS->GetProjectionRef();
OGRSpatialReference oSRS;
OGRErr nErr = oSRS.importFromWkt(pszWKT);
if (nErr != OGRERR_NONE) {
CPLError( CE_Failure, CPLE_NotSupported,
"Cannot import spatial reference WKT from source dataset.");
return nullptr;
}
int nSrs = 0;
if (oSRS.GetAuthorityCode("PROJCS") != nullptr) {
nSrs = atoi(oSRS.GetAuthorityCode("PROJCS"));
}
else if (oSRS.GetAuthorityCode("GEOGCS") != nullptr) {
nSrs = atoi(oSRS.GetAuthorityCode("GEOGCS"));
}
else {
// could not determine projected or geographic code
// default to EPSG:3857 if no code could be found
nSrs = 3857;
}
/********************************************************************/
/* Create JSON companion file. */
/********************************************************************/
const CPLString osJSONFilename = GetJsonFilename(pszFilename);
json_object *poJSONObject = json_object_new_object();
char **pszTokens = poSrcDS->GetMetadata();
const char *pszLayer = CSLFetchNameValue(pszTokens, "LAYER");
if ( pszLayer == nullptr) {
// Set the layer
json_object_object_add(poJSONObject, "layer", json_object_new_string(
CPLGetBasename(osJSONFilename)
));
}
else {
// Set the layer
json_object_object_add(poJSONObject, "layer", json_object_new_string(
pszLayer
));
}
// Set the type
json_object_object_add(poJSONObject, "type", json_object_new_string("arg"));
// Set the datatype
json_object_object_add(poJSONObject, "datatype", json_object_new_string(pszDataType));
const int nXSize = poSrcDS->GetRasterXSize();
const int nYSize = poSrcDS->GetRasterYSize();
// Set the number of rows
json_object_object_add(poJSONObject, "rows", json_object_new_int(nYSize));
// Set the number of columns
json_object_object_add(poJSONObject, "cols", json_object_new_int(nXSize));
// Set the xmin
json_object_object_add(poJSONObject, "xmin", json_object_new_double(adfTransform[0]));
// Set the ymax
json_object_object_add(poJSONObject, "ymax", json_object_new_double(adfTransform[3]));
// Set the cellwidth
json_object_object_add(poJSONObject, "cellwidth", json_object_new_double(adfTransform[1]));
// Set the cellheight
json_object_object_add(poJSONObject, "cellheight", json_object_new_double(-adfTransform[5]));
// Set the xmax
json_object_object_add(poJSONObject, "xmax", json_object_new_double(adfTransform[0] + nXSize * adfTransform[1]));
// Set the ymin
json_object_object_add(poJSONObject, "ymin", json_object_new_double(adfTransform[3] + nYSize * adfTransform[5]));
// Set the xskew
json_object_object_add(poJSONObject, "xskew", json_object_new_double(adfTransform[2]));
// Set the yskew
json_object_object_add(poJSONObject, "yskew", json_object_new_double(adfTransform[4]));
if (nSrs > 0) {
// Set the epsg
json_object_object_add(poJSONObject, "epsg", json_object_new_int(nSrs));
}
if (json_object_to_file(const_cast<char *>(osJSONFilename.c_str()), poJSONObject) < 0) {
CPLError( CE_Failure, CPLE_NotSupported,
"ARG driver can't write companion file.");
json_object_put(poJSONObject);
poJSONObject = nullptr;
return nullptr;
}
json_object_put(poJSONObject);
poJSONObject = nullptr;
VSILFILE *fpImage = VSIFOpenL(pszFilename, "wb");
if (fpImage == nullptr)
{
CPLError( CE_Failure, CPLE_NotSupported,
"ARG driver can't create data file %s.", pszFilename);
// remove JSON file
VSIUnlink( osJSONFilename.c_str() );
return nullptr;
}
// only 1 raster band
GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( 1 );
#ifdef CPL_LSB
bool bNative = false;
#else
bool bNative = true;
#endif
RawRasterBand *poDstBand = new RawRasterBand( fpImage, 0, nPixelOffset,
nPixelOffset * nXSize, eType,
bNative,
nXSize, nYSize,
RawRasterBand::OwnFP::NO);
int nXBlockSize, nYBlockSize;
poSrcBand->GetBlockSize(&nXBlockSize, &nYBlockSize);
void *pabyData = CPLMalloc(nXBlockSize * nPixelOffset);
// convert any blocks into scanlines
for (int nYBlock = 0; nYBlock * nYBlockSize < nYSize; nYBlock++) {
for (int nYScanline = 0; nYScanline < nYBlockSize; nYScanline++) {
if ((nYScanline+1) + nYBlock * nYBlockSize > poSrcBand->GetYSize() )
{
continue;
}
for (int nXBlock = 0; nXBlock * nXBlockSize < nXSize; nXBlock++) {
int nXValid;
if( (nXBlock+1) * nXBlockSize > poSrcBand->GetXSize() )
nXValid = poSrcBand->GetXSize() - nXBlock * nXBlockSize;
else
nXValid = nXBlockSize;
CPLErr eErr = poSrcBand->RasterIO(GF_Read, nXBlock * nXBlockSize,
nYBlock * nYBlockSize + nYScanline, nXValid, 1, pabyData, nXBlockSize,
1, eType, 0, 0, nullptr);
if (eErr != CE_None) {
CPLError(CE_Failure, CPLE_AppDefined, "Error reading.");
CPLFree( pabyData );
delete poDstBand;
VSIFCloseL( fpImage );
return nullptr;
}
eErr = poDstBand->RasterIO(GF_Write, nXBlock * nXBlockSize,
nYBlock * nYBlockSize + nYScanline, nXValid, 1, pabyData, nXBlockSize,
1, eType, 0, 0, nullptr);
if (eErr != CE_None) {
CPLError(CE_Failure, CPLE_AppDefined, "Error writing.");
CPLFree( pabyData );
delete poDstBand;
VSIFCloseL( fpImage );
return nullptr;
}
}
}
}
CPLFree( pabyData );
delete poDstBand;
VSIFCloseL( fpImage );
return reinterpret_cast<GDALDataset *>( GDALOpen( pszFilename, GA_ReadOnly ) );
}
int main(int argc, char* argv[])
{
int i;
int nThreads = CPLGetNumCPUs();
std::vector<CPLJoinableThread*> apsThreads;
Strategy eStrategy = STRATEGY_RANDOM;
int bNewDatasetOption = FALSE;
int nXSize = 5000;
int nYSize = 5000;
int nBands = 4;
char** papszOptions = NULL;
int bOnDisk = FALSE;
std::vector<ThreadDescription> asThreadDescription;
int bMemDriver = FALSE;
GDALDataset* poMEMDS = NULL;
int bMigrate = FALSE;
int nMaxRequests = -1;
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
GDALAllRegister();
for(i = 1; i < argc; i++)
{
if( EQUAL(argv[i], "-threads") && i + 1 < argc)
{
i ++;
nThreads = atoi(argv[i]);
}
else if( EQUAL(argv[i], "-loops") && i + 1 < argc)
{
i ++;
nLoops = atoi(argv[i]);
if( nLoops <= 0 )
nLoops = INT_MAX;
}
else if( EQUAL(argv[i], "-max_requests") && i + 1 < argc)
{
i ++;
nMaxRequests = atoi(argv[i]);
}
else if( EQUAL(argv[i], "-strategy") && i + 1 < argc)
{
i ++;
if( EQUAL(argv[i], "random") )
eStrategy = STRATEGY_RANDOM;
else if( EQUAL(argv[i], "line") )
eStrategy = STRATEGY_LINE;
else if( EQUAL(argv[i], "block") )
eStrategy = STRATEGY_BLOCK;
else
Usage();
}
else if( EQUAL(argv[i], "-xsize") && i + 1 < argc)
{
i ++;
nXSize = atoi(argv[i]);
bNewDatasetOption = TRUE;
}
else if( EQUAL(argv[i], "-ysize") && i + 1 < argc)
{
i ++;
nYSize = atoi(argv[i]);
bNewDatasetOption = TRUE;
}
else if( EQUAL(argv[i], "-bands") && i + 1 < argc)
{
i ++;
nBands = atoi(argv[i]);
bNewDatasetOption = TRUE;
}
else if( EQUAL(argv[i], "-co") && i + 1 < argc)
{
i ++;
papszOptions = CSLAddString(papszOptions, argv[i]);
bNewDatasetOption = TRUE;
}
else if( EQUAL(argv[i], "-ondisk"))
{
bOnDisk = TRUE;
bNewDatasetOption = TRUE;
}
else if( EQUAL(argv[i], "-check"))
{
bCheck = TRUE;
bNewDatasetOption = TRUE;
}
else if( EQUAL(argv[i], "-memdriver"))
{
bMemDriver = TRUE;
bNewDatasetOption = TRUE;
}
else if( EQUAL(argv[i], "-migrate"))
bMigrate = TRUE;
else if( argv[i][0] == '-' )
Usage();
else if( pszDataset == NULL )
pszDataset = argv[i];
else
{
Usage();
}
}
if( pszDataset != NULL && bNewDatasetOption )
Usage();
CPLDebug("TEST", "Using %d threads", nThreads);
int bCreatedDataset = FALSE;
if( pszDataset == NULL )
{
bCreatedDataset = TRUE;
if( bOnDisk )
pszDataset = "/tmp/tmp.tif";
else
pszDataset = "/vsimem/tmp.tif";
GDALDataset* poDS = ((GDALDriver*)GDALGetDriverByName((bMemDriver) ? "MEM" : "GTiff"))->Create(pszDataset,
nXSize, nYSize, nBands, GDT_Byte, papszOptions);
if( bCheck )
{
GByte* pabyLine = (GByte*) VSIMalloc(nBands * nXSize);
for(int iY=0;iY<nYSize;iY++)
{
for(int iX=0;iX<nXSize;iX++)
{
for(int iBand=0;iBand<nBands;iBand++)
{
unsigned long seed = iBand * nXSize * nYSize + iY * nXSize + iX;
pabyLine[iBand * nXSize + iX] = (GByte)(myrand_r(&seed) & 0xff);
}
}
CPL_IGNORE_RET_VAL(poDS->RasterIO(GF_Write, 0, iY, nXSize, 1,
pabyLine, nXSize, 1,
GDT_Byte,
nBands, NULL,
0, 0, 0
#ifdef GDAL_COMPILATION
, NULL
#endif
));
}
VSIFree(pabyLine);
}
if( bMemDriver )
poMEMDS = poDS;
else
GDALClose(poDS);
}
else
{
bCheck = FALSE;
}
CSLDestroy(papszOptions);
papszOptions = NULL;
Request* psGlobalRequestLast = NULL;
for(i = 0; i < nThreads; i++ )
{
GDALDataset* poDS;
// Since GDAL 2.0, the MEM driver is thread-safe, i.e. does not use the block
// cache, but only for operations not involving resampling, which is
// the case here
if( poMEMDS )
poDS = poMEMDS;
else
{
poDS = (GDALDataset*)GDALOpen(pszDataset, GA_ReadOnly);
if( poDS == NULL )
exit(1);
}
if( bMigrate )
{
Resource* psResource = (Resource*)CPLMalloc(sizeof(Resource));
psResource->poDS = poDS;
int nBufferSize;
if( eStrategy == STRATEGY_RANDOM )
nBufferSize = CreateRandomStrategyRequests(
poDS, nMaxRequests, psGlobalRequestList, psGlobalRequestLast);
else if( eStrategy == STRATEGY_LINE )
nBufferSize = CreateLineStrategyRequests(
poDS, nMaxRequests, psGlobalRequestList, psGlobalRequestLast);
else
nBufferSize = CreateBlockStrategyRequests(
poDS, nMaxRequests, psGlobalRequestList, psGlobalRequestLast);
psResource->pBuffer = CPLMalloc(nBufferSize);
PutResourceAtEnd(psResource);
}
else
{
ThreadDescription sThreadDescription;
sThreadDescription.poDS = poDS;
sThreadDescription.psRequestList = NULL;
Request* psRequestLast = NULL;
if( eStrategy == STRATEGY_RANDOM )
sThreadDescription.nBufferSize = CreateRandomStrategyRequests(
poDS, nMaxRequests, sThreadDescription.psRequestList, psRequestLast);
else if( eStrategy == STRATEGY_LINE )
sThreadDescription.nBufferSize = CreateLineStrategyRequests(
poDS, nMaxRequests, sThreadDescription.psRequestList, psRequestLast);
else
sThreadDescription.nBufferSize = CreateBlockStrategyRequests(
poDS, nMaxRequests, sThreadDescription.psRequestList, psRequestLast);
asThreadDescription.push_back(sThreadDescription);
}
}
if( bCreatedDataset && poMEMDS == NULL && bOnDisk )
{
CPLPushErrorHandler(CPLQuietErrorHandler);
VSIUnlink(pszDataset);
CPLPopErrorHandler();
}
if( bMigrate )
{
psLock = CPLCreateLock(LOCK_SPIN);
}
for(i = 0; i < nThreads; i++ )
{
CPLJoinableThread* pThread;
if( bMigrate )
pThread = CPLCreateJoinableThread(ThreadFuncWithMigration, NULL);
else
pThread = CPLCreateJoinableThread(ThreadFuncDedicatedDataset,
&(asThreadDescription[i]));
apsThreads.push_back(pThread);
}
for(i = 0; i < nThreads; i++ )
{
CPLJoinThread(apsThreads[i]);
if( !bMigrate && poMEMDS == NULL )
GDALClose(asThreadDescription[i].poDS);
}
while( psGlobalResourceList != NULL )
{
CPLFree( psGlobalResourceList->pBuffer);
if( poMEMDS == NULL )
GDALClose(psGlobalResourceList->poDS);
Resource* psNext = psGlobalResourceList->psNext;
CPLFree( psGlobalResourceList );
psGlobalResourceList = psNext;
}
if( psLock )
{
CPLDestroyLock( psLock );
}
if( bCreatedDataset && poMEMDS == NULL )
{
CPLPushErrorHandler(CPLQuietErrorHandler);
VSIUnlink(pszDataset);
CPLPopErrorHandler();
}
if( poMEMDS )
GDALClose(poMEMDS);
assert( GDALGetCacheUsed64() == 0 );
GDALDestroyDriverManager();
CSLDestroy( argv );
return 0;
}
CPLErr GDALWriteRPBFile( const char *pszFilename, char **papszMD )
{
CPLString osRPBFilename = CPLResetExtension( pszFilename, "RPB" );
/* -------------------------------------------------------------------- */
/* Read file and parse. */
/* -------------------------------------------------------------------- */
VSILFILE *fp = VSIFOpenL( osRPBFilename, "w" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create %s for writing.\n%s",
osRPBFilename.c_str(), CPLGetLastErrorMsg() );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Write the prefix information. */
/* -------------------------------------------------------------------- */
VSIFPrintfL( fp, "%s", "satId = \"QB02\";\n" );
VSIFPrintfL( fp, "%s", "bandId = \"P\";\n" );
VSIFPrintfL( fp, "%s", "SpecId = \"RPC00B\";\n" );
VSIFPrintfL( fp, "%s", "BEGIN_GROUP = IMAGE\n" );
VSIFPrintfL( fp, "%s", "\terrBias = 0.0;\n" );
VSIFPrintfL( fp, "%s", "\terrRand = 0.0;\n" );
/* -------------------------------------------------------------------- */
/* Write RPC values from our RPC metadata. */
/* -------------------------------------------------------------------- */
int i;
for( i = 0; apszRPBMap[i] != NULL; i += 2 )
{
const char *pszRPBVal = CSLFetchNameValue( papszMD, apszRPBMap[i] );
const char *pszRPBTag;
if( pszRPBVal == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s field missing in metadata, %s file not written.",
apszRPBMap[i], osRPBFilename.c_str() );
VSIFCloseL( fp );
VSIUnlink( osRPBFilename );
return CE_Failure;
}
pszRPBTag = apszRPBMap[i+1];
if( EQUALN(pszRPBTag,"IMAGE.",6) )
pszRPBTag += 6;
if( strstr(apszRPBMap[i], "COEF" ) == NULL )
{
VSIFPrintfL( fp, "\t%s = %s;\n", pszRPBTag, pszRPBVal );
}
else
{
// Reformat in brackets with commas over multiple lines.
VSIFPrintfL( fp, "\t%s = (\n", pszRPBTag );
char **papszItems = CSLTokenizeStringComplex( pszRPBVal, " ,",
FALSE, FALSE );
if( CSLCount(papszItems) != 20 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s field is corrupt (not 20 values), %s file not written.\n%s = %s",
apszRPBMap[i], osRPBFilename.c_str(),
apszRPBMap[i], pszRPBVal );
VSIFCloseL( fp );
VSIUnlink( osRPBFilename );
CSLDestroy( papszItems );
return CE_Failure;
}
int j;
for( j = 0; j < 20; j++ )
{
if( j < 19 )
VSIFPrintfL( fp, "\t\t\t%s,\n", papszItems[j] );
else
VSIFPrintfL( fp, "\t\t\t%s);\n", papszItems[j] );
}
CSLDestroy( papszItems );
}
}
/* -------------------------------------------------------------------- */
/* Write end part */
/* -------------------------------------------------------------------- */
VSIFPrintfL( fp, "%s", "END_GROUP = IMAGE\n" );
VSIFPrintfL( fp, "END;\n" );
VSIFCloseL( fp );
return CE_None;
}
CPLErr GDALWriteRPCTXTFile( const char *pszFilename, char **papszMD )
{
CPLString osRPCFilename = pszFilename;
CPLString soPt(".");
size_t found = osRPCFilename.rfind(soPt);
if (found == CPLString::npos)
return CE_Failure;
osRPCFilename.replace (found, osRPCFilename.size() - found, "_RPC.TXT");
/* -------------------------------------------------------------------- */
/* Read file and parse. */
/* -------------------------------------------------------------------- */
VSILFILE *fp = VSIFOpenL( osRPCFilename, "w" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create %s for writing.\n%s",
osRPCFilename.c_str(), CPLGetLastErrorMsg() );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Write RPC values from our RPC metadata. */
/* -------------------------------------------------------------------- */
int i;
for( i = 0; apszRPCTXTSingleValItems[i] != NULL; i ++ )
{
const char *pszRPCVal = CSLFetchNameValue( papszMD, apszRPCTXTSingleValItems[i] );
if( pszRPCVal == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s field missing in metadata, %s file not written.",
apszRPCTXTSingleValItems[i], osRPCFilename.c_str() );
VSIFCloseL( fp );
VSIUnlink( osRPCFilename );
return CE_Failure;
}
VSIFPrintfL( fp, "%s: %s\n", apszRPCTXTSingleValItems[i], pszRPCVal );
}
for( i = 0; apszRPCTXT20ValItems[i] != NULL; i ++ )
{
const char *pszRPCVal = CSLFetchNameValue( papszMD, apszRPCTXT20ValItems[i] );
if( pszRPCVal == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s field missing in metadata, %s file not written.",
apszRPCTXTSingleValItems[i], osRPCFilename.c_str() );
VSIFCloseL( fp );
VSIUnlink( osRPCFilename );
return CE_Failure;
}
char **papszItems = CSLTokenizeStringComplex( pszRPCVal, " ,",
FALSE, FALSE );
if( CSLCount(papszItems) != 20 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s field is corrupt (not 20 values), %s file not written.\n%s = %s",
apszRPCTXT20ValItems[i], osRPCFilename.c_str(),
apszRPCTXT20ValItems[i], pszRPCVal );
VSIFCloseL( fp );
VSIUnlink( osRPCFilename );
CSLDestroy( papszItems );
return CE_Failure;
}
int j;
for( j = 0; j < 20; j++ )
{
VSIFPrintfL( fp, "%s_%d: %s\n", apszRPCTXT20ValItems[i], j+1,
papszItems[j] );
}
CSLDestroy( papszItems );
}
VSIFCloseL( fp );
return CE_None;
}
OGRErr OGRShapeLayer::Repack()
{
if( !bUpdateAccess )
{
CPLError( CE_Failure, CPLE_AppDefined,
"The REPACK operation is not permitted on a read-only shapefile." );
return OGRERR_FAILURE;
}
if( hDBF == NULL )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Attempt to repack a shapefile with no .dbf file not supported.");
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Build a list of records to be dropped. */
/* -------------------------------------------------------------------- */
int *panRecordsToDelete = (int *)
CPLMalloc(sizeof(int)*(nTotalShapeCount+1));
int nDeleteCount = 0;
int iShape = 0;
OGRErr eErr = OGRERR_NONE;
for( iShape = 0; iShape < nTotalShapeCount; iShape++ )
{
if( DBFIsRecordDeleted( hDBF, iShape ) )
panRecordsToDelete[nDeleteCount++] = iShape;
}
panRecordsToDelete[nDeleteCount] = -1;
/* -------------------------------------------------------------------- */
/* If there are no records marked for deletion, we take no */
/* action. */
/* -------------------------------------------------------------------- */
if( nDeleteCount == 0 )
{
CPLFree( panRecordsToDelete );
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* Find existing filenames with exact case (see #3293). */
/* -------------------------------------------------------------------- */
CPLString osDirname(CPLGetPath(pszFullName));
CPLString osBasename(CPLGetBasename(pszFullName));
CPLString osDBFName, osSHPName, osSHXName;
char **papszCandidates = CPLReadDir( osDirname );
int i = 0;
while(papszCandidates != NULL && papszCandidates[i] != NULL)
{
CPLString osCandidateBasename = CPLGetBasename(papszCandidates[i]);
CPLString osCandidateExtension = CPLGetExtension(papszCandidates[i]);
if (osCandidateBasename.compare(osBasename) == 0)
{
if (EQUAL(osCandidateExtension, "dbf"))
osDBFName = CPLFormFilename(osDirname, papszCandidates[i], NULL);
else if (EQUAL(osCandidateExtension, "shp"))
osSHPName = CPLFormFilename(osDirname, papszCandidates[i], NULL);
else if (EQUAL(osCandidateExtension, "shx"))
osSHXName = CPLFormFilename(osDirname, papszCandidates[i], NULL);
}
i++;
}
CSLDestroy(papszCandidates);
papszCandidates = NULL;
if (osDBFName.size() == 0)
{
/* Should not happen, really */
CPLFree( panRecordsToDelete );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Cleanup any existing spatial index. It will become */
/* meaningless when the fids change. */
/* -------------------------------------------------------------------- */
if( CheckForQIX() )
DropSpatialIndex();
/* -------------------------------------------------------------------- */
/* Create a new dbf file, matching the old. */
/* -------------------------------------------------------------------- */
DBFHandle hNewDBF = NULL;
CPLString oTempFile(CPLFormFilename(osDirname, osBasename, NULL));
oTempFile += "_packed.dbf";
hNewDBF = DBFCloneEmpty( hDBF, oTempFile );
if( hNewDBF == NULL )
{
CPLFree( panRecordsToDelete );
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create temp file %s.",
oTempFile.c_str() );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Copy over all records that are not deleted. */
/* -------------------------------------------------------------------- */
int iDestShape = 0;
int iNextDeletedShape = 0;
for( iShape = 0;
iShape < nTotalShapeCount && eErr == OGRERR_NONE;
iShape++ )
{
if( panRecordsToDelete[iNextDeletedShape] == iShape )
iNextDeletedShape++;
else
{
void *pTuple = (void *) DBFReadTuple( hDBF, iShape );
if( pTuple == NULL )
eErr = OGRERR_FAILURE;
else if( !DBFWriteTuple( hNewDBF, iDestShape++, pTuple ) )
eErr = OGRERR_FAILURE;
}
}
if( eErr != OGRERR_NONE )
{
CPLFree( panRecordsToDelete );
VSIUnlink( oTempFile );
return eErr;
}
/* -------------------------------------------------------------------- */
/* Cleanup the old .dbf and rename the new one. */
/* -------------------------------------------------------------------- */
DBFClose( hDBF );
DBFClose( hNewDBF );
hDBF = hNewDBF = NULL;
VSIUnlink( osDBFName );
if( VSIRename( oTempFile, osDBFName ) != 0 )
{
CPLDebug( "Shape", "Can not rename DBF file: %s", VSIStrerror( errno ) );
CPLFree( panRecordsToDelete );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Now create a shapefile matching the old one. */
/* -------------------------------------------------------------------- */
if( hSHP != NULL )
{
SHPHandle hNewSHP = NULL;
if (osSHPName.size() == 0 || osSHXName.size() == 0)
{
/* Should not happen, really */
CPLFree( panRecordsToDelete );
return OGRERR_FAILURE;
}
oTempFile = CPLFormFilename(osDirname, osBasename, NULL);
oTempFile += "_packed.shp";
hNewSHP = SHPCreate( oTempFile, hSHP->nShapeType );
if( hNewSHP == NULL )
{
CPLFree( panRecordsToDelete );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Copy over all records that are not deleted. */
/* -------------------------------------------------------------------- */
iNextDeletedShape = 0;
for( iShape = 0;
iShape < nTotalShapeCount && eErr == OGRERR_NONE;
iShape++ )
{
if( panRecordsToDelete[iNextDeletedShape] == iShape )
iNextDeletedShape++;
else
{
SHPObject *hObject;
hObject = SHPReadObject( hSHP, iShape );
if( hObject == NULL )
eErr = OGRERR_FAILURE;
else if( SHPWriteObject( hNewSHP, -1, hObject ) == -1 )
eErr = OGRERR_FAILURE;
if( hObject )
SHPDestroyObject( hObject );
}
}
if( eErr != OGRERR_NONE )
{
CPLFree( panRecordsToDelete );
VSIUnlink( CPLResetExtension( oTempFile, "shp" ) );
VSIUnlink( CPLResetExtension( oTempFile, "shx" ) );
return eErr;
}
/* -------------------------------------------------------------------- */
/* Cleanup the old .shp/.shx and rename the new one. */
/* -------------------------------------------------------------------- */
SHPClose( hSHP );
SHPClose( hNewSHP );
hSHP = hNewSHP = NULL;
VSIUnlink( osSHPName );
VSIUnlink( osSHXName );
oTempFile = CPLResetExtension( oTempFile, "shp" );
if( VSIRename( oTempFile, osSHPName ) != 0 )
{
CPLDebug( "Shape", "Can not rename SHP file: %s", VSIStrerror( errno ) );
CPLFree( panRecordsToDelete );
return OGRERR_FAILURE;
}
oTempFile = CPLResetExtension( oTempFile, "shx" );
if( VSIRename( oTempFile, osSHXName ) != 0 )
{
CPLDebug( "Shape", "Can not rename SHX file: %s", VSIStrerror( errno ) );
CPLFree( panRecordsToDelete );
return OGRERR_FAILURE;
}
}
CPLFree( panRecordsToDelete );
panRecordsToDelete = NULL;
/* -------------------------------------------------------------------- */
/* Reopen the shapefile */
/* */
/* We do not need to reimplement OGRShapeDataSource::OpenFile() here */
/* with the fully featured error checking. */
/* If all operations above succeeded, then all necessery files are */
/* in the right place and accessible. */
/* -------------------------------------------------------------------- */
CPLAssert( NULL == hSHP );
CPLAssert( NULL == hDBF && NULL == hNewDBF );
CPLPushErrorHandler( CPLQuietErrorHandler );
const char* pszAccess = NULL;
if( bUpdateAccess )
pszAccess = "r+";
else
pszAccess = "r";
hSHP = SHPOpen ( CPLResetExtension( pszFullName, "shp" ) , pszAccess );
hDBF = DBFOpen ( CPLResetExtension( pszFullName, "dbf" ) , pszAccess );
CPLPopErrorHandler();
if( NULL == hSHP || NULL == hDBF )
{
CPLString osMsg(CPLGetLastErrorMsg());
CPLError( CE_Failure, CPLE_OpenFailed, "%s", osMsg.c_str() );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Update total shape count. */
/* -------------------------------------------------------------------- */
nTotalShapeCount = hDBF->nRecords;
return OGRERR_NONE;
}
int NITFUncompressBILEVEL( NITFImage *psImage,
GByte *pabyInputData, int nInputBytes,
GByte *pabyOutputImage )
{
int nOutputBytes= (psImage->nBlockWidth * psImage->nBlockHeight + 7)/8;
/* -------------------------------------------------------------------- */
/* Write memory TIFF with the bilevel data. */
/* -------------------------------------------------------------------- */
CPLString osFilename;
osFilename.Printf( "/vsimem/nitf-wrk-%ld.tif", (long) CPLGetPID() );
VSILFILE* fpL = VSIFOpenL(osFilename, "w+");
if( fpL == NULL )
return FALSE;
TIFF *hTIFF = VSI_TIFFOpen( osFilename, "w+", fpL );
if (hTIFF == NULL)
{
VSIFCloseL(fpL);
return FALSE;
}
TIFFSetField( hTIFF, TIFFTAG_IMAGEWIDTH, psImage->nBlockWidth );
TIFFSetField( hTIFF, TIFFTAG_IMAGELENGTH, psImage->nBlockHeight );
TIFFSetField( hTIFF, TIFFTAG_BITSPERSAMPLE, 1 );
TIFFSetField( hTIFF, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT );
TIFFSetField( hTIFF, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG );
TIFFSetField( hTIFF, TIFFTAG_FILLORDER, FILLORDER_MSB2LSB );
TIFFSetField( hTIFF, TIFFTAG_ROWSPERSTRIP, psImage->nBlockHeight );
TIFFSetField( hTIFF, TIFFTAG_SAMPLESPERPIXEL, 1 );
TIFFSetField( hTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK );
TIFFSetField( hTIFF, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX3 );
if( psImage->szCOMRAT[0] == '2' )
TIFFSetField( hTIFF, TIFFTAG_GROUP3OPTIONS, GROUP3OPT_2DENCODING );
TIFFWriteRawStrip( hTIFF, 0, pabyInputData, nInputBytes );
TIFFWriteDirectory( hTIFF );
TIFFClose( hTIFF );
/* -------------------------------------------------------------------- */
/* Now open and read it back. */
/* -------------------------------------------------------------------- */
int bResult = TRUE;
hTIFF = VSI_TIFFOpen( osFilename, "r", fpL );
if (hTIFF == NULL)
{
VSIFCloseL(fpL);
return FALSE;
}
if( TIFFReadEncodedStrip( hTIFF, 0, pabyOutputImage, nOutputBytes ) == -1 )
{
memset( pabyOutputImage, 0, nOutputBytes );
bResult = FALSE;
}
TIFFClose( hTIFF );
VSIFCloseL(fpL);
VSIUnlink( osFilename );
return bResult;
}
static void msTransformToGeospatialPDF(imageObj *img, mapObj *map, cairo_renderer *r)
{
/* We need a GDAL 1.10 PDF driver at runtime, but as far as the C API is concerned, GDAL 1.9 is */
/* largely sufficient. */
#if defined(USE_GDAL) && defined(GDAL_VERSION_NUM) && GDAL_VERSION_NUM >= 1900
GDALDatasetH hDS = NULL;
const char* pszGEO_ENCODING = NULL;
GDALDriverH hPDFDriver = NULL;
const char* pszVirtualIO = NULL;
int bVirtualIO = FALSE;
char* pszTmpFilename = NULL;
VSILFILE* fp = NULL;
if (map == NULL)
return;
pszGEO_ENCODING = msGetOutputFormatOption(img->format, "GEO_ENCODING", NULL);
if (pszGEO_ENCODING == NULL)
return;
msGDALInitialize();
hPDFDriver = GDALGetDriverByName("PDF");
if (hPDFDriver == NULL)
return;
/* When compiled against libpoppler, the PDF driver is VirtualIO capable */
/* but not, when it is compiled against libpodofo. */
pszVirtualIO = GDALGetMetadataItem( hPDFDriver, GDAL_DCAP_VIRTUALIO, NULL );
if (pszVirtualIO)
bVirtualIO = CSLTestBoolean(pszVirtualIO);
if (bVirtualIO)
pszTmpFilename = msTmpFile(map, NULL, "/vsimem/mscairopdf/", "pdf");
else
pszTmpFilename = msTmpFile(map, map->mappath, NULL, "pdf");
/* Copy content of outputStream buffer into file */
fp = VSIFOpenL(pszTmpFilename, "wb");
if (fp == NULL) {
msFree(pszTmpFilename);
return;
}
VSIFWriteL(r->outputStream->data, 1, r->outputStream->size, fp);
VSIFCloseL(fp);
fp = NULL;
hDS = GDALOpen(pszTmpFilename, GA_Update);
if ( hDS != NULL ) {
char* pszWKT = msProjectionObj2OGCWKT( &(map->projection) );
if( pszWKT != NULL ) {
double adfGeoTransform[6];
int i;
/* Add user-specified options */
for( i = 0; i < img->format->numformatoptions; i++ ) {
const char* pszOption = img->format->formatoptions[i];
if( strncasecmp(pszOption,"METADATA_ITEM:",14) == 0 ) {
char* pszKey = NULL;
const char* pszValue = CPLParseNameValue(pszOption + 14,
&pszKey);
if( pszKey != NULL ) {
GDALSetMetadataItem(hDS, pszKey, pszValue, NULL);
CPLFree(pszKey);
}
}
}
/* We need to rescale the geotransform because GDAL will not necessary */
/* open the PDF with the DPI that was used to generate it */
memcpy(adfGeoTransform, map->gt.geotransform, 6 * sizeof(double));
adfGeoTransform[1] = adfGeoTransform[1] * map->width / GDALGetRasterXSize(hDS);
adfGeoTransform[5] = adfGeoTransform[5] * map->height / GDALGetRasterYSize(hDS);
GDALSetGeoTransform(hDS, adfGeoTransform);
GDALSetProjection(hDS, pszWKT);
msFree( pszWKT );
pszWKT = NULL;
CPLSetThreadLocalConfigOption("GDAL_PDF_GEO_ENCODING", pszGEO_ENCODING);
GDALClose(hDS);
hDS = NULL;
CPLSetThreadLocalConfigOption("GDAL_PDF_GEO_ENCODING", NULL);
/* We need to replace the buffer with the content of the GDAL file */
fp = VSIFOpenL(pszTmpFilename, "rb");
if( fp != NULL ) {
int nFileSize;
VSIFSeekL(fp, 0, SEEK_END);
nFileSize = (int)VSIFTellL(fp);
msBufferResize(r->outputStream, nFileSize);
VSIFSeekL(fp, 0, SEEK_SET);
r->outputStream->size = VSIFReadL(r->outputStream->data, 1, nFileSize, fp);
VSIFCloseL(fp);
fp = NULL;
}
}
}
if ( hDS != NULL )
GDALClose(hDS);
VSIUnlink(pszTmpFilename);
msFree(pszTmpFilename);
#endif
}
CPLErr RasterliteDataset::CreateOverviewLevel(int nOvrFactor,
GDALProgressFunc pfnProgress,
void * pProgressData)
{
double dfXResolution = padfXResolutions[0] * nOvrFactor;
double dfYResolution = padfXResolutions[0] * nOvrFactor;
CPLString osSQL;
int nBlockXSize = 256;
int nBlockYSize = 256;
int nOvrXSize = nRasterXSize / nOvrFactor;
int nOvrYSize = nRasterYSize / nOvrFactor;
if (nOvrXSize == 0 || nOvrYSize == 0)
return CE_Failure;
int nXBlocks = (nOvrXSize + nBlockXSize - 1) / nBlockXSize;
int nYBlocks = (nOvrYSize + nBlockYSize - 1) / nBlockYSize;
const char* pszDriverName = "GTiff";
GDALDriverH hTileDriver = GDALGetDriverByName(pszDriverName);
if (hTileDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL %s driver", pszDriverName);
return CE_Failure;
}
GDALDriverH hMemDriver = GDALGetDriverByName("MEM");
if (hMemDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL MEM driver");
return CE_Failure;
}
GDALDataType eDataType = GetRasterBand(1)->GetRasterDataType();
int nDataTypeSize = GDALGetDataTypeSize(eDataType) / 8;
GByte* pabyMEMDSBuffer =
(GByte*)VSIMalloc3(nBlockXSize, nBlockYSize, nBands * nDataTypeSize);
if (pabyMEMDSBuffer == NULL)
{
return CE_Failure;
}
char** papszTileDriverOptions = NULL;
CPLString osTempFileName;
osTempFileName.Printf("/vsimem/%p", hDS);
int nTileId = 0;
int nBlocks = 0;
int nTotalBlocks = nXBlocks * nYBlocks;
CPLString osRasterLayer;
osRasterLayer.Printf("%s_rasters", osTableName.c_str());
CPLString osMetatadataLayer;
osMetatadataLayer.Printf("%s_metadata", osTableName.c_str());
OGRLayerH hRasterLayer = OGR_DS_GetLayerByName(hDS, osRasterLayer.c_str());
OGRLayerH hMetadataLayer = OGR_DS_GetLayerByName(hDS, osMetatadataLayer.c_str());
CPLString osSourceName = "unknown";
osSQL.Printf("SELECT source_name FROM \"%s\" WHERE "
"pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f LIMIT 1",
osMetatadataLayer.c_str(),
padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15,
padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15);
OGRLayerH hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
const char* pszVal = OGR_F_GetFieldAsString(hFeat, 0);
if (pszVal)
osSourceName = pszVal;
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
/* -------------------------------------------------------------------- */
/* Compute up to which existing overview level we can use for */
/* computing the requested overview */
/* -------------------------------------------------------------------- */
int iLev;
nLimitOvrCount = 0;
for(iLev=1;iLev<nResolutions;iLev++)
{
if (!(padfXResolutions[iLev] < dfXResolution - 1e-10 &&
padfYResolutions[iLev] < dfYResolution - 1e-10))
{
break;
}
nLimitOvrCount++;
}
/* -------------------------------------------------------------------- */
/* Iterate over blocks to add data into raster and metadata tables */
/* -------------------------------------------------------------------- */
OGR_DS_ExecuteSQL(hDS, "BEGIN", NULL, NULL);
CPLErr eErr = CE_None;
int nBlockXOff, nBlockYOff;
for(nBlockYOff=0;eErr == CE_None && nBlockYOff<nYBlocks;nBlockYOff++)
{
for(nBlockXOff=0;eErr == CE_None && nBlockXOff<nXBlocks;nBlockXOff++)
{
/* -------------------------------------------------------------------- */
/* Create in-memory tile */
/* -------------------------------------------------------------------- */
int nReqXSize = nBlockXSize, nReqYSize = nBlockYSize;
if ((nBlockXOff+1) * nBlockXSize > nOvrXSize)
nReqXSize = nOvrXSize - nBlockXOff * nBlockXSize;
if ((nBlockYOff+1) * nBlockYSize > nOvrYSize)
nReqYSize = nOvrYSize - nBlockYOff * nBlockYSize;
eErr = RasterIO(GF_Read,
nBlockXOff * nBlockXSize * nOvrFactor,
nBlockYOff * nBlockYSize * nOvrFactor,
nReqXSize * nOvrFactor, nReqYSize * nOvrFactor,
pabyMEMDSBuffer, nReqXSize, nReqYSize,
eDataType, nBands, NULL,
0, 0, 0);
if (eErr != CE_None)
{
break;
}
GDALDatasetH hMemDS = GDALCreate(hMemDriver, "MEM:::",
nReqXSize, nReqYSize, 0,
eDataType, NULL);
if (hMemDS == NULL)
{
eErr = CE_Failure;
break;
}
int iBand;
for(iBand = 0; iBand < nBands; iBand ++)
{
char** papszOptions = NULL;
char szTmp[64];
memset(szTmp, 0, sizeof(szTmp));
CPLPrintPointer(szTmp,
pabyMEMDSBuffer + iBand * nDataTypeSize *
nReqXSize * nReqYSize, sizeof(szTmp));
papszOptions = CSLSetNameValue(papszOptions, "DATAPOINTER", szTmp);
GDALAddBand(hMemDS, eDataType, papszOptions);
CSLDestroy(papszOptions);
}
GDALDatasetH hOutDS = GDALCreateCopy(hTileDriver,
osTempFileName.c_str(), hMemDS, FALSE,
papszTileDriverOptions, NULL, NULL);
GDALClose(hMemDS);
if (hOutDS)
GDALClose(hOutDS);
else
{
eErr = CE_Failure;
break;
}
/* -------------------------------------------------------------------- */
/* Insert new entry into raster table */
/* -------------------------------------------------------------------- */
vsi_l_offset nDataLength;
GByte *pabyData = VSIGetMemFileBuffer( osTempFileName.c_str(),
&nDataLength, FALSE);
OGRFeatureH hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hRasterLayer) );
OGR_F_SetFieldBinary(hFeat, 0, (int)nDataLength, pabyData);
OGR_L_CreateFeature(hRasterLayer, hFeat);
/* Query raster ID to set it as the ID of the associated metadata */
int nRasterID = (int)OGR_F_GetFID(hFeat);
OGR_F_Destroy(hFeat);
VSIUnlink(osTempFileName.c_str());
/* -------------------------------------------------------------------- */
/* Insert new entry into metadata table */
/* -------------------------------------------------------------------- */
hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hMetadataLayer) );
OGR_F_SetFID(hFeat, nRasterID);
OGR_F_SetFieldString(hFeat, 0, osSourceName);
OGR_F_SetFieldInteger(hFeat, 1, nTileId ++);
OGR_F_SetFieldInteger(hFeat, 2, nReqXSize);
OGR_F_SetFieldInteger(hFeat, 3, nReqYSize);
OGR_F_SetFieldDouble(hFeat, 4, dfXResolution);
OGR_F_SetFieldDouble(hFeat, 5, dfYResolution);
double minx, maxx, maxy, miny;
minx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff) * dfXResolution;
maxx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff + nReqXSize) * dfXResolution;
maxy = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff) * (-dfYResolution);
miny = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff + nReqYSize) * (-dfYResolution);
OGRGeometryH hRectangle = OGR_G_CreateGeometry(wkbPolygon);
OGRGeometryH hLinearRing = OGR_G_CreateGeometry(wkbLinearRing);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddGeometryDirectly(hRectangle, hLinearRing);
OGR_F_SetGeometryDirectly(hFeat, hRectangle);
OGR_L_CreateFeature(hMetadataLayer, hFeat);
OGR_F_Destroy(hFeat);
nBlocks++;
if (pfnProgress && !pfnProgress(1.0 * nBlocks / nTotalBlocks,
NULL, pProgressData))
eErr = CE_Failure;
}
}
nLimitOvrCount = -1;
if (eErr == CE_None)
OGR_DS_ExecuteSQL(hDS, "COMMIT", NULL, NULL);
else
OGR_DS_ExecuteSQL(hDS, "ROLLBACK", NULL, NULL);
VSIFree(pabyMEMDSBuffer);
/* -------------------------------------------------------------------- */
/* Update raster_pyramids table */
/* -------------------------------------------------------------------- */
if (eErr == CE_None)
{
OGRLayerH hRasterPyramidsLyr = OGR_DS_GetLayerByName(hDS, "raster_pyramids");
if (hRasterPyramidsLyr == NULL)
{
osSQL.Printf ("CREATE TABLE raster_pyramids ("
"table_prefix TEXT NOT NULL,"
"pixel_x_size DOUBLE NOT NULL,"
"pixel_y_size DOUBLE NOT NULL,"
"tile_count INTEGER NOT NULL)");
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
/* Re-open the DB to take into account the new tables*/
OGRReleaseDataSource(hDS);
CPLString osOldVal = CPLGetConfigOption("SQLITE_LIST_ALL_TABLES", "FALSE");
CPLSetThreadLocalConfigOption("SQLITE_LIST_ALL_TABLES", "TRUE");
hDS = OGROpen(osFileName.c_str(), TRUE, NULL);
CPLSetThreadLocalConfigOption("SQLITE_LIST_ALL_TABLES", osOldVal.c_str());
}
/* Insert base resolution into raster_pyramids if not already done */
int bHasBaseResolution = FALSE;
osSQL.Printf("SELECT * FROM raster_pyramids WHERE "
"table_prefix = '%s' AND pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f",
osTableName.c_str(),
padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15,
padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15);
hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
bHasBaseResolution = TRUE;
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
if (!bHasBaseResolution)
{
osSQL.Printf("SELECT COUNT(*) FROM \"%s\" WHERE "
"pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f",
osMetatadataLayer.c_str(),
padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15,
padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15);
int nBlocksMainRes = 0;
hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
nBlocksMainRes = OGR_F_GetFieldAsInteger(hFeat, 0);
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
osSQL.Printf("INSERT INTO raster_pyramids "
"( table_prefix, pixel_x_size, pixel_y_size, tile_count ) "
"VALUES ( '%s', %.18f, %.18f, %d )",
osTableName.c_str(), padfXResolutions[0], padfYResolutions[0],
nBlocksMainRes);
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
}
osSQL.Printf("INSERT INTO raster_pyramids "
"( table_prefix, pixel_x_size, pixel_y_size, tile_count ) "
"VALUES ( '%s', %.18f, %.18f, %d )",
osTableName.c_str(), dfXResolution, dfYResolution,
nTotalBlocks);
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
}
return eErr;
}
void GDALPamProxyDB::SaveDB()
{
/* -------------------------------------------------------------------- */
/* Open the database relating original names to proxy .aux.xml */
/* file names. */
/* -------------------------------------------------------------------- */
CPLString osDBName =
CPLFormFilename( osProxyDBDir, "gdal_pam_proxy", "dat" );
void *hLock = CPLLockFile( osDBName, 1.0 );
// proceed even if lock fails - we need CPLBreakLockFile()!
if( hLock == NULL )
{
CPLError( CE_Warning, CPLE_AppDefined,
"GDALPamProxyDB::SaveDB() - Failed to lock %s file, proceeding anyways.",
osDBName.c_str() );
}
FILE *fpDB = VSIFOpenL( osDBName, "w" );
if( fpDB == NULL )
{
if( hLock )
CPLUnlockFile( hLock );
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to save %s Pam Proxy DB.\n%s",
osDBName.c_str(),
VSIStrerror( errno ) );
return;
}
/* -------------------------------------------------------------------- */
/* Write header. */
/* -------------------------------------------------------------------- */
GByte abyHeader[100];
memset( abyHeader, ' ', sizeof(abyHeader) );
strncpy( (char *) abyHeader, "GDAL_PROXY", 10 );
sprintf( (char *) abyHeader + 10, "%9d", nUpdateCounter );
VSIFWriteL( abyHeader, 1, 100, fpDB );
/* -------------------------------------------------------------------- */
/* Write names. */
/* -------------------------------------------------------------------- */
unsigned int i;
for( i = 0; i < aosOriginalFiles.size(); i++ )
{
size_t nBytesWritten;
const char *pszProxyFile;
VSIFWriteL( aosOriginalFiles[i].c_str(), 1,
strlen(aosOriginalFiles[i].c_str())+1, fpDB );
pszProxyFile = CPLGetFilename(aosProxyFiles[i]);
nBytesWritten = VSIFWriteL( pszProxyFile, 1,
strlen(pszProxyFile)+1, fpDB );
if( nBytesWritten != strlen(pszProxyFile)+1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to write complete %s Pam Proxy DB.\n%s",
osDBName.c_str(),
VSIStrerror( errno ) );
VSIFCloseL( fpDB );
VSIUnlink( osDBName );
return;
}
}
VSIFCloseL( fpDB );
if( hLock )
CPLUnlockFile( hLock );
}
