/******************************************************************************

 *

 * Project:  GDAL Core

 * Purpose:  Implementation of GDALNoDataValuesMaskBand, a class implementing

 *           a default band mask based on the NODATA_VALUES metadata item.

 *           A pixel is considered nodata in all bands if and only if all bands

 *           match the corresponding value in the NODATA_VALUES tuple

 * Author:   Even Rouault, <even dot rouault at spatialys.com>

 *

 ******************************************************************************

 * Copyright (c) 2008-2009, Even Rouault <even dot rouault at spatialys.com>

 *

 * SPDX-License-Identifier: MIT

 ****************************************************************************/

#include "cpl_port.h"

#include "gdal_priv.h"

#include <cstring>

#include "cpl_conv.h"

#include "cpl_error.h"

#include "cpl_string.h"

#include "cpl_vsi.h"

#include "gdal.h"

//! @cond Doxygen_Suppress

/************************************************************************/

/*                   GDALNoDataValuesMaskBand()                         */

/************************************************************************/

GDALNoDataValuesMaskBand::GDALNoDataValuesMaskBand(GDALDataset *poDSIn)

    : padfNodataValues(nullptr)

{

    const char *pszNoDataValues = poDSIn->GetMetadataItem("NODATA_VALUES");

    char **papszNoDataValues =

        CSLTokenizeStringComplex(pszNoDataValues, " ", FALSE, FALSE);

    padfNodataValues = static_cast<double *>(

        CPLMalloc(sizeof(double) * poDSIn->GetRasterCount()));

    for (int i = 0; i < poDSIn->GetRasterCount(); ++i)

    {

        padfNodataValues[i] = CPLAtof(papszNoDataValues[i]);

    }

    CSLDestroy(papszNoDataValues);

    poDS = poDSIn;

    nBand = 0;

    nRasterXSize = poDS->GetRasterXSize();

    nRasterYSize = poDS->GetRasterYSize();

    eDataType = GDT_Byte;

    poDS->GetRasterBand(1)->GetBlockSize(&nBlockXSize, &nBlockYSize);

}

/************************************************************************/

/*                    ~GDALNoDataValuesMaskBand()                       */

/************************************************************************/

GDALNoDataValuesMaskBand::~GDALNoDataValuesMaskBand()

{

    CPLFree(padfNodataValues);

}

/************************************************************************/

/*                            FillOutBuffer()                           */

/************************************************************************/

template <class T>

static void FillOutBuffer(GPtrDiff_t nBlockOffsetPixels, int nBands,

                          const void *pabySrc, const double *padfNodataValues,

                          void *pImage)

{

    T *paNoData = static_cast<T *>(CPLMalloc(nBands * sizeof(T)));

    for (int iBand = 0; iBand < nBands; ++iBand)

    {

        paNoData[iBand] = static_cast<T>(padfNodataValues[iBand]);

    }

    for (GPtrDiff_t i = 0; i < nBlockOffsetPixels; i++)

    {

        int nCountNoData = 0;

        for (int iBand = 0; iBand < nBands; ++iBand)

        {

            if (static_cast<const T *>(

                    pabySrc)[i + iBand * nBlockOffsetPixels] == paNoData[iBand])

                ++nCountNoData;

        }

        static_cast<GByte *>(pImage)[i] = nCountNoData == nBands ? 0 : 255;

    }

    CPLFree(paNoData);

}

Unexecuted instantiation: gdalnodatavaluesmaskband.cpp:void FillOutBuffer<unsigned char>(long long, int, void const*, double const*, void*)

Unexecuted instantiation: gdalnodatavaluesmaskband.cpp:void FillOutBuffer<unsigned int>(long long, int, void const*, double const*, void*)

Unexecuted instantiation: gdalnodatavaluesmaskband.cpp:void FillOutBuffer<int>(long long, int, void const*, double const*, void*)

Unexecuted instantiation: gdalnodatavaluesmaskband.cpp:void FillOutBuffer<float>(long long, int, void const*, double const*, void*)

Unexecuted instantiation: gdalnodatavaluesmaskband.cpp:void FillOutBuffer<double>(long long, int, void const*, double const*, void*)

/************************************************************************/

/*                             IReadBlock()                             */

/************************************************************************/

CPLErr GDALNoDataValuesMaskBand::IReadBlock(int nXBlockOff, int nYBlockOff,

                                            void *pImage)

{

    GDALDataType eWrkDT = GDT_Unknown;

    /* -------------------------------------------------------------------- */

    /*      Decide on a working type.                                       */

    /* -------------------------------------------------------------------- */

    switch (poDS->GetRasterBand(1)->GetRasterDataType())

    {

        case GDT_Byte:

            eWrkDT = GDT_Byte;

            break;

        case GDT_UInt16:

        case GDT_UInt32:

            eWrkDT = GDT_UInt32;

            break;

        case GDT_Int8:

        case GDT_Int16:

        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:

            // Lossy mapping...

            eWrkDT = GDT_Float64;

            break;

        case GDT_Unknown:

        case GDT_TypeCount:

            CPLAssert(false);

            eWrkDT = GDT_Float64;

            break;

    }

    /* -------------------------------------------------------------------- */

    /*      Read the image data.                                            */

    /* -------------------------------------------------------------------- */

    const int nBands = poDS->GetRasterCount();

    const int nWrkDTSize = GDALGetDataTypeSizeBytes(eWrkDT);

    GByte *pabySrc = static_cast<GByte *>(VSI_MALLOC3_VERBOSE(

        cpl::fits_on<int>(nBands * nWrkDTSize), nBlockXSize, nBlockYSize));

    if (pabySrc == nullptr)

    {

        return CE_Failure;

    }

    int nXSizeRequest = 0;

    int nYSizeRequest = 0;

    GetActualBlockSize(nXBlockOff, nYBlockOff, &nXSizeRequest, &nYSizeRequest);

    if (nXSizeRequest != nBlockXSize || nYSizeRequest != nBlockYSize)

    {

        // memset the whole buffer to avoid Valgrind warnings in case we can't

        // fetch a full block.

        memset(pabySrc, 0,

               static_cast<size_t>(nBands) * nWrkDTSize * nBlockXSize *

                   nBlockYSize);

    }

    const GPtrDiff_t nBlockOffsetPixels =

        static_cast<GPtrDiff_t>(nBlockXSize) * nBlockYSize;

    const GPtrDiff_t nBandOffsetByte = nWrkDTSize * nBlockOffsetPixels;

    for (int iBand = 0; iBand < nBands; ++iBand)

    {

        const CPLErr eErr = poDS->GetRasterBand(iBand + 1)->RasterIO(

            GF_Read, nXBlockOff * nBlockXSize, nYBlockOff * nBlockYSize,

            nXSizeRequest, nYSizeRequest, pabySrc + iBand * nBandOffsetByte,

            nXSizeRequest, nYSizeRequest, eWrkDT, 0,

            static_cast<GSpacing>(nBlockXSize) * nWrkDTSize, nullptr);

        if (eErr != CE_None)

            return eErr;

    }

    /* -------------------------------------------------------------------- */

    /*      Process different cases.                                        */

    /* -------------------------------------------------------------------- */

    switch (eWrkDT)

    {

        case GDT_Byte:

        {

            FillOutBuffer<GByte>(nBlockOffsetPixels, nBands, pabySrc,

                                 padfNodataValues, pImage);

        }

        break;

        case GDT_UInt32:

        {

            FillOutBuffer<GUInt32>(nBlockOffsetPixels, nBands, pabySrc,

                                   padfNodataValues, pImage);

        }

        break;

        case GDT_Int32:

        {

            FillOutBuffer<GInt32>(nBlockOffsetPixels, nBands, pabySrc,

                                  padfNodataValues, pImage);

        }

        break;

        case GDT_Float32:

        {

            FillOutBuffer<float>(nBlockOffsetPixels, nBands, pabySrc,

                                 padfNodataValues, pImage);

        }

        break;

        case GDT_Float64:

        {

            FillOutBuffer<double>(nBlockOffsetPixels, nBands, pabySrc,

                                  padfNodataValues, pImage);

        }

        break;

        default:

            CPLAssert(false);

            break;

    }

    CPLFree(pabySrc);

    return CE_None;

}

/************************************************************************/

/*                   EmitErrorMessageIfWriteNotSupported()              */

/************************************************************************/

bool GDALNoDataValuesMaskBand::EmitErrorMessageIfWriteNotSupported(

    const char *pszCaller) const

{

    ReportError(CE_Failure, CPLE_NoWriteAccess,

                "%s: attempt to write to a nodata implicit mask band.",

                pszCaller);

    return true;

}

//! @endcond