/src/gdal/frmts/vrt/vrtdriver.cpp

Source (jump to first uncovered line)
/******************************************************************************
 *
 * Project:  Virtual GDAL Datasets
 * Purpose:  Implementation of VRTDriver
 * Author:   Frank Warmerdam <warmerdam@pobox.com>
 *
 ******************************************************************************
 * Copyright (c) 2003, Frank Warmerdam <warmerdam@pobox.com>
 * Copyright (c) 2009-2013, Even Rouault <even dot rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include "vrtdataset.h"

#include "cpl_minixml.h"
#include "cpl_string.h"
#include "gdal_alg_priv.h"
#include "gdal_frmts.h"

#include <mutex>

/*! @cond Doxygen_Suppress */

/************************************************************************/
/*                             VRTDriver()                              */
/************************************************************************/

VRTDriver::VRTDriver() : papszSourceParsers(nullptr)
{
#if 0
    pDeserializerData = GDALRegisterTransformDeserializer(
        "WarpedOverviewTransformer",
        VRTWarpedOverviewTransform,
        VRTDeserializeWarpedOverviewTransformer );
#endif
}

/************************************************************************/
/*                             ~VRTDriver()                             */
/************************************************************************/

VRTDriver::~VRTDriver()

{
    CSLDestroy(papszSourceParsers);
    VRTDerivedRasterBand::Cleanup();
#if 0
    if(  pDeserializerData )
    {
        GDALUnregisterTransformDeserializer( pDeserializerData );
    }
#endif
}

/************************************************************************/
/*                      GetMetadataDomainList()                         */
/************************************************************************/

char **VRTDriver::GetMetadataDomainList()
{
    return BuildMetadataDomainList(GDALDriver::GetMetadataDomainList(), TRUE,
                                   "SourceParsers", nullptr);
}

/************************************************************************/
/*                            GetMetadata()                             */
/************************************************************************/

char **VRTDriver::GetMetadata(const char *pszDomain)

{
    std::lock_guard oLock(m_oMutex);
    if (pszDomain && EQUAL(pszDomain, "SourceParsers"))
        return papszSourceParsers;

    return GDALDriver::GetMetadata(pszDomain);
}

/************************************************************************/
/*                            SetMetadata()                             */
/************************************************************************/

CPLErr VRTDriver::SetMetadata(char **papszMetadata, const char *pszDomain)

{
    std::lock_guard oLock(m_oMutex);
    if (pszDomain && EQUAL(pszDomain, "SourceParsers"))
    {
        m_oMapSourceParser.clear();
        CSLDestroy(papszSourceParsers);
        papszSourceParsers = CSLDuplicate(papszMetadata);
        return CE_None;
    }

    return GDALDriver::SetMetadata(papszMetadata, pszDomain);
}

/************************************************************************/
/*                          AddSourceParser()                           */
/************************************************************************/

void VRTDriver::AddSourceParser(const char *pszElementName,
                                VRTSourceParser pfnParser)

{
    m_oMapSourceParser[pszElementName] = pfnParser;

    // Below won't work on architectures with "capability pointers"

    char szPtrValue[128] = {'\0'};
    void *ptr;
    CPL_STATIC_ASSERT(sizeof(pfnParser) == sizeof(void *));
    memcpy(&ptr, &pfnParser, sizeof(void *));
    int nRet = CPLPrintPointer(szPtrValue, ptr, sizeof(szPtrValue));
    szPtrValue[nRet] = 0;

    papszSourceParsers =
        CSLSetNameValue(papszSourceParsers, pszElementName, szPtrValue);
}

/************************************************************************/
/*                            ParseSource()                             */
/************************************************************************/

VRTSource *VRTDriver::ParseSource(const CPLXMLNode *psSrc,
                                  const char *pszVRTPath,
                                  VRTMapSharedResources &oMapSharedSources)

{

    if (psSrc == nullptr || psSrc->eType != CXT_Element)
    {
        CPLError(CE_Failure, CPLE_AppDefined,
                 "Corrupt or empty VRT source XML document.");
        return nullptr;
    }

    if (!m_oMapSourceParser.empty())
    {
        auto oIter = m_oMapSourceParser.find(psSrc->pszValue);
        if (oIter != m_oMapSourceParser.end())
        {
            return oIter->second(psSrc, pszVRTPath, oMapSharedSources);
        }
        return nullptr;
    }

    // Below won't work on architectures with "capability pointers"

    const char *pszParserFunc =
        CSLFetchNameValue(papszSourceParsers, psSrc->pszValue);
    if (pszParserFunc == nullptr)
        return nullptr;

    VRTSourceParser pfnParser;
    CPL_STATIC_ASSERT(sizeof(pfnParser) == sizeof(void *));
    void *ptr =
        CPLScanPointer(pszParserFunc, static_cast<int>(strlen(pszParserFunc)));
    memcpy(&pfnParser, &ptr, sizeof(void *));

    if (pfnParser == nullptr)
        return nullptr;

    return pfnParser(psSrc, pszVRTPath, oMapSharedSources);
}

/************************************************************************/
/*                           VRTCreateCopy()                            */
/************************************************************************/

static GDALDataset *VRTCreateCopy(const char *pszFilename, GDALDataset *poSrcDS,
                                  int /* bStrict */, char **papszOptions,
                                  GDALProgressFunc /* pfnProgress */,
                                  void * /* pProgressData */)
{
    CPLAssert(nullptr != poSrcDS);

    VRTDataset *poSrcVRTDS = nullptr;

    void *pHandle = poSrcDS->GetInternalHandle("VRT_DATASET");
    if (pHandle && poSrcDS->GetInternalHandle(nullptr) == nullptr)
    {
        poSrcVRTDS = static_cast<VRTDataset *>(pHandle);
    }
    else
    {
        poSrcVRTDS = dynamic_cast<VRTDataset *>(poSrcDS);
    }

    /* -------------------------------------------------------------------- */
    /*      If the source dataset is a virtual dataset then just write      */
    /*      it to disk as a special case to avoid extra layers of           */
    /*      indirection.                                                    */
    /* -------------------------------------------------------------------- */
    if (poSrcVRTDS)
    {

        /* --------------------------------------------------------------------
         */
        /*      Convert tree to a single block of XML text. */
        /* --------------------------------------------------------------------
         */
        char *pszVRTPath = CPLStrdup(CPLGetPathSafe(pszFilename).c_str());
        poSrcVRTDS->UnsetPreservedRelativeFilenames();
        CPLXMLNode *psDSTree = poSrcVRTDS->SerializeToXML(pszVRTPath);

        char *pszXML = CPLSerializeXMLTree(psDSTree);

        CPLDestroyXMLNode(psDSTree);

        CPLFree(pszVRTPath);

        /* --------------------------------------------------------------------
         */
        /*      Write to disk. */
        /* --------------------------------------------------------------------
         */
        GDALDataset *pCopyDS = nullptr;

        if (0 != strlen(pszFilename))
        {
            VSILFILE *fpVRT = VSIFOpenL(pszFilename, "wb");
            if (fpVRT == nullptr)
            {
                CPLError(CE_Failure, CPLE_AppDefined, "Cannot create %s",
                         pszFilename);
                CPLFree(pszXML);
                return nullptr;
            }

            bool bRet = VSIFWriteL(pszXML, strlen(pszXML), 1, fpVRT) > 0;
            if (VSIFCloseL(fpVRT) != 0)
                bRet = false;

            if (bRet)
                pCopyDS = GDALDataset::Open(
                    pszFilename,
                    GDAL_OF_RASTER | GDAL_OF_MULTIDIM_RASTER | GDAL_OF_UPDATE);
        }
        else
        {
            /* No destination file is given, so pass serialized XML directly. */
            pCopyDS = GDALDataset::Open(pszXML, GDAL_OF_RASTER |
                                                    GDAL_OF_MULTIDIM_RASTER |
                                                    GDAL_OF_UPDATE);
        }

        CPLFree(pszXML);

        return pCopyDS;
    }

    /* -------------------------------------------------------------------- */
    /*      Multidimensional raster ?                                       */
    /* -------------------------------------------------------------------- */
    auto poSrcGroup = poSrcDS->GetRootGroup();
    if (poSrcGroup != nullptr)
    {
        auto poDstDS = std::unique_ptr<GDALDataset>(
            VRTDataset::CreateMultiDimensional(pszFilename, nullptr, nullptr));
        if (!poDstDS)
            return nullptr;
        auto poDstGroup = poDstDS->GetRootGroup();
        if (!poDstGroup)
            return nullptr;
        if (GDALDriver::DefaultCreateCopyMultiDimensional(
                poSrcDS, poDstDS.get(), false, nullptr, nullptr, nullptr) !=
            CE_None)
            return nullptr;
        return poDstDS.release();
    }

    /* -------------------------------------------------------------------- */
    /*      Create the virtual dataset.                                     */
    /* -------------------------------------------------------------------- */
    auto poVRTDS = VRTDataset::CreateVRTDataset(
        pszFilename, poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize(), 0,
        GDT_Byte, papszOptions);
    if (poVRTDS == nullptr)
        return nullptr;

    /* -------------------------------------------------------------------- */
    /*      Do we have a geotransform?                                      */
    /* -------------------------------------------------------------------- */
    double adfGeoTransform[6] = {0.0};

    if (poSrcDS->GetGeoTransform(adfGeoTransform) == CE_None)
    {
        poVRTDS->SetGeoTransform(adfGeoTransform);
    }

    /* -------------------------------------------------------------------- */
    /*      Copy projection                                                 */
    /* -------------------------------------------------------------------- */
    poVRTDS->SetSpatialRef(poSrcDS->GetSpatialRef());

    /* -------------------------------------------------------------------- */
    /*      Emit dataset level metadata.                                    */
    /* -------------------------------------------------------------------- */
    const char *pszCopySrcMDD =
        CSLFetchNameValueDef(papszOptions, "COPY_SRC_MDD", "AUTO");
    char **papszSrcMDD = CSLFetchNameValueMultiple(papszOptions, "SRC_MDD");
    if (EQUAL(pszCopySrcMDD, "AUTO") || CPLTestBool(pszCopySrcMDD) ||
        papszSrcMDD)
    {
        if (!papszSrcMDD || CSLFindString(papszSrcMDD, "") >= 0 ||
            CSLFindString(papszSrcMDD, "_DEFAULT_") >= 0)
        {
            poVRTDS->SetMetadata(poSrcDS->GetMetadata());
        }

        /* -------------------------------------------------------------------- */
        /*      Copy any special domains that should be transportable.          */
        /* -------------------------------------------------------------------- */
        constexpr const char *apszDefaultDomains[] = {"RPC", "IMD",
                                                      "GEOLOCATION"};
        for (const char *pszDomain : apszDefaultDomains)
        {
            if (!papszSrcMDD || CSLFindString(papszSrcMDD, pszDomain) >= 0)
            {
                char **papszMD = poSrcDS->GetMetadata(pszDomain);
                if (papszMD)
                    poVRTDS->SetMetadata(papszMD, pszDomain);
            }
        }

        if ((!EQUAL(pszCopySrcMDD, "AUTO") && CPLTestBool(pszCopySrcMDD)) ||
            papszSrcMDD)
        {
            char **papszDomainList = poSrcDS->GetMetadataDomainList();
            constexpr const char *apszReservedDomains[] = {
                "IMAGE_STRUCTURE", "DERIVED_SUBDATASETS"};
            for (char **papszIter = papszDomainList; papszIter && *papszIter;
                 ++papszIter)
            {
                const char *pszDomain = *papszIter;
                if (pszDomain[0] != 0 &&
                    (!papszSrcMDD ||
                     CSLFindString(papszSrcMDD, pszDomain) >= 0))
                {
                    bool bCanCopy = true;
                    for (const char *pszOtherDomain : apszDefaultDomains)
                    {
                        if (EQUAL(pszDomain, pszOtherDomain))
                        {
                            bCanCopy = false;
                            break;
                        }
                    }
                    if (!papszSrcMDD)
                    {
                        for (const char *pszOtherDomain : apszReservedDomains)
                        {
                            if (EQUAL(pszDomain, pszOtherDomain))
                            {
                                bCanCopy = false;
                                break;
                            }
                        }
                    }
                    if (bCanCopy)
                    {
                        poVRTDS->SetMetadata(poSrcDS->GetMetadata(pszDomain),
                                             pszDomain);
                    }
                }
            }
            CSLDestroy(papszDomainList);
        }
    }
    CSLDestroy(papszSrcMDD);

    {
        const char *pszInterleave =
            poSrcDS->GetMetadataItem("INTERLEAVE", "IMAGE_STRUCTURE");
        if (pszInterleave)
        {
            poVRTDS->SetMetadataItem("INTERLEAVE", pszInterleave,
                                     "IMAGE_STRUCTURE");
        }
    }
    {
        const char *pszCompression =
            poSrcDS->GetMetadataItem("COMPRESSION", "IMAGE_STRUCTURE");
        if (pszCompression)
        {
            poVRTDS->SetMetadataItem("COMPRESSION", pszCompression,
                                     "IMAGE_STRUCTURE");
        }
    }

    /* -------------------------------------------------------------------- */
    /*      GCPs                                                            */
    /* -------------------------------------------------------------------- */
    if (poSrcDS->GetGCPCount() > 0)
    {
        poVRTDS->SetGCPs(poSrcDS->GetGCPCount(), poSrcDS->GetGCPs(),
                         poSrcDS->GetGCPSpatialRef());
    }

    /* -------------------------------------------------------------------- */
    /*      Loop over all the bands.                                        */
    /* -------------------------------------------------------------------- */
    for (int iBand = 0; iBand < poSrcDS->GetRasterCount(); iBand++)
    {
        GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand(iBand + 1);

        /* --------------------------------------------------------------------
         */
        /*      Create the band with the appropriate band type. */
        /* --------------------------------------------------------------------
         */
        CPLStringList aosAddBandOptions;
        int nBlockXSize = poVRTDS->GetBlockXSize();
        int nBlockYSize = poVRTDS->GetBlockYSize();
        if (!poVRTDS->IsBlockSizeSpecified())
        {
            poSrcBand->GetBlockSize(&nBlockXSize, &nBlockYSize);
        }
        aosAddBandOptions.SetNameValue("BLOCKXSIZE",
                                       CPLSPrintf("%d", nBlockXSize));
        aosAddBandOptions.SetNameValue("BLOCKYSIZE",
                                       CPLSPrintf("%d", nBlockYSize));
        poVRTDS->AddBand(poSrcBand->GetRasterDataType(), aosAddBandOptions);

        VRTSourcedRasterBand *poVRTBand = static_cast<VRTSourcedRasterBand *>(
            poVRTDS->GetRasterBand(iBand + 1));

        /* --------------------------------------------------------------------
         */
        /*      Setup source mapping. */
        /* --------------------------------------------------------------------
         */
        poVRTBand->AddSimpleSource(poSrcBand);

        /* --------------------------------------------------------------------
         */
        /*      Emit various band level metadata. */
        /* --------------------------------------------------------------------
         */
        poVRTBand->CopyCommonInfoFrom(poSrcBand);

        const char *pszCompression =
            poSrcBand->GetMetadataItem("COMPRESSION", "IMAGE_STRUCTURE");
        if (pszCompression)
        {
            poVRTBand->SetMetadataItem("COMPRESSION", pszCompression,
                                       "IMAGE_STRUCTURE");
        }

        /* --------------------------------------------------------------------
         */
        /*      Add specific mask band. */
        /* --------------------------------------------------------------------
         */
        if ((poSrcBand->GetMaskFlags() &
             (GMF_PER_DATASET | GMF_ALL_VALID | GMF_NODATA)) == 0)
        {
            VRTSourcedRasterBand *poVRTMaskBand = new VRTSourcedRasterBand(
                poVRTDS.get(), 0, poSrcBand->GetMaskBand()->GetRasterDataType(),
                poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize());
            poVRTMaskBand->AddMaskBandSource(poSrcBand);
            poVRTBand->SetMaskBand(poVRTMaskBand);
        }
    }

    /* -------------------------------------------------------------------- */
    /*      Add dataset mask band                                           */
    /* -------------------------------------------------------------------- */
    if (poSrcDS->GetRasterCount() != 0 &&
        poSrcDS->GetRasterBand(1) != nullptr &&
        poSrcDS->GetRasterBand(1)->GetMaskFlags() == GMF_PER_DATASET)
    {
        GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand(1);
        VRTSourcedRasterBand *poVRTMaskBand = new VRTSourcedRasterBand(
            poVRTDS.get(), 0, poSrcBand->GetMaskBand()->GetRasterDataType(),
            poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize());
        poVRTMaskBand->AddMaskBandSource(poSrcBand);
        poVRTDS->SetMaskBand(poVRTMaskBand);
    }

    if (strcmp(pszFilename, "") != 0)
    {
        CPLErrorReset();
        poVRTDS->FlushCache(true);
        if (CPLGetLastErrorType() != CE_None)
        {
            poVRTDS.reset();
        }
    }

    return poVRTDS.release();
}

/************************************************************************/
/*                          GDALRegister_VRT()                          */
/************************************************************************/

void GDALRegister_VRT()

{
    if (GDALGetDriverByName("VRT") != nullptr)
        return;

    static std::once_flag flag;
    std::call_once(flag,
                   []()
                   {
                       // First register the pixel functions
                       GDALRegisterDefaultPixelFunc();

                       // Register functions for VRTProcessedDataset
                       GDALVRTRegisterDefaultProcessedDatasetFuncs();
                   });

    VRTDriver *poDriver = new VRTDriver();

    poDriver->SetDescription("VRT");
    poDriver->SetMetadataItem(GDAL_DCAP_RASTER, "YES");
    poDriver->SetMetadataItem(GDAL_DCAP_MULTIDIM_RASTER, "YES");
    poDriver->SetMetadataItem(GDAL_DMD_LONGNAME, "Virtual Raster");
    poDriver->SetMetadataItem(GDAL_DMD_EXTENSION, "vrt");
    poDriver->SetMetadataItem(GDAL_DMD_HELPTOPIC, "drivers/raster/vrt.html");
    poDriver->SetMetadataItem(
        GDAL_DMD_CREATIONDATATYPES,
        "Byte Int8 Int16 UInt16 Int32 UInt32 Int64 UInt64 "
        "Float16 Float32 Float64 "
        "CInt16 CInt32 CFloat16 CFloat32 CFloat64");
    poDriver->SetMetadataItem(
        GDAL_DMD_CREATIONOPTIONLIST,
        "<CreationOptionList>\n"
        "   <Option name='SUBCLASS' type='string-select' "
        "default='VRTDataset'>\n"
        "       <Value>VRTDataset</Value>\n"
        "       <Value>VRTWarpedDataset</Value>\n"
        "   </Option>\n"
        "   <Option name='BLOCKXSIZE' type='int' description='Block width'/>\n"
        "   <Option name='BLOCKYSIZE' type='int' description='Block height'/>\n"
        "</CreationOptionList>\n");

    poDriver->pfnCreateCopy = VRTCreateCopy;
    poDriver->pfnCreate = VRTDataset::Create;
    poDriver->pfnCreateMultiDimensional = VRTDataset::CreateMultiDimensional;

#ifndef NO_OPEN
    poDriver->pfnOpen = VRTDataset::Open;
    poDriver->pfnIdentify = VRTDataset::Identify;
    poDriver->pfnDelete = VRTDataset::Delete;

    poDriver->SetMetadataItem(
        GDAL_DMD_OPENOPTIONLIST,
        "<OpenOptionList>"
        "  <Option name='ROOT_PATH' type='string' description='Root path to "
        "evaluate "
        "relative paths inside the VRT. Mainly useful for inlined VRT, or "
        "in-memory "
        "VRT, where their own directory does not make sense'/>"
        "<Option name='NUM_THREADS' type='string' description="
        "'Number of worker threads for reading. Can be set to ALL_CPUS' "
        "default='ALL_CPUS'/>"
        "</OpenOptionList>");
#endif

    poDriver->SetMetadataItem(GDAL_DCAP_VIRTUALIO, "YES");
    poDriver->SetMetadataItem(GDAL_DCAP_COORDINATE_EPOCH, "YES");

    poDriver->SetMetadataItem(GDAL_DCAP_UPDATE, "YES");
    poDriver->SetMetadataItem(GDAL_DMD_UPDATE_ITEMS,
                              "GeoTransform SRS GCPs NoData "
                              "ColorInterpretation "
                              "DatasetMetadata BandMetadata");

    const char *pszExpressionDialects = "ExpressionDialects";
#if defined(GDAL_VRT_ENABLE_MUPARSER) && defined(GDAL_VRT_ENABLE_EXPRTK)
    poDriver->SetMetadataItem(pszExpressionDialects, "muparser,exprtk");
#elif defined(GDAL_VRT_ENABLE_MUPARSER)
    poDriver->SetMetadataItem(pszExpressionDialects, "muparser");
#elif defined(GDAL_VRT_ENABLE_EXPRTK)
    poDriver->SetMetadataItem(pszExpressionDialects, "exprtk");
#else
    poDriver->SetMetadataItem(pszExpressionDialects, "none");
#endif

    poDriver->AddSourceParser("SimpleSource", VRTParseCoreSources);
    poDriver->AddSourceParser("ComplexSource", VRTParseCoreSources);
    poDriver->AddSourceParser("AveragedSource", VRTParseCoreSources);
    poDriver->AddSourceParser("NoDataFromMaskSource", VRTParseCoreSources);
    poDriver->AddSourceParser("KernelFilteredSource", VRTParseFilterSources);
    poDriver->AddSourceParser("ArraySource", VRTParseArraySource);

    GetGDALDriverManager()->RegisterDriver(poDriver);
}

/*! @endcond */

Coverage Report

Created: 2025-06-22 06:59

Line	Count	Source (jump to first uncovered line)
1		/******************************************************************************
2		*
3		* Project: Virtual GDAL Datasets
4		* Purpose: Implementation of VRTDriver
5		* Author: Frank Warmerdam <warmerdam@pobox.com>
6		*
7		******************************************************************************
8		* Copyright (c) 2003, Frank Warmerdam <warmerdam@pobox.com>
9		* Copyright (c) 2009-2013, Even Rouault <even dot rouault at spatialys.com>
10		*
11		* SPDX-License-Identifier: MIT
12		****************************************************************************/
13
14		#include "vrtdataset.h"
15
16		#include "cpl_minixml.h"
17		#include "cpl_string.h"
18		#include "gdal_alg_priv.h"
19		#include "gdal_frmts.h"
20
21		#include <mutex>
22
23		/! @cond Doxygen_Suppress /
24
25		/************************************************************************/
26		/* VRTDriver() */
27		/************************************************************************/
28
29	0	VRTDriver::VRTDriver() : papszSourceParsers(nullptr)
30	0	{
31		#if 0
32		pDeserializerData = GDALRegisterTransformDeserializer(
33		"WarpedOverviewTransformer",
34		VRTWarpedOverviewTransform,
35		VRTDeserializeWarpedOverviewTransformer );
36		#endif
37	0	}
38
39		/************************************************************************/
40		/* ~VRTDriver() */
41		/************************************************************************/
42
43		VRTDriver::~VRTDriver()
44
45	0	{
46	0	CSLDestroy(papszSourceParsers);
47	0	VRTDerivedRasterBand::Cleanup();
48		#if 0
49		if( pDeserializerData )
50		{
51		GDALUnregisterTransformDeserializer( pDeserializerData );
52		}
53		#endif
54	0	}
55
56		/************************************************************************/
57		/* GetMetadataDomainList() */
58		/************************************************************************/
59
60		char **VRTDriver::GetMetadataDomainList()
61	0	{
62	0	return BuildMetadataDomainList(GDALDriver::GetMetadataDomainList(), TRUE,
63	0	"SourceParsers", nullptr);
64	0	}
65
66		/************************************************************************/
67		/* GetMetadata() */
68		/************************************************************************/
69
70		char *VRTDriver::GetMetadata(const char pszDomain)
71
72	0	{
73	0	std::lock_guard oLock(m_oMutex);
74	0	if (pszDomain && EQUAL(pszDomain, "SourceParsers"))
75	0	return papszSourceParsers;
76
77	0	return GDALDriver::GetMetadata(pszDomain);
78	0	}
79
80		/************************************************************************/
81		/* SetMetadata() */
82		/************************************************************************/
83
84		CPLErr VRTDriver::SetMetadata(char *papszMetadata, const char pszDomain)
85
86	0	{
87	0	std::lock_guard oLock(m_oMutex);
88	0	if (pszDomain && EQUAL(pszDomain, "SourceParsers"))
89	0	{
90	0	m_oMapSourceParser.clear();
91	0	CSLDestroy(papszSourceParsers);
92	0	papszSourceParsers = CSLDuplicate(papszMetadata);
93	0	return CE_None;
94	0	}
95
96	0	return GDALDriver::SetMetadata(papszMetadata, pszDomain);
97	0	}
98
99		/************************************************************************/
100		/* AddSourceParser() */
101		/************************************************************************/
102
103		void VRTDriver::AddSourceParser(const char *pszElementName,
104		VRTSourceParser pfnParser)
105
106	0	{
107	0	m_oMapSourceParser[pszElementName] = pfnParser;
108
109		// Below won't work on architectures with "capability pointers"
110
111	0	char szPtrValue[128] = {'\0'};
112	0	void *ptr;
113	0	CPL_STATIC_ASSERT(sizeof(pfnParser) == sizeof(void *));
114	0	memcpy(&ptr, &pfnParser, sizeof(void *));
115	0	int nRet = CPLPrintPointer(szPtrValue, ptr, sizeof(szPtrValue));
116	0	szPtrValue[nRet] = 0;
117
118	0	papszSourceParsers =
119	0	CSLSetNameValue(papszSourceParsers, pszElementName, szPtrValue);
120	0	}
121
122		/************************************************************************/
123		/* ParseSource() */
124		/************************************************************************/
125
126		VRTSource VRTDriver::ParseSource(const CPLXMLNode psSrc,
127		const char *pszVRTPath,
128		VRTMapSharedResources &oMapSharedSources)
129
130	0	{
131
132	0	if (psSrc == nullptr \|\| psSrc->eType != CXT_Element)
133	0	{
134	0	CPLError(CE_Failure, CPLE_AppDefined,
135	0	"Corrupt or empty VRT source XML document.");
136	0	return nullptr;
137	0	}
138
139	0	if (!m_oMapSourceParser.empty())
140	0	{
141	0	auto oIter = m_oMapSourceParser.find(psSrc->pszValue);
142	0	if (oIter != m_oMapSourceParser.end())
143	0	{
144	0	return oIter->second(psSrc, pszVRTPath, oMapSharedSources);
145	0	}
146	0	return nullptr;
147	0	}
148
149		// Below won't work on architectures with "capability pointers"
150
151	0	const char *pszParserFunc =
152	0	CSLFetchNameValue(papszSourceParsers, psSrc->pszValue);
153	0	if (pszParserFunc == nullptr)
154	0	return nullptr;
155
156	0	VRTSourceParser pfnParser;
157	0	CPL_STATIC_ASSERT(sizeof(pfnParser) == sizeof(void *));
158	0	void *ptr =
159	0	CPLScanPointer(pszParserFunc, static_cast<int>(strlen(pszParserFunc)));
160	0	memcpy(&pfnParser, &ptr, sizeof(void *));
161
162	0	if (pfnParser == nullptr)
163	0	return nullptr;
164
165	0	return pfnParser(psSrc, pszVRTPath, oMapSharedSources);
166	0	}
167
168		/************************************************************************/
169		/* VRTCreateCopy() */
170		/************************************************************************/
171
172		static GDALDataset VRTCreateCopy(const char pszFilename, GDALDataset *poSrcDS,
173		int /* bStrict /, char *papszOptions,
174		GDALProgressFunc /* pfnProgress */,
175		void * /* pProgressData */)
176	0	{
177	0	CPLAssert(nullptr != poSrcDS);
178
179	0	VRTDataset *poSrcVRTDS = nullptr;
180
181	0	void *pHandle = poSrcDS->GetInternalHandle("VRT_DATASET");
182	0	if (pHandle && poSrcDS->GetInternalHandle(nullptr) == nullptr)
183	0	{
184	0	poSrcVRTDS = static_cast<VRTDataset *>(pHandle);
185	0	}
186	0	else
187	0	{
188	0	poSrcVRTDS = dynamic_cast<VRTDataset *>(poSrcDS);
189	0	}
190
191		/* -------------------------------------------------------------------- */
192		/* If the source dataset is a virtual dataset then just write */
193		/* it to disk as a special case to avoid extra layers of */
194		/* indirection. */
195		/* -------------------------------------------------------------------- */
196	0	if (poSrcVRTDS)
197	0	{
198
199		/* --------------------------------------------------------------------
200		*/
201		/* Convert tree to a single block of XML text. */
202		/* --------------------------------------------------------------------
203		*/
204	0	char *pszVRTPath = CPLStrdup(CPLGetPathSafe(pszFilename).c_str());
205	0	poSrcVRTDS->UnsetPreservedRelativeFilenames();
206	0	CPLXMLNode *psDSTree = poSrcVRTDS->SerializeToXML(pszVRTPath);
207
208	0	char *pszXML = CPLSerializeXMLTree(psDSTree);
209
210	0	CPLDestroyXMLNode(psDSTree);
211
212	0	CPLFree(pszVRTPath);
213
214		/* --------------------------------------------------------------------
215		*/
216		/* Write to disk. */
217		/* --------------------------------------------------------------------
218		*/
219	0	GDALDataset *pCopyDS = nullptr;
220
221	0	if (0 != strlen(pszFilename))
222	0	{
223	0	VSILFILE *fpVRT = VSIFOpenL(pszFilename, "wb");
224	0	if (fpVRT == nullptr)
225	0	{
226	0	CPLError(CE_Failure, CPLE_AppDefined, "Cannot create %s",
227	0	pszFilename);
228	0	CPLFree(pszXML);
229	0	return nullptr;
230	0	}
231
232	0	bool bRet = VSIFWriteL(pszXML, strlen(pszXML), 1, fpVRT) > 0;
233	0	if (VSIFCloseL(fpVRT) != 0)
234	0	bRet = false;
235
236	0	if (bRet)
237	0	pCopyDS = GDALDataset::Open(
238	0	pszFilename,
239	0	GDAL_OF_RASTER \| GDAL_OF_MULTIDIM_RASTER \| GDAL_OF_UPDATE);
240	0	}
241	0	else
242	0	{
243		/* No destination file is given, so pass serialized XML directly. */
244	0	pCopyDS = GDALDataset::Open(pszXML, GDAL_OF_RASTER \|
245	0	GDAL_OF_MULTIDIM_RASTER \|
246	0	GDAL_OF_UPDATE);
247	0	}
248
249	0	CPLFree(pszXML);
250
251	0	return pCopyDS;
252	0	}
253
254		/* -------------------------------------------------------------------- */
255		/* Multidimensional raster ? */
256		/* -------------------------------------------------------------------- */
257	0	auto poSrcGroup = poSrcDS->GetRootGroup();
258	0	if (poSrcGroup != nullptr)
259	0	{
260	0	auto poDstDS = std::unique_ptr<GDALDataset>(
261	0	VRTDataset::CreateMultiDimensional(pszFilename, nullptr, nullptr));
262	0	if (!poDstDS)
263	0	return nullptr;
264	0	auto poDstGroup = poDstDS->GetRootGroup();
265	0	if (!poDstGroup)
266	0	return nullptr;
267	0	if (GDALDriver::DefaultCreateCopyMultiDimensional(
268	0	poSrcDS, poDstDS.get(), false, nullptr, nullptr, nullptr) !=
269	0	CE_None)
270	0	return nullptr;
271	0	return poDstDS.release();
272	0	}
273
274		/* -------------------------------------------------------------------- */
275		/* Create the virtual dataset. */
276		/* -------------------------------------------------------------------- */
277	0	auto poVRTDS = VRTDataset::CreateVRTDataset(
278	0	pszFilename, poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize(), 0,
279	0	GDT_Byte, papszOptions);
280	0	if (poVRTDS == nullptr)
281	0	return nullptr;
282
283		/* -------------------------------------------------------------------- */
284		/* Do we have a geotransform? */
285		/* -------------------------------------------------------------------- */
286	0	double adfGeoTransform[6] = {0.0};
287
288	0	if (poSrcDS->GetGeoTransform(adfGeoTransform) == CE_None)
289	0	{
290	0	poVRTDS->SetGeoTransform(adfGeoTransform);
291	0	}
292
293		/* -------------------------------------------------------------------- */
294		/* Copy projection */
295		/* -------------------------------------------------------------------- */
296	0	poVRTDS->SetSpatialRef(poSrcDS->GetSpatialRef());
297
298		/* -------------------------------------------------------------------- */
299		/* Emit dataset level metadata. */
300		/* -------------------------------------------------------------------- */
301	0	const char *pszCopySrcMDD =
302	0	CSLFetchNameValueDef(papszOptions, "COPY_SRC_MDD", "AUTO");
303	0	char **papszSrcMDD = CSLFetchNameValueMultiple(papszOptions, "SRC_MDD");
304	0	if (EQUAL(pszCopySrcMDD, "AUTO") \|\| CPLTestBool(pszCopySrcMDD) \|\|
305	0	papszSrcMDD)
306	0	{
307	0	if (!papszSrcMDD \|\| CSLFindString(papszSrcMDD, "") >= 0 \|\|
308	0	CSLFindString(papszSrcMDD, "_DEFAULT_") >= 0)
309	0	{
310	0	poVRTDS->SetMetadata(poSrcDS->GetMetadata());
311	0	}
312
313		/* -------------------------------------------------------------------- */
314		/* Copy any special domains that should be transportable. */
315		/* -------------------------------------------------------------------- */
316	0	constexpr const char *apszDefaultDomains[] = {"RPC", "IMD",
317	0	"GEOLOCATION"};
318	0	for (const char *pszDomain : apszDefaultDomains)
319	0	{
320	0	if (!papszSrcMDD \|\| CSLFindString(papszSrcMDD, pszDomain) >= 0)
321	0	{
322	0	char **papszMD = poSrcDS->GetMetadata(pszDomain);
323	0	if (papszMD)
324	0	poVRTDS->SetMetadata(papszMD, pszDomain);
325	0	}
326	0	}
327
328	0	if ((!EQUAL(pszCopySrcMDD, "AUTO") && CPLTestBool(pszCopySrcMDD)) \|\|
329	0	papszSrcMDD)
330	0	{
331	0	char **papszDomainList = poSrcDS->GetMetadataDomainList();
332	0	constexpr const char *apszReservedDomains[] = {
333	0	"IMAGE_STRUCTURE", "DERIVED_SUBDATASETS"};
334	0	for (char *papszIter = papszDomainList; papszIter && papszIter;
335	0	++papszIter)
336	0	{
337	0	const char pszDomain = papszIter;
338	0	if (pszDomain[0] != 0 &&
339	0	(!papszSrcMDD \|\|
340	0	CSLFindString(papszSrcMDD, pszDomain) >= 0))
341	0	{
342	0	bool bCanCopy = true;
343	0	for (const char *pszOtherDomain : apszDefaultDomains)
344	0	{
345	0	if (EQUAL(pszDomain, pszOtherDomain))
346	0	{
347	0	bCanCopy = false;
348	0	break;
349	0	}
350	0	}
351	0	if (!papszSrcMDD)
352	0	{
353	0	for (const char *pszOtherDomain : apszReservedDomains)
354	0	{
355	0	if (EQUAL(pszDomain, pszOtherDomain))
356	0	{
357	0	bCanCopy = false;
358	0	break;
359	0	}
360	0	}
361	0	}
362	0	if (bCanCopy)
363	0	{
364	0	poVRTDS->SetMetadata(poSrcDS->GetMetadata(pszDomain),
365	0	pszDomain);
366	0	}
367	0	}
368	0	}
369	0	CSLDestroy(papszDomainList);
370	0	}
371	0	}
372	0	CSLDestroy(papszSrcMDD);
373
374	0	{
375	0	const char *pszInterleave =
376	0	poSrcDS->GetMetadataItem("INTERLEAVE", "IMAGE_STRUCTURE");
377	0	if (pszInterleave)
378	0	{
379	0	poVRTDS->SetMetadataItem("INTERLEAVE", pszInterleave,
380	0	"IMAGE_STRUCTURE");
381	0	}
382	0	}
383	0	{
384	0	const char *pszCompression =
385	0	poSrcDS->GetMetadataItem("COMPRESSION", "IMAGE_STRUCTURE");
386	0	if (pszCompression)
387	0	{
388	0	poVRTDS->SetMetadataItem("COMPRESSION", pszCompression,
389	0	"IMAGE_STRUCTURE");
390	0	}
391	0	}
392
393		/* -------------------------------------------------------------------- */
394		/* GCPs */
395		/* -------------------------------------------------------------------- */
396	0	if (poSrcDS->GetGCPCount() > 0)
397	0	{
398	0	poVRTDS->SetGCPs(poSrcDS->GetGCPCount(), poSrcDS->GetGCPs(),
399	0	poSrcDS->GetGCPSpatialRef());
400	0	}
401
402		/* -------------------------------------------------------------------- */
403		/* Loop over all the bands. */
404		/* -------------------------------------------------------------------- */
405	0	for (int iBand = 0; iBand < poSrcDS->GetRasterCount(); iBand++)
406	0	{
407	0	GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand(iBand + 1);
408
409		/* --------------------------------------------------------------------
410		*/
411		/* Create the band with the appropriate band type. */
412		/* --------------------------------------------------------------------
413		*/
414	0	CPLStringList aosAddBandOptions;
415	0	int nBlockXSize = poVRTDS->GetBlockXSize();
416	0	int nBlockYSize = poVRTDS->GetBlockYSize();
417	0	if (!poVRTDS->IsBlockSizeSpecified())
418	0	{
419	0	poSrcBand->GetBlockSize(&nBlockXSize, &nBlockYSize);
420	0	}
421	0	aosAddBandOptions.SetNameValue("BLOCKXSIZE",
422	0	CPLSPrintf("%d", nBlockXSize));
423	0	aosAddBandOptions.SetNameValue("BLOCKYSIZE",
424	0	CPLSPrintf("%d", nBlockYSize));
425	0	poVRTDS->AddBand(poSrcBand->GetRasterDataType(), aosAddBandOptions);
426
427	0	VRTSourcedRasterBand poVRTBand = static_cast<VRTSourcedRasterBand >(
428	0	poVRTDS->GetRasterBand(iBand + 1));
429
430		/* --------------------------------------------------------------------
431		*/
432		/* Setup source mapping. */
433		/* --------------------------------------------------------------------
434		*/
435	0	poVRTBand->AddSimpleSource(poSrcBand);
436
437		/* --------------------------------------------------------------------
438		*/
439		/* Emit various band level metadata. */
440		/* --------------------------------------------------------------------
441		*/
442	0	poVRTBand->CopyCommonInfoFrom(poSrcBand);
443
444	0	const char *pszCompression =
445	0	poSrcBand->GetMetadataItem("COMPRESSION", "IMAGE_STRUCTURE");
446	0	if (pszCompression)
447	0	{
448	0	poVRTBand->SetMetadataItem("COMPRESSION", pszCompression,
449	0	"IMAGE_STRUCTURE");
450	0	}
451
452		/* --------------------------------------------------------------------
453		*/
454		/* Add specific mask band. */
455		/* --------------------------------------------------------------------
456		*/
457	0	if ((poSrcBand->GetMaskFlags() &
458	0	(GMF_PER_DATASET \| GMF_ALL_VALID \| GMF_NODATA)) == 0)
459	0	{
460	0	VRTSourcedRasterBand *poVRTMaskBand = new VRTSourcedRasterBand(
461	0	poVRTDS.get(), 0, poSrcBand->GetMaskBand()->GetRasterDataType(),
462	0	poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize());
463	0	poVRTMaskBand->AddMaskBandSource(poSrcBand);
464	0	poVRTBand->SetMaskBand(poVRTMaskBand);
465	0	}
466	0	}
467
468		/* -------------------------------------------------------------------- */
469		/* Add dataset mask band */
470		/* -------------------------------------------------------------------- */
471	0	if (poSrcDS->GetRasterCount() != 0 &&
472	0	poSrcDS->GetRasterBand(1) != nullptr &&
473	0	poSrcDS->GetRasterBand(1)->GetMaskFlags() == GMF_PER_DATASET)
474	0	{
475	0	GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand(1);
476	0	VRTSourcedRasterBand *poVRTMaskBand = new VRTSourcedRasterBand(
477	0	poVRTDS.get(), 0, poSrcBand->GetMaskBand()->GetRasterDataType(),
478	0	poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize());
479	0	poVRTMaskBand->AddMaskBandSource(poSrcBand);
480	0	poVRTDS->SetMaskBand(poVRTMaskBand);
481	0	}
482
483	0	if (strcmp(pszFilename, "") != 0)
484	0	{
485	0	CPLErrorReset();
486	0	poVRTDS->FlushCache(true);
487	0	if (CPLGetLastErrorType() != CE_None)
488	0	{
489	0	poVRTDS.reset();
490	0	}
491	0	}
492
493	0	return poVRTDS.release();
494	0	}
495
496		/************************************************************************/
497		/* GDALRegister_VRT() */
498		/************************************************************************/
499
500		void GDALRegister_VRT()
501
502	0	{
503	0	if (GDALGetDriverByName("VRT") != nullptr)
504	0	return;
505
506	0	static std::once_flag flag;
507	0	std::call_once(flag,
508	0	[]()
509	0	{
510		// First register the pixel functions
511	0	GDALRegisterDefaultPixelFunc();
512
513		// Register functions for VRTProcessedDataset
514	0	GDALVRTRegisterDefaultProcessedDatasetFuncs();
515	0	});
516
517	0	VRTDriver *poDriver = new VRTDriver();
518
519	0	poDriver->SetDescription("VRT");
520	0	poDriver->SetMetadataItem(GDAL_DCAP_RASTER, "YES");
521	0	poDriver->SetMetadataItem(GDAL_DCAP_MULTIDIM_RASTER, "YES");
522	0	poDriver->SetMetadataItem(GDAL_DMD_LONGNAME, "Virtual Raster");
523	0	poDriver->SetMetadataItem(GDAL_DMD_EXTENSION, "vrt");
524	0	poDriver->SetMetadataItem(GDAL_DMD_HELPTOPIC, "drivers/raster/vrt.html");
525	0	poDriver->SetMetadataItem(
526	0	GDAL_DMD_CREATIONDATATYPES,
527	0	"Byte Int8 Int16 UInt16 Int32 UInt32 Int64 UInt64 "
528	0	"Float16 Float32 Float64 "
529	0	"CInt16 CInt32 CFloat16 CFloat32 CFloat64");
530	0	poDriver->SetMetadataItem(
531	0	GDAL_DMD_CREATIONOPTIONLIST,
532	0	"<CreationOptionList>\n"
533	0	" <Option name='SUBCLASS' type='string-select' "
534	0	"default='VRTDataset'>\n"
535	0	" <Value>VRTDataset</Value>\n"
536	0	" <Value>VRTWarpedDataset</Value>\n"
537	0	" </Option>\n"
538	0	" <Option name='BLOCKXSIZE' type='int' description='Block width'/>\n"
539	0	" <Option name='BLOCKYSIZE' type='int' description='Block height'/>\n"
540	0	"</CreationOptionList>\n");
541
542	0	poDriver->pfnCreateCopy = VRTCreateCopy;
543	0	poDriver->pfnCreate = VRTDataset::Create;
544	0	poDriver->pfnCreateMultiDimensional = VRTDataset::CreateMultiDimensional;
545
546	0	#ifndef NO_OPEN
547	0	poDriver->pfnOpen = VRTDataset::Open;
548	0	poDriver->pfnIdentify = VRTDataset::Identify;
549	0	poDriver->pfnDelete = VRTDataset::Delete;
550
551	0	poDriver->SetMetadataItem(
552	0	GDAL_DMD_OPENOPTIONLIST,
553	0	"<OpenOptionList>"
554	0	" <Option name='ROOT_PATH' type='string' description='Root path to "
555	0	"evaluate "
556	0	"relative paths inside the VRT. Mainly useful for inlined VRT, or "
557	0	"in-memory "
558	0	"VRT, where their own directory does not make sense'/>"
559	0	"<Option name='NUM_THREADS' type='string' description="
560	0	"'Number of worker threads for reading. Can be set to ALL_CPUS' "
561	0	"default='ALL_CPUS'/>"
562	0	"</OpenOptionList>");
563	0	#endif
564
565	0	poDriver->SetMetadataItem(GDAL_DCAP_VIRTUALIO, "YES");
566	0	poDriver->SetMetadataItem(GDAL_DCAP_COORDINATE_EPOCH, "YES");
567
568	0	poDriver->SetMetadataItem(GDAL_DCAP_UPDATE, "YES");
569	0	poDriver->SetMetadataItem(GDAL_DMD_UPDATE_ITEMS,
570	0	"GeoTransform SRS GCPs NoData "
571	0	"ColorInterpretation "
572	0	"DatasetMetadata BandMetadata");
573
574	0	const char *pszExpressionDialects = "ExpressionDialects";
575		#if defined(GDAL_VRT_ENABLE_MUPARSER) && defined(GDAL_VRT_ENABLE_EXPRTK)
576		poDriver->SetMetadataItem(pszExpressionDialects, "muparser,exprtk");
577		#elif defined(GDAL_VRT_ENABLE_MUPARSER)
578		poDriver->SetMetadataItem(pszExpressionDialects, "muparser");
579		#elif defined(GDAL_VRT_ENABLE_EXPRTK)
580		poDriver->SetMetadataItem(pszExpressionDialects, "exprtk");
581		#else
582	0	poDriver->SetMetadataItem(pszExpressionDialects, "none");
583	0	#endif
584
585	0	poDriver->AddSourceParser("SimpleSource", VRTParseCoreSources);
586	0	poDriver->AddSourceParser("ComplexSource", VRTParseCoreSources);
587	0	poDriver->AddSourceParser("AveragedSource", VRTParseCoreSources);
588	0	poDriver->AddSourceParser("NoDataFromMaskSource", VRTParseCoreSources);
589	0	poDriver->AddSourceParser("KernelFilteredSource", VRTParseFilterSources);
590	0	poDriver->AddSourceParser("ArraySource", VRTParseArraySource);
591
592	0	GetGDALDriverManager()->RegisterDriver(poDriver);
593	0	}
594
595		/! @endcond /