{

static_assert(CPL_ARRAYSIZE(anGWKFilterRadius) == GRA_LAST_VALUE + 1,

"Bad size of anGWKFilterRadius");

return anGWKFilterRadius[eResampleAlg];

{

static_assert(CPL_ARRAYSIZE(apfGWKFilter) == GRA_LAST_VALUE + 1,

"Bad size of apfGWKFilter");

return apfGWKFilter[eResampleAlg];

{

static_assert(CPL_ARRAYSIZE(apfGWKFilter4Values) == GRA_LAST_VALUE + 1,

"Bad size of apfGWKFilter4Values");

return apfGWKFilter4Values[eResampleAlg];

{

std::mutex &mutex;

std::condition_variable &cv;

int &counter;

bool &stopFlag;

GDALWarpKernel *poWK;

int iYMin;

int iYMax;

int (*pfnProgress)(GWKJobStruct *psJob);

void *pTransformerArg;

void (*pfnFunc)(

void *); // used by GWKRun() to assign the proper pTransformerArg

GWKJobStruct(std::mutex &mutex_, std::condition_variable &cv_,

int &counter_, bool &stopFlag_)

: mutex(mutex_), cv(cv_), counter(counter_), stopFlag(stopFlag_),

poWK(nullptr), iYMin(0), iYMax(0), pfnProgress(nullptr),

pTransformerArg(nullptr), pfnFunc(nullptr)

{

}

{

std::unique_ptr<CPLJobQueue> poJobQueue{};

std::unique_ptr<std::vector<GWKJobStruct>> threadJobs{};

int nMaxThreads{0};

int counter{0};

bool stopFlag{false};

std::mutex mutex{};

std::condition_variable cv{};

bool bTransformerArgInputAssignedToThread{false};

void *pTransformerArgInput{

nullptr}; // owned by calling layer. Not to be destroyed

std::map<GIntBig, void *> mapThreadToTransformerArg{};

int nTotalThreadCountForThisRun = 0;

int nCurThreadCountForThisRun = 0;

{

bool stop = false;

{

std::lock_guard<std::mutex> lock(psJob->mutex);

psJob->counter++;

stop = psJob->stopFlag;

}

psJob->cv.notify_one();

return stop;

{

GDALWarpKernel *poWK = psJob->poWK;

if (!poWK->pfnProgress(

poWK->dfProgressBase +

poWK->dfProgressScale *

(++psJob->counter / static_cast<double>(psJob->iYMax)),

"", poWK->pProgress))

{

CPLError(CE_Failure, CPLE_UserInterrupt, "User terminated");

psJob->stopFlag = true;

return TRUE;

}

return FALSE;

void (*pfnFunc)(void *pUserData))

{

GWKThreadData td;

// NOTE: the mutex is not used.

GWKJobStruct job(td.mutex, td.cv, td.counter, td.stopFlag);

job.poWK = poWK;

job.iYMin = 0;

job.iYMax = poWK->nDstYSize;

job.pfnProgress = GWKProgressMonoThread;

job.pTransformerArg = poWK->pTransformerArg;

pfnFunc(&job);

return td.stopFlag ? CE_Failure : CE_None;

{

if (psThreadDataIn == nullptr)

return;

GWKThreadData *psThreadData = static_cast<GWKThreadData *>(psThreadDataIn);

if (psThreadData->poJobQueue)

{

for (auto &pair : psThreadData->mapThreadToTransformerArg)

{

CPLAssert(pair.second != psThreadData->pTransformerArgInput);

GDALDestroyTransformer(pair.second);

}

psThreadData->poJobQueue.reset();

}

delete psThreadData;

{

GWKJobStruct *psJob = static_cast<GWKJobStruct *>(pData);

GWKThreadData *psThreadData =

static_cast<GWKThreadData *>(psJob->poWK->psThreadData);

// Look if we have already a per-thread transformer

void *pTransformerArg = nullptr;

const GIntBig nThreadId = CPLGetPID();

{

std::lock_guard<std::mutex> lock(psThreadData->mutex);

++psThreadData->nCurThreadCountForThisRun;

auto oIter = psThreadData->mapThreadToTransformerArg.find(nThreadId);

if (oIter != psThreadData->mapThreadToTransformerArg.end())

{

pTransformerArg = oIter->second;

}

else if (!psThreadData->bTransformerArgInputAssignedToThread &&

psThreadData->nCurThreadCountForThisRun ==

psThreadData->nTotalThreadCountForThisRun)

{

// If we are the last thread to be started, temporarily borrow the

// original transformer

psThreadData->bTransformerArgInputAssignedToThread = true;

pTransformerArg = psThreadData->pTransformerArgInput;

psThreadData->mapThreadToTransformerArg[nThreadId] =

pTransformerArg;

}

if (pTransformerArg == nullptr)

{

CPLAssert(psThreadData->pTransformerArgInput != nullptr);

CPLAssert(!psThreadData->bTransformerArgInputAssignedToThread);

}

}

// If no transformer assigned to current thread, instantiate one

if (pTransformerArg == nullptr)

{

// This somehow assumes that GDALCloneTransformer() is thread-safe

// which should normally be the case.

pTransformerArg =

GDALCloneTransformer(psThreadData->pTransformerArgInput);

// Lock for the stop flag and the transformer map.

std::lock_guard<std::mutex> lock(psThreadData->mutex);

if (!pTransformerArg)

{

psJob->stopFlag = true;

return;

}

psThreadData->mapThreadToTransformerArg[nThreadId] = pTransformerArg;

}

psJob->pTransformerArg = pTransformerArg;

psJob->pfnFunc(pData);

// Give back original transformer, if borrowed.

{

std::lock_guard<std::mutex> lock(psThreadData->mutex);

if (psThreadData->bTransformerArgInputAssignedToThread &&

pTransformerArg == psThreadData->pTransformerArgInput)

{

psThreadData->mapThreadToTransformerArg.erase(

psThreadData->mapThreadToTransformerArg.find(nThreadId));

psThreadData->bTransformerArgInputAssignedToThread = false;

}

}

void (*pfnFunc)(void *pUserData))

{

const int nDstYSize = poWK->nDstYSize;

CPLDebug("GDAL",

"GDALWarpKernel()::%s() "

"Src=%d,%d,%dx%d Dst=%d,%d,%dx%d",

pszFuncName, poWK->nSrcXOff, poWK->nSrcYOff, poWK->nSrcXSize,

poWK->nSrcYSize, poWK->nDstXOff, poWK->nDstYOff, poWK->nDstXSize,

poWK->nDstYSize);

if (!poWK->pfnProgress(poWK->dfProgressBase, "", poWK->pProgress))

{

CPLError(CE_Failure, CPLE_UserInterrupt, "User terminated");

return CE_Failure;

}

GWKThreadData *psThreadData =

static_cast<GWKThreadData *>(poWK->psThreadData);

if (psThreadData == nullptr || psThreadData->poJobQueue == nullptr)

{

return GWKGenericMonoThread(poWK, pfnFunc);

}

int nThreads = std::min(psThreadData->nMaxThreads, nDstYSize / 2);

// Config option mostly useful for tests to be able to test multithreading

// with small rasters

const int nWarpChunkSize =

atoi(CPLGetConfigOption("WARP_THREAD_CHUNK_SIZE", "65536"));

if (nWarpChunkSize > 0)

{

GIntBig nChunks =

static_cast<GIntBig>(nDstYSize) * poWK->nDstXSize / nWarpChunkSize;

if (nThreads > nChunks)

nThreads = static_cast<int>(nChunks);

}

if (nThreads <= 0)

nThreads = 1;

CPLDebug("WARP", "Using %d threads", nThreads);

auto &jobs = *psThreadData->threadJobs;

CPLAssert(static_cast<int>(jobs.size()) >= nThreads);

// Fill-in job structures.

for (int i = 0; i < nThreads; ++i)

{

auto &job = jobs[i];

job.poWK = poWK;

job.iYMin =

static_cast<int>(static_cast<int64_t>(i) * nDstYSize / nThreads);

job.iYMax = static_cast<int>(static_cast<int64_t>(i + 1) * nDstYSize /

nThreads);

if (poWK->pfnProgress != GDALDummyProgress)

job.pfnProgress = GWKProgressThread;

job.pfnFunc = pfnFunc;

}

{

std::unique_lock<std::mutex> lock(psThreadData->mutex);

psThreadData->nTotalThreadCountForThisRun = nThreads;

// coverity[missing_lock]

psThreadData->nCurThreadCountForThisRun = 0;

// Start jobs.

for (int i = 0; i < nThreads; ++i)

{

auto &job = jobs[i];

psThreadData->poJobQueue->SubmitJob(ThreadFuncAdapter,

static_cast<void *>(&job));

}

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

*/

/* Report progress. */

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

*/

if (poWK->pfnProgress != GDALDummyProgress)

{

int &counter = psThreadData->counter;

while (counter < nDstYSize)

{

psThreadData->cv.wait(lock);

if (!poWK->pfnProgress(

poWK->dfProgressBase +

poWK->dfProgressScale *

(counter / static_cast<double>(nDstYSize)),

"", poWK->pProgress))

{

CPLError(CE_Failure, CPLE_UserInterrupt, "User terminated");

psThreadData->stopFlag = true;

break;

}

}

}

}

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

/* Wait for all jobs to complete. */

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

psThreadData->poJobQueue->WaitCompletion();

return psThreadData->stopFlag ? CE_Failure : CE_None;

: papszWarpOptions(nullptr), eResample(GRA_NearestNeighbour),

eWorkingDataType(GDT_Unknown), nBands(0), nSrcXSize(0), nSrcYSize(0),

dfSrcXExtraSize(0.0), dfSrcYExtraSize(0.0), papabySrcImage(nullptr),

papanBandSrcValid(nullptr), panUnifiedSrcValid(nullptr),

pafUnifiedSrcDensity(nullptr), nDstXSize(0), nDstYSize(0),

papabyDstImage(nullptr), panDstValid(nullptr), pafDstDensity(nullptr),

dfXScale(1.0), dfYScale(1.0), dfXFilter(0.0), dfYFilter(0.0), nXRadius(0),

nYRadius(0), nFiltInitX(0), nFiltInitY(0), nSrcXOff(0), nSrcYOff(0),

nDstXOff(0), nDstYOff(0), pfnTransformer(nullptr),

pTransformerArg(nullptr), pfnProgress(GDALDummyProgress),

pProgress(nullptr), dfProgressBase(0.0), dfProgressScale(1.0),

padfDstNoDataReal(nullptr), psThreadData(nullptr)

{