/src/gdal/gcore/gdalnodatamaskband.cpp

Source
/******************************************************************************
 *
 * Project:  GDAL Core
 * Purpose:  Implementation of GDALNoDataMaskBand, a class implementing all
 *           a default band mask based on nodata values.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 2007, Frank Warmerdam
 * Copyright (c) 2008-2012, Even Rouault <even dot rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#include "cpl_port.h"
#include "gdal_priv.h"

#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring>
#include <utility>

#include "cpl_conv.h"
#include "cpl_error.h"
#include "cpl_vsi.h"
#include "gdal.h"
#include "gdal_priv_templates.hpp"

//! @cond Doxygen_Suppress
/************************************************************************/
/*                         GDALNoDataMaskBand()                         */
/************************************************************************/

GDALNoDataMaskBand::GDALNoDataMaskBand(GDALRasterBand *poParentIn)
    : m_poParent(poParentIn)
{
    poDS = nullptr;
    nBand = 0;

    nRasterXSize = m_poParent->GetXSize();
    nRasterYSize = m_poParent->GetYSize();

    eDataType = GDT_UInt8;
    m_poParent->GetBlockSize(&nBlockXSize, &nBlockYSize);

    const auto eParentDT = m_poParent->GetRasterDataType();
    if (eParentDT == GDT_Int64)
        m_nNoDataValueInt64 = m_poParent->GetNoDataValueAsInt64();
    else if (eParentDT == GDT_UInt64)
        m_nNoDataValueUInt64 = m_poParent->GetNoDataValueAsUInt64();
    else
        m_dfNoDataValue = m_poParent->GetNoDataValue();
}

/************************************************************************/
/*                         GDALNoDataMaskBand()                         */
/************************************************************************/

GDALNoDataMaskBand::GDALNoDataMaskBand(GDALRasterBand *poParentIn,
                                       double dfNoDataValue)
    : m_poParent(poParentIn)
{
    poDS = nullptr;
    nBand = 0;

    nRasterXSize = m_poParent->GetXSize();
    nRasterYSize = m_poParent->GetYSize();

    eDataType = GDT_UInt8;
    m_poParent->GetBlockSize(&nBlockXSize, &nBlockYSize);

    const auto eParentDT = m_poParent->GetRasterDataType();
    if (eParentDT == GDT_Int64)
        m_nNoDataValueInt64 = static_cast<int64_t>(dfNoDataValue);
    else if (eParentDT == GDT_UInt64)
        m_nNoDataValueUInt64 = static_cast<uint64_t>(dfNoDataValue);
    else
        m_dfNoDataValue = dfNoDataValue;
}

/************************************************************************/
/*                        ~GDALNoDataMaskBand()                         */
/************************************************************************/

GDALNoDataMaskBand::~GDALNoDataMaskBand() = default;

/************************************************************************/
/*                          GetWorkDataType()                           */
/************************************************************************/

static GDALDataType GetWorkDataType(GDALDataType eDataType)
{
    GDALDataType eWrkDT = GDT_Unknown;
    switch (eDataType)
    {
        case GDT_UInt8:
            eWrkDT = GDT_UInt8;
            break;

        case GDT_Int16:
            eWrkDT = GDT_Int16;
            break;

        case GDT_UInt16:
            eWrkDT = GDT_UInt16;
            break;

        case GDT_UInt32:
            eWrkDT = GDT_UInt32;
            break;

        case GDT_Int8:
        case GDT_Int32:
        case GDT_CInt16:
        case GDT_CInt32:
            eWrkDT = GDT_Int32;
            break;

        case GDT_Float16:
        case GDT_CFloat16:
        case GDT_Float32:
        case GDT_CFloat32:
            eWrkDT = GDT_Float32;
            break;

        case GDT_Float64:
        case GDT_CFloat64:
            eWrkDT = GDT_Float64;
            break;

        case GDT_Int64:
        case GDT_UInt64:
            eWrkDT = eDataType;
            break;

        case GDT_Unknown:
        case GDT_TypeCount:
            CPLAssert(false);
            eWrkDT = GDT_Float64;
            break;
    }
    return eWrkDT;
}

/************************************************************************/
/*                          IsNoDataInRange()                           */
/************************************************************************/

bool GDALNoDataMaskBand::IsNoDataInRange(double dfNoDataValue,
                                         GDALDataType eDataTypeIn)
{
    GDALDataType eWrkDT = GetWorkDataType(eDataTypeIn);
    switch (eWrkDT)
    {
        case GDT_UInt8:
        {
            return GDALIsValueInRange<GByte>(dfNoDataValue);
        }

        case GDT_Int8:
        {
            return GDALIsValueInRange<signed char>(dfNoDataValue);
        }

        case GDT_Int16:
        {
            return GDALIsValueInRange<GInt16>(dfNoDataValue);
        }

        case GDT_UInt16:
        {
            return GDALIsValueInRange<GUInt16>(dfNoDataValue);
        }

        case GDT_UInt32:
        {
            return GDALIsValueInRange<GUInt32>(dfNoDataValue);
        }
        case GDT_Int32:
        {
            return GDALIsValueInRange<GInt32>(dfNoDataValue);
        }

        case GDT_UInt64:
        {
            return GDALIsValueInRange<uint64_t>(dfNoDataValue);
        }

        case GDT_Int64:
        {
            return GDALIsValueInRange<int64_t>(dfNoDataValue);
        }

        case GDT_Float16:
        {
            return std::isnan(dfNoDataValue) || std::isinf(dfNoDataValue) ||
                   GDALIsValueInRange<GFloat16>(dfNoDataValue);
        }

        case GDT_Float32:
        {
            return std::isnan(dfNoDataValue) || std::isinf(dfNoDataValue) ||
                   GDALIsValueInRange<float>(dfNoDataValue);
        }

        case GDT_Float64:
        {
            return true;
        }

        case GDT_CFloat16:
        case GDT_CFloat32:
        case GDT_CFloat64:
        case GDT_CInt16:
        case GDT_CInt32:
        case GDT_Unknown:
        case GDT_TypeCount:
            break;
    }

    CPLAssert(false);
    return false;
}

/************************************************************************/
/*                             IReadBlock()                             */
/************************************************************************/

CPLErr GDALNoDataMaskBand::IReadBlock(int nXBlockOff, int nYBlockOff,
                                      void *pImage)

{
    const int nXOff = nXBlockOff * nBlockXSize;
    const int nXSizeRequest = std::min(nBlockXSize, nRasterXSize - nXOff);
    const int nYOff = nYBlockOff * nBlockYSize;
    const int nYSizeRequest = std::min(nBlockYSize, nRasterYSize - nYOff);

    if (nBlockXSize != nXSizeRequest || nBlockYSize != nYSizeRequest)
    {
        memset(pImage, 0, static_cast<GPtrDiff_t>(nBlockXSize) * nBlockYSize);
    }

    GDALRasterIOExtraArg sExtraArg;
    INIT_RASTERIO_EXTRA_ARG(sExtraArg);
    return IRasterIO(GF_Read, nXOff, nYOff, nXSizeRequest, nYSizeRequest,
                     pImage, nXSizeRequest, nYSizeRequest, GDT_UInt8, 1,
                     nBlockXSize, &sExtraArg);
}

/************************************************************************/
/*                            SetZeroOr255()                            */
/************************************************************************/

#if (defined(__GNUC__) && !defined(__clang__))
__attribute__((optimize("tree-vectorize")))
#endif
static void SetZeroOr255(GByte *pabyDestAndSrc, size_t nBufSize, GByte byNoData)
{
    for (size_t i = 0; i < nBufSize; ++i)
    {
        pabyDestAndSrc[i] = (pabyDestAndSrc[i] == byNoData) ? 0 : 255;
    }
}

template <class T>
#if (defined(__GNUC__) && !defined(__clang__))
__attribute__((optimize("tree-vectorize")))
#endif
static void SetZeroOr255(GByte *pabyDest, const T *panSrc, size_t nBufSize,
                         T nNoData)
{
    for (size_t i = 0; i < nBufSize; ++i)
    {
        pabyDest[i] = (panSrc[i] == nNoData) ? 0 : 255;
    }
}

template <class T>
static void SetZeroOr255(GByte *pabyDest, const T *panSrc, int nBufXSize,
                         int nBufYSize, GSpacing nPixelSpace,
                         GSpacing nLineSpace, T nNoData)
{
    if (nPixelSpace == 1)
    {
        for (int iY = 0; iY < nBufYSize; iY++)
        {
            SetZeroOr255(pabyDest, panSrc, nBufXSize, nNoData);
            pabyDest += nLineSpace;
            panSrc += nBufXSize;
        }
    }
    else
    {
        size_t i = 0;
        for (int iY = 0; iY < nBufYSize; iY++)
        {
            GByte *pabyLineDest = pabyDest + iY * nLineSpace;
            for (int iX = 0; iX < nBufXSize; iX++)
            {
                *pabyLineDest = (panSrc[i] == nNoData) ? 0 : 255;
                ++i;
                pabyLineDest += nPixelSpace;
            }
        }
    }
}

/************************************************************************/
/*                             IRasterIO()                              */
/************************************************************************/

CPLErr GDALNoDataMaskBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
                                     int nXSize, int nYSize, void *pData,
                                     int nBufXSize, int nBufYSize,
                                     GDALDataType eBufType,
                                     GSpacing nPixelSpace, GSpacing nLineSpace,
                                     GDALRasterIOExtraArg *psExtraArg)
{
    if (eRWFlag != GF_Read)
    {
        return CE_Failure;
    }
    const auto eParentDT = m_poParent->GetRasterDataType();
    const GDALDataType eWrkDT = GetWorkDataType(eParentDT);

    // Optimization in common use case (#4488).
    // This avoids triggering the block cache on this band, which helps
    // reducing the global block cache consumption.
    if (eBufType == GDT_UInt8 && eWrkDT == GDT_UInt8 && nPixelSpace == 1 &&
        nLineSpace >= nBufXSize)
    {
        const CPLErr eErr = m_poParent->RasterIO(
            GF_Read, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize,
            eBufType, nPixelSpace, nLineSpace, psExtraArg);
        if (eErr != CE_None)
            return eErr;

        GByte *pabyData = static_cast<GByte *>(pData);
        const GByte byNoData = static_cast<GByte>(m_dfNoDataValue);

        if (nLineSpace == nBufXSize)
        {
            const size_t nBufSize = static_cast<size_t>(nBufXSize) * nBufYSize;
            SetZeroOr255(pabyData, nBufSize, byNoData);
        }
        else
        {
            assert(nLineSpace > nBufXSize);
            for (int iY = 0; iY < nBufYSize; iY++)
            {
                SetZeroOr255(pabyData, nBufXSize, byNoData);
                pabyData += nLineSpace;
            }
        }
        return CE_None;
    }

    const auto AllocTempBufferOrFallback =
        [this, eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize,
         nBufYSize, eBufType, nPixelSpace, nLineSpace,
         psExtraArg](int nWrkDTSize) -> std::pair<CPLErr, void *>
    {
        auto poParentDS = m_poParent->GetDataset();
        // Check if we must simulate a memory allocation failure
        // Before checking the env variable, which is slightly expensive,
        // check first for a special dataset name, which is a cheap test.
        const char *pszOptVal =
            poParentDS && strcmp(poParentDS->GetDescription(), "__debug__") == 0
                ? CPLGetConfigOption(
                      "GDAL_SIMUL_MEM_ALLOC_FAILURE_NODATA_MASK_BAND", "NO")
                : "NO";
        const bool bSimulMemAllocFailure =
            EQUAL(pszOptVal, "ALWAYS") ||
            (CPLTestBool(pszOptVal) &&
             GDALMajorObject::GetMetadataItem(__func__, "__INTERNAL__") ==
                 nullptr);
        void *pTemp = nullptr;
        if (!bSimulMemAllocFailure)
        {
            CPLErrorStateBackuper oErrorStateBackuper(CPLQuietErrorHandler);
            pTemp = VSI_MALLOC3_VERBOSE(nWrkDTSize, nBufXSize, nBufYSize);
        }
        if (!pTemp)
        {
            const bool bAllocHasAlreadyFailed =
                GDALMajorObject::GetMetadataItem(__func__, "__INTERNAL__") !=
                nullptr;
            CPLError(bAllocHasAlreadyFailed ? CE_Failure : CE_Warning,
                     CPLE_OutOfMemory,
                     "GDALNoDataMaskBand::IRasterIO(): cannot allocate %d x %d "
                     "x %d bytes%s",
                     nBufXSize, nBufYSize, nWrkDTSize,
                     bAllocHasAlreadyFailed
                         ? ""
                         : ". Falling back to block-based approach");
            if (bAllocHasAlreadyFailed)
                return std::pair(CE_Failure, nullptr);
            // Sets a metadata item to prevent potential infinite recursion
            GDALMajorObject::SetMetadataItem(__func__, "IN", "__INTERNAL__");
            const CPLErr eErr = GDALRasterBand::IRasterIO(
                eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize,
                nBufYSize, eBufType, nPixelSpace, nLineSpace, psExtraArg);
            GDALMajorObject::SetMetadataItem(__func__, nullptr, "__INTERNAL__");
            return std::pair(eErr, nullptr);
        }
        return std::pair(CE_None, pTemp);
    };

    if (eBufType == GDT_UInt8)
    {
        const int nWrkDTSize = GDALGetDataTypeSizeBytes(eWrkDT);
        auto [eErr, pTemp] = AllocTempBufferOrFallback(nWrkDTSize);
        if (!pTemp)
            return eErr;

        eErr = m_poParent->RasterIO(
            GF_Read, nXOff, nYOff, nXSize, nYSize, pTemp, nBufXSize, nBufYSize,
            eWrkDT, nWrkDTSize, static_cast<GSpacing>(nBufXSize) * nWrkDTSize,
            psExtraArg);
        if (eErr != CE_None)
        {
            VSIFree(pTemp);
            return eErr;
        }

        const bool bIsNoDataNan = std::isnan(m_dfNoDataValue) != 0;
        GByte *pabyDest = static_cast<GByte *>(pData);

        /* --------------------------------------------------------------------
         */
        /*      Process different cases. */
        /* --------------------------------------------------------------------
         */
        switch (eWrkDT)
        {
            case GDT_UInt8:
            {
                const auto nNoData = static_cast<GByte>(m_dfNoDataValue);
                const auto *panSrc = static_cast<const GByte *>(pTemp);
                SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
                             nPixelSpace, nLineSpace, nNoData);
            }
            break;

            case GDT_Int16:
            {
                const auto nNoData = static_cast<int16_t>(m_dfNoDataValue);
                const auto *panSrc = static_cast<const int16_t *>(pTemp);
                SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
                             nPixelSpace, nLineSpace, nNoData);
            }
            break;

            case GDT_UInt16:
            {
                const auto nNoData = static_cast<uint16_t>(m_dfNoDataValue);
                const auto *panSrc = static_cast<const uint16_t *>(pTemp);
                SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
                             nPixelSpace, nLineSpace, nNoData);
            }
            break;

            case GDT_UInt32:
            {
                const auto nNoData = static_cast<GUInt32>(m_dfNoDataValue);
                const auto *panSrc = static_cast<const GUInt32 *>(pTemp);
                SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
                             nPixelSpace, nLineSpace, nNoData);
            }
            break;

            case GDT_Int32:
            {
                const auto nNoData = static_cast<GInt32>(m_dfNoDataValue);
                const auto *panSrc = static_cast<const GInt32 *>(pTemp);
                SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
                             nPixelSpace, nLineSpace, nNoData);
            }
            break;

            case GDT_Float32:
            {
                const float fNoData = static_cast<float>(m_dfNoDataValue);
                const float *pafSrc = static_cast<const float *>(pTemp);

                size_t i = 0;
                for (int iY = 0; iY < nBufYSize; iY++)
                {
                    GByte *pabyLineDest = pabyDest + iY * nLineSpace;
                    for (int iX = 0; iX < nBufXSize; iX++)
                    {
                        const float fVal = pafSrc[i];
                        if (bIsNoDataNan && std::isnan(fVal))
                            *pabyLineDest = 0;
                        else if (ARE_REAL_EQUAL(fVal, fNoData))
                            *pabyLineDest = 0;
                        else
                            *pabyLineDest = 255;
                        ++i;
                        pabyLineDest += nPixelSpace;
                    }
                }
            }
            break;

            case GDT_Float64:
            {
                const double *padfSrc = static_cast<const double *>(pTemp);

                size_t i = 0;
                for (int iY = 0; iY < nBufYSize; iY++)
                {
                    GByte *pabyLineDest = pabyDest + iY * nLineSpace;
                    for (int iX = 0; iX < nBufXSize; iX++)
                    {
                        const double dfVal = padfSrc[i];
                        if (bIsNoDataNan && std::isnan(dfVal))
                            *pabyLineDest = 0;
                        else if (ARE_REAL_EQUAL(dfVal, m_dfNoDataValue))
                            *pabyLineDest = 0;
                        else
                            *pabyLineDest = 255;
                        ++i;
                        pabyLineDest += nPixelSpace;
                    }
                }
            }
            break;

            case GDT_Int64:
            {
                const auto *panSrc = static_cast<const int64_t *>(pTemp);
                SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
                             nPixelSpace, nLineSpace, m_nNoDataValueInt64);
            }
            break;

            case GDT_UInt64:
            {
                const auto *panSrc = static_cast<const uint64_t *>(pTemp);
                SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
                             nPixelSpace, nLineSpace, m_nNoDataValueUInt64);
            }
            break;

            default:
                CPLAssert(false);
                break;
        }

        VSIFree(pTemp);
        return CE_None;
    }

    // Output buffer is non-Byte. Ask for Byte and expand to user requested
    // type
    auto [eErr, pTemp] = AllocTempBufferOrFallback(sizeof(GByte));
    if (!pTemp)
        return eErr;

    eErr = IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pTemp, nBufXSize,
                     nBufYSize, GDT_UInt8, 1, nBufXSize, psExtraArg);
    if (eErr != CE_None)
    {
        VSIFree(pTemp);
        return eErr;
    }

    for (int iY = 0; iY < nBufYSize; iY++)
    {
        GDALCopyWords64(
            static_cast<GByte *>(pTemp) + static_cast<size_t>(iY) * nBufXSize,
            GDT_UInt8, 1, static_cast<GByte *>(pData) + iY * nLineSpace,
            eBufType, static_cast<int>(nPixelSpace), nBufXSize);
    }
    VSIFree(pTemp);
    return CE_None;
}

/************************************************************************/
/*                EmitErrorMessageIfWriteNotSupported()                 */
/************************************************************************/

bool GDALNoDataMaskBand::EmitErrorMessageIfWriteNotSupported(
    const char *pszCaller) const
{
    ReportError(CE_Failure, CPLE_NoWriteAccess,
                "%s: attempt to write to a nodata implicit mask band.",
                pszCaller);

    return true;
}

//! @endcond

Coverage Report

Created: 2026-02-14 06:52

Line	Count	Source
1		/******************************************************************************
2		*
3		* Project: GDAL Core
4		* Purpose: Implementation of GDALNoDataMaskBand, a class implementing all
5		* a default band mask based on nodata values.
6		* Author: Frank Warmerdam, warmerdam@pobox.com
7		*
8		******************************************************************************
9		* Copyright (c) 2007, Frank Warmerdam
10		* Copyright (c) 2008-2012, Even Rouault <even dot rouault at spatialys.com>
11		*
12		* SPDX-License-Identifier: MIT
13		****************************************************************************/
14
15		#include "cpl_port.h"
16		#include "gdal_priv.h"
17
18		#include <algorithm>
19		#include <cassert>
20		#include <cmath>
21		#include <cstring>
22		#include <utility>
23
24		#include "cpl_conv.h"
25		#include "cpl_error.h"
26		#include "cpl_vsi.h"
27		#include "gdal.h"
28		#include "gdal_priv_templates.hpp"
29
30		//! @cond Doxygen_Suppress
31		/************************************************************************/
32		/* GDALNoDataMaskBand() */
33		/************************************************************************/
34
35		GDALNoDataMaskBand::GDALNoDataMaskBand(GDALRasterBand *poParentIn)
36	0	: m_poParent(poParentIn)
37	0	{
38	0	poDS = nullptr;
39	0	nBand = 0;
40
41	0	nRasterXSize = m_poParent->GetXSize();
42	0	nRasterYSize = m_poParent->GetYSize();
43
44	0	eDataType = GDT_UInt8;
45	0	m_poParent->GetBlockSize(&nBlockXSize, &nBlockYSize);
46
47	0	const auto eParentDT = m_poParent->GetRasterDataType();
48	0	if (eParentDT == GDT_Int64)
49	0	m_nNoDataValueInt64 = m_poParent->GetNoDataValueAsInt64();
50	0	else if (eParentDT == GDT_UInt64)
51	0	m_nNoDataValueUInt64 = m_poParent->GetNoDataValueAsUInt64();
52	0	else
53	0	m_dfNoDataValue = m_poParent->GetNoDataValue();
54	0	}
55
56		/************************************************************************/
57		/* GDALNoDataMaskBand() */
58		/************************************************************************/
59
60		GDALNoDataMaskBand::GDALNoDataMaskBand(GDALRasterBand *poParentIn,
61		double dfNoDataValue)
62	0	: m_poParent(poParentIn)
63	0	{
64	0	poDS = nullptr;
65	0	nBand = 0;
66
67	0	nRasterXSize = m_poParent->GetXSize();
68	0	nRasterYSize = m_poParent->GetYSize();
69
70	0	eDataType = GDT_UInt8;
71	0	m_poParent->GetBlockSize(&nBlockXSize, &nBlockYSize);
72
73	0	const auto eParentDT = m_poParent->GetRasterDataType();
74	0	if (eParentDT == GDT_Int64)
75	0	m_nNoDataValueInt64 = static_cast<int64_t>(dfNoDataValue);
76	0	else if (eParentDT == GDT_UInt64)
77	0	m_nNoDataValueUInt64 = static_cast<uint64_t>(dfNoDataValue);
78	0	else
79	0	m_dfNoDataValue = dfNoDataValue;
80	0	}
81
82		/************************************************************************/
83		/* ~GDALNoDataMaskBand() */
84		/************************************************************************/
85
86	0	GDALNoDataMaskBand::~GDALNoDataMaskBand() = default;
87
88		/************************************************************************/
89		/* GetWorkDataType() */
90		/************************************************************************/
91
92		static GDALDataType GetWorkDataType(GDALDataType eDataType)
93	0	{
94	0	GDALDataType eWrkDT = GDT_Unknown;
95	0	switch (eDataType)
96	0	{
97	0	case GDT_UInt8:
98	0	eWrkDT = GDT_UInt8;
99	0	break;
100
101	0	case GDT_Int16:
102	0	eWrkDT = GDT_Int16;
103	0	break;
104
105	0	case GDT_UInt16:
106	0	eWrkDT = GDT_UInt16;
107	0	break;
108
109	0	case GDT_UInt32:
110	0	eWrkDT = GDT_UInt32;
111	0	break;
112
113	0	case GDT_Int8:
114	0	case GDT_Int32:
115	0	case GDT_CInt16:
116	0	case GDT_CInt32:
117	0	eWrkDT = GDT_Int32;
118	0	break;
119
120	0	case GDT_Float16:
121	0	case GDT_CFloat16:
122	0	case GDT_Float32:
123	0	case GDT_CFloat32:
124	0	eWrkDT = GDT_Float32;
125	0	break;
126
127	0	case GDT_Float64:
128	0	case GDT_CFloat64:
129	0	eWrkDT = GDT_Float64;
130	0	break;
131
132	0	case GDT_Int64:
133	0	case GDT_UInt64:
134	0	eWrkDT = eDataType;
135	0	break;
136
137	0	case GDT_Unknown:
138	0	case GDT_TypeCount:
139	0	CPLAssert(false);
140	0	eWrkDT = GDT_Float64;
141	0	break;
142	0	}
143	0	return eWrkDT;
144	0	}
145
146		/************************************************************************/
147		/* IsNoDataInRange() */
148		/************************************************************************/
149
150		bool GDALNoDataMaskBand::IsNoDataInRange(double dfNoDataValue,
151		GDALDataType eDataTypeIn)
152	0	{
153	0	GDALDataType eWrkDT = GetWorkDataType(eDataTypeIn);
154	0	switch (eWrkDT)
155	0	{
156	0	case GDT_UInt8:
157	0	{
158	0	return GDALIsValueInRange<GByte>(dfNoDataValue);
159	0	}
160
161	0	case GDT_Int8:
162	0	{
163	0	return GDALIsValueInRange<signed char>(dfNoDataValue);
164	0	}
165
166	0	case GDT_Int16:
167	0	{
168	0	return GDALIsValueInRange<GInt16>(dfNoDataValue);
169	0	}
170
171	0	case GDT_UInt16:
172	0	{
173	0	return GDALIsValueInRange<GUInt16>(dfNoDataValue);
174	0	}
175
176	0	case GDT_UInt32:
177	0	{
178	0	return GDALIsValueInRange<GUInt32>(dfNoDataValue);
179	0	}
180	0	case GDT_Int32:
181	0	{
182	0	return GDALIsValueInRange<GInt32>(dfNoDataValue);
183	0	}
184
185	0	case GDT_UInt64:
186	0	{
187	0	return GDALIsValueInRange<uint64_t>(dfNoDataValue);
188	0	}
189
190	0	case GDT_Int64:
191	0	{
192	0	return GDALIsValueInRange<int64_t>(dfNoDataValue);
193	0	}
194
195	0	case GDT_Float16:
196	0	{
197	0	return std::isnan(dfNoDataValue) \|\| std::isinf(dfNoDataValue) \|\|
198	0	GDALIsValueInRange<GFloat16>(dfNoDataValue);
199	0	}
200
201	0	case GDT_Float32:
202	0	{
203	0	return std::isnan(dfNoDataValue) \|\| std::isinf(dfNoDataValue) \|\|
204	0	GDALIsValueInRange<float>(dfNoDataValue);
205	0	}
206
207	0	case GDT_Float64:
208	0	{
209	0	return true;
210	0	}
211
212	0	case GDT_CFloat16:
213	0	case GDT_CFloat32:
214	0	case GDT_CFloat64:
215	0	case GDT_CInt16:
216	0	case GDT_CInt32:
217	0	case GDT_Unknown:
218	0	case GDT_TypeCount:
219	0	break;
220	0	}
221
222	0	CPLAssert(false);
223	0	return false;
224	0	}
225
226		/************************************************************************/
227		/* IReadBlock() */
228		/************************************************************************/
229
230		CPLErr GDALNoDataMaskBand::IReadBlock(int nXBlockOff, int nYBlockOff,
231		void *pImage)
232
233	0	{
234	0	const int nXOff = nXBlockOff * nBlockXSize;
235	0	const int nXSizeRequest = std::min(nBlockXSize, nRasterXSize - nXOff);
236	0	const int nYOff = nYBlockOff * nBlockYSize;
237	0	const int nYSizeRequest = std::min(nBlockYSize, nRasterYSize - nYOff);
238
239	0	if (nBlockXSize != nXSizeRequest \|\| nBlockYSize != nYSizeRequest)
240	0	{
241	0	memset(pImage, 0, static_cast<GPtrDiff_t>(nBlockXSize) * nBlockYSize);
242	0	}
243
244	0	GDALRasterIOExtraArg sExtraArg;
245	0	INIT_RASTERIO_EXTRA_ARG(sExtraArg);
246	0	return IRasterIO(GF_Read, nXOff, nYOff, nXSizeRequest, nYSizeRequest,
247	0	pImage, nXSizeRequest, nYSizeRequest, GDT_UInt8, 1,
248	0	nBlockXSize, &sExtraArg);
249	0	}
250
251		/************************************************************************/
252		/* SetZeroOr255() */
253		/************************************************************************/
254
255		#if (defined(__GNUC__) && !defined(__clang__))
256		__attribute__((optimize("tree-vectorize")))
257		#endif
258		static void SetZeroOr255(GByte *pabyDestAndSrc, size_t nBufSize, GByte byNoData)
259	0	{
260	0	for (size_t i = 0; i < nBufSize; ++i)
261	0	{
262	0	pabyDestAndSrc[i] = (pabyDestAndSrc[i] == byNoData) ? 0 : 255;
263	0	}
264	0	}
265
266		template <class T>
267		#if (defined(__GNUC__) && !defined(__clang__))
268		__attribute__((optimize("tree-vectorize")))
269		#endif
270		static void SetZeroOr255(GByte pabyDest, const T panSrc, size_t nBufSize,
271		T nNoData)
272	0	{
273	0	for (size_t i = 0; i < nBufSize; ++i)
274	0	{
275	0	pabyDest[i] = (panSrc[i] == nNoData) ? 0 : 255;
276	0	}
277	0	} Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<unsigned char>(unsigned char, unsigned char const, unsigned long, unsigned char) Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<short>(unsigned char, short const, unsigned long, short) Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<unsigned short>(unsigned char, unsigned short const, unsigned long, unsigned short) Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<unsigned int>(unsigned char, unsigned int const, unsigned long, unsigned int) Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<int>(unsigned char, int const, unsigned long, int) Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<long>(unsigned char, long const, unsigned long, long) Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<unsigned long>(unsigned char, unsigned long const, unsigned long, unsigned long)
278
279		template <class T>
280		static void SetZeroOr255(GByte pabyDest, const T panSrc, int nBufXSize,
281		int nBufYSize, GSpacing nPixelSpace,
282		GSpacing nLineSpace, T nNoData)
283	0	{
284	0	if (nPixelSpace == 1)
285	0	{
286	0	for (int iY = 0; iY < nBufYSize; iY++)
287	0	{
288	0	SetZeroOr255(pabyDest, panSrc, nBufXSize, nNoData);
289	0	pabyDest += nLineSpace;
290	0	panSrc += nBufXSize;
291	0	}
292	0	}
293	0	else
294	0	{
295	0	size_t i = 0;
296	0	for (int iY = 0; iY < nBufYSize; iY++)
297	0	{
298	0	GByte pabyLineDest = pabyDest + iY nLineSpace;
299	0	for (int iX = 0; iX < nBufXSize; iX++)
300	0	{
301	0	*pabyLineDest = (panSrc[i] == nNoData) ? 0 : 255;
302	0	++i;
303	0	pabyLineDest += nPixelSpace;
304	0	}
305	0	}
306	0	}
307	0	} Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<unsigned char>(unsigned char, unsigned char const, int, int, long long, long long, unsigned char) Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<short>(unsigned char, short const, int, int, long long, long long, short) Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<unsigned short>(unsigned char, unsigned short const, int, int, long long, long long, unsigned short) Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<unsigned int>(unsigned char, unsigned int const, int, int, long long, long long, unsigned int) Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<int>(unsigned char, int const, int, int, long long, long long, int) Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<long>(unsigned char, long const, int, int, long long, long long, long) Unexecuted instantiation: gdalnodatamaskband.cpp:void SetZeroOr255<unsigned long>(unsigned char, unsigned long const, int, int, long long, long long, unsigned long)
308
309		/************************************************************************/
310		/* IRasterIO() */
311		/************************************************************************/
312
313		CPLErr GDALNoDataMaskBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff, int nYOff,
314		int nXSize, int nYSize, void *pData,
315		int nBufXSize, int nBufYSize,
316		GDALDataType eBufType,
317		GSpacing nPixelSpace, GSpacing nLineSpace,
318		GDALRasterIOExtraArg *psExtraArg)
319	0	{
320	0	if (eRWFlag != GF_Read)
321	0	{
322	0	return CE_Failure;
323	0	}
324	0	const auto eParentDT = m_poParent->GetRasterDataType();
325	0	const GDALDataType eWrkDT = GetWorkDataType(eParentDT);
326
327		// Optimization in common use case (#4488).
328		// This avoids triggering the block cache on this band, which helps
329		// reducing the global block cache consumption.
330	0	if (eBufType == GDT_UInt8 && eWrkDT == GDT_UInt8 && nPixelSpace == 1 &&
331	0	nLineSpace >= nBufXSize)
332	0	{
333	0	const CPLErr eErr = m_poParent->RasterIO(
334	0	GF_Read, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize,
335	0	eBufType, nPixelSpace, nLineSpace, psExtraArg);
336	0	if (eErr != CE_None)
337	0	return eErr;
338
339	0	GByte pabyData = static_cast<GByte >(pData);
340	0	const GByte byNoData = static_cast<GByte>(m_dfNoDataValue);
341
342	0	if (nLineSpace == nBufXSize)
343	0	{
344	0	const size_t nBufSize = static_cast<size_t>(nBufXSize) * nBufYSize;
345	0	SetZeroOr255(pabyData, nBufSize, byNoData);
346	0	}
347	0	else
348	0	{
349	0	assert(nLineSpace > nBufXSize);
350	0	for (int iY = 0; iY < nBufYSize; iY++)
351	0	{
352	0	SetZeroOr255(pabyData, nBufXSize, byNoData);
353	0	pabyData += nLineSpace;
354	0	}
355	0	}
356	0	return CE_None;
357	0	}
358
359	0	const auto AllocTempBufferOrFallback =
360	0	[this, eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize,
361	0	nBufYSize, eBufType, nPixelSpace, nLineSpace,
362	0	psExtraArg](int nWrkDTSize) -> std::pair<CPLErr, void *>
363	0	{
364	0	auto poParentDS = m_poParent->GetDataset();
365		// Check if we must simulate a memory allocation failure
366		// Before checking the env variable, which is slightly expensive,
367		// check first for a special dataset name, which is a cheap test.
368	0	const char *pszOptVal =
369	0	poParentDS && strcmp(poParentDS->GetDescription(), "__debug__") == 0
370	0	? CPLGetConfigOption(
371	0	"GDAL_SIMUL_MEM_ALLOC_FAILURE_NODATA_MASK_BAND", "NO")
372	0	: "NO";
373	0	const bool bSimulMemAllocFailure =
374	0	EQUAL(pszOptVal, "ALWAYS") \|\|
375	0	(CPLTestBool(pszOptVal) &&
376	0	GDALMajorObject::GetMetadataItem(__func__, "__INTERNAL__") ==
377	0	nullptr);
378	0	void *pTemp = nullptr;
379	0	if (!bSimulMemAllocFailure)
380	0	{
381	0	CPLErrorStateBackuper oErrorStateBackuper(CPLQuietErrorHandler);
382	0	pTemp = VSI_MALLOC3_VERBOSE(nWrkDTSize, nBufXSize, nBufYSize);
383	0	}
384	0	if (!pTemp)
385	0	{
386	0	const bool bAllocHasAlreadyFailed =
387	0	GDALMajorObject::GetMetadataItem(__func__, "__INTERNAL__") !=
388	0	nullptr;
389	0	CPLError(bAllocHasAlreadyFailed ? CE_Failure : CE_Warning,
390	0	CPLE_OutOfMemory,
391	0	"GDALNoDataMaskBand::IRasterIO(): cannot allocate %d x %d "
392	0	"x %d bytes%s",
393	0	nBufXSize, nBufYSize, nWrkDTSize,
394	0	bAllocHasAlreadyFailed
395	0	? ""
396	0	: ". Falling back to block-based approach");
397	0	if (bAllocHasAlreadyFailed)
398	0	return std::pair(CE_Failure, nullptr);
399		// Sets a metadata item to prevent potential infinite recursion
400	0	GDALMajorObject::SetMetadataItem(__func__, "IN", "__INTERNAL__");
401	0	const CPLErr eErr = GDALRasterBand::IRasterIO(
402	0	eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize,
403	0	nBufYSize, eBufType, nPixelSpace, nLineSpace, psExtraArg);
404	0	GDALMajorObject::SetMetadataItem(__func__, nullptr, "__INTERNAL__");
405	0	return std::pair(eErr, nullptr);
406	0	}
407	0	return std::pair(CE_None, pTemp);
408	0	};
409
410	0	if (eBufType == GDT_UInt8)
411	0	{
412	0	const int nWrkDTSize = GDALGetDataTypeSizeBytes(eWrkDT);
413	0	auto [eErr, pTemp] = AllocTempBufferOrFallback(nWrkDTSize);
414	0	if (!pTemp)
415	0	return eErr;
416
417	0	eErr = m_poParent->RasterIO(
418	0	GF_Read, nXOff, nYOff, nXSize, nYSize, pTemp, nBufXSize, nBufYSize,
419	0	eWrkDT, nWrkDTSize, static_cast<GSpacing>(nBufXSize) * nWrkDTSize,
420	0	psExtraArg);
421	0	if (eErr != CE_None)
422	0	{
423	0	VSIFree(pTemp);
424	0	return eErr;
425	0	}
426
427	0	const bool bIsNoDataNan = std::isnan(m_dfNoDataValue) != 0;
428	0	GByte pabyDest = static_cast<GByte >(pData);
429
430		/* --------------------------------------------------------------------
431		*/
432		/* Process different cases. */
433		/* --------------------------------------------------------------------
434		*/
435	0	switch (eWrkDT)
436	0	{
437	0	case GDT_UInt8:
438	0	{
439	0	const auto nNoData = static_cast<GByte>(m_dfNoDataValue);
440	0	const auto panSrc = static_cast<const GByte >(pTemp);
441	0	SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
442	0	nPixelSpace, nLineSpace, nNoData);
443	0	}
444	0	break;
445
446	0	case GDT_Int16:
447	0	{
448	0	const auto nNoData = static_cast<int16_t>(m_dfNoDataValue);
449	0	const auto panSrc = static_cast<const int16_t >(pTemp);
450	0	SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
451	0	nPixelSpace, nLineSpace, nNoData);
452	0	}
453	0	break;
454
455	0	case GDT_UInt16:
456	0	{
457	0	const auto nNoData = static_cast<uint16_t>(m_dfNoDataValue);
458	0	const auto panSrc = static_cast<const uint16_t >(pTemp);
459	0	SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
460	0	nPixelSpace, nLineSpace, nNoData);
461	0	}
462	0	break;
463
464	0	case GDT_UInt32:
465	0	{
466	0	const auto nNoData = static_cast<GUInt32>(m_dfNoDataValue);
467	0	const auto panSrc = static_cast<const GUInt32 >(pTemp);
468	0	SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
469	0	nPixelSpace, nLineSpace, nNoData);
470	0	}
471	0	break;
472
473	0	case GDT_Int32:
474	0	{
475	0	const auto nNoData = static_cast<GInt32>(m_dfNoDataValue);
476	0	const auto panSrc = static_cast<const GInt32 >(pTemp);
477	0	SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
478	0	nPixelSpace, nLineSpace, nNoData);
479	0	}
480	0	break;
481
482	0	case GDT_Float32:
483	0	{
484	0	const float fNoData = static_cast<float>(m_dfNoDataValue);
485	0	const float pafSrc = static_cast<const float >(pTemp);
486
487	0	size_t i = 0;
488	0	for (int iY = 0; iY < nBufYSize; iY++)
489	0	{
490	0	GByte pabyLineDest = pabyDest + iY nLineSpace;
491	0	for (int iX = 0; iX < nBufXSize; iX++)
492	0	{
493	0	const float fVal = pafSrc[i];
494	0	if (bIsNoDataNan && std::isnan(fVal))
495	0	*pabyLineDest = 0;
496	0	else if (ARE_REAL_EQUAL(fVal, fNoData))
497	0	*pabyLineDest = 0;
498	0	else
499	0	*pabyLineDest = 255;
500	0	++i;
501	0	pabyLineDest += nPixelSpace;
502	0	}
503	0	}
504	0	}
505	0	break;
506
507	0	case GDT_Float64:
508	0	{
509	0	const double padfSrc = static_cast<const double >(pTemp);
510
511	0	size_t i = 0;
512	0	for (int iY = 0; iY < nBufYSize; iY++)
513	0	{
514	0	GByte pabyLineDest = pabyDest + iY nLineSpace;
515	0	for (int iX = 0; iX < nBufXSize; iX++)
516	0	{
517	0	const double dfVal = padfSrc[i];
518	0	if (bIsNoDataNan && std::isnan(dfVal))
519	0	*pabyLineDest = 0;
520	0	else if (ARE_REAL_EQUAL(dfVal, m_dfNoDataValue))
521	0	*pabyLineDest = 0;
522	0	else
523	0	*pabyLineDest = 255;
524	0	++i;
525	0	pabyLineDest += nPixelSpace;
526	0	}
527	0	}
528	0	}
529	0	break;
530
531	0	case GDT_Int64:
532	0	{
533	0	const auto panSrc = static_cast<const int64_t >(pTemp);
534	0	SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
535	0	nPixelSpace, nLineSpace, m_nNoDataValueInt64);
536	0	}
537	0	break;
538
539	0	case GDT_UInt64:
540	0	{
541	0	const auto panSrc = static_cast<const uint64_t >(pTemp);
542	0	SetZeroOr255(pabyDest, panSrc, nBufXSize, nBufYSize,
543	0	nPixelSpace, nLineSpace, m_nNoDataValueUInt64);
544	0	}
545	0	break;
546
547	0	default:
548	0	CPLAssert(false);
549	0	break;
550	0	}
551
552	0	VSIFree(pTemp);
553	0	return CE_None;
554	0	}
555
556		// Output buffer is non-Byte. Ask for Byte and expand to user requested
557		// type
558	0	auto [eErr, pTemp] = AllocTempBufferOrFallback(sizeof(GByte));
559	0	if (!pTemp)
560	0	return eErr;
561
562	0	eErr = IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize, pTemp, nBufXSize,
563	0	nBufYSize, GDT_UInt8, 1, nBufXSize, psExtraArg);
564	0	if (eErr != CE_None)
565	0	{
566	0	VSIFree(pTemp);
567	0	return eErr;
568	0	}
569
570	0	for (int iY = 0; iY < nBufYSize; iY++)
571	0	{
572	0	GDALCopyWords64(
573	0	static_cast<GByte >(pTemp) + static_cast<size_t>(iY) nBufXSize,
574	0	GDT_UInt8, 1, static_cast<GByte >(pData) + iY nLineSpace,
575	0	eBufType, static_cast<int>(nPixelSpace), nBufXSize);
576	0	}
577	0	VSIFree(pTemp);
578	0	return CE_None;
579	0	}
580
581		/************************************************************************/
582		/* EmitErrorMessageIfWriteNotSupported() */
583		/************************************************************************/
584
585		bool GDALNoDataMaskBand::EmitErrorMessageIfWriteNotSupported(
586		const char *pszCaller) const
587	0	{
588	0	ReportError(CE_Failure, CPLE_NoWriteAccess,
589	0	"%s: attempt to write to a nodata implicit mask band.",
590	0	pszCaller);
591
592	0	return true;
593	0	}
594
595		//! @endcond