/******************************************************************************
 * $Id$
 *
 * Project:  GDAL High Performance Warper
 * Purpose:  Prototypes, and definitions for warping related work.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 2003, Frank Warmerdam
 * Copyright (c) 2009-2012, Even Rouault <even dot rouault at spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/

#ifndef GDALWARPER_H_INCLUDED
#define GDALWARPER_H_INCLUDED

/**
 * \file gdalwarper.h
 *
 * GDAL warper related entry points and definitions.  Eventually it is
 * expected that this file will be mostly private to the implementation,
 * and the public C entry points will be available in gdal_alg.h.
 */

#include "gdal_alg.h"
#include "cpl_minixml.h"
#include "cpl_multiproc.h"

CPL_C_START

/* Note: values are selected to be consistent with GDALRIOResampleAlg of
 * gcore/gdal.h */
/*! Warp Resampling Algorithm */
typedef enum
{
    /*! Nearest neighbour (select on one input pixel) */ GRA_NearestNeighbour =
        0,
    /*! Bilinear (2x2 kernel) */ GRA_Bilinear = 1,
    /*! Cubic Convolution Approximation (4x4 kernel) */ GRA_Cubic = 2,
    /*! Cubic B-Spline Approximation (4x4 kernel) */ GRA_CubicSpline = 3,
    /*! Lanczos windowed sinc interpolation (6x6 kernel) */ GRA_Lanczos = 4,
    /*! Average (computes the weighted average of all non-NODATA contributing
       pixels) */
    GRA_Average = 5,
    /*! Mode (selects the value which appears most often of all the sampled
       points) */
    GRA_Mode = 6,
    /*  GRA_Gauss=7 reserved. */
    /*! Max (selects maximum of all non-NODATA contributing pixels) */ GRA_Max =
        8,
    /*! Min (selects minimum of all non-NODATA contributing pixels) */ GRA_Min =
        9,
    /*! Med (selects median of all non-NODATA contributing pixels) */ GRA_Med =
        10,
    /*! Q1 (selects first quartile of all non-NODATA contributing pixels) */
    GRA_Q1 = 11,
    /*! Q3 (selects third quartile of all non-NODATA contributing pixels) */
    GRA_Q3 = 12,
    /*! Sum (weighed sum of all non-NODATA contributing pixels). Added in
       GDAL 3.1 */
    GRA_Sum = 13,
    /*! RMS (weighted root mean square (quadratic mean) of all non-NODATA
       contributing pixels) */
    GRA_RMS = 14,
    /*! @cond Doxygen_Suppress */
    GRA_LAST_VALUE = GRA_RMS
    /*! @endcond */
} GDALResampleAlg;

/*! @cond Doxygen_Suppress */
typedef int (*GDALMaskFunc)(void *pMaskFuncArg, int nBandCount,
                            GDALDataType eType, int nXOff, int nYOff,
                            int nXSize, int nYSize, GByte **papabyImageData,
                            int bMaskIsFloat, void *pMask);

CPLErr CPL_DLL GDALWarpNoDataMasker(void *pMaskFuncArg, int nBandCount,
                                    GDALDataType eType, int nXOff, int nYOff,
                                    int nXSize, int nYSize,
                                    GByte **papabyImageData, int bMaskIsFloat,
                                    void *pValidityMask, int *pbOutAllValid);

CPLErr CPL_DLL GDALWarpDstAlphaMasker(void *pMaskFuncArg, int nBandCount,
                                      GDALDataType eType, int nXOff, int nYOff,
                                      int nXSize, int nYSize,
                                      GByte ** /*ppImageData */,
                                      int bMaskIsFloat, void *pValidityMask);
CPLErr CPL_DLL GDALWarpSrcAlphaMasker(void *pMaskFuncArg, int nBandCount,
                                      GDALDataType eType, int nXOff, int nYOff,
                                      int nXSize, int nYSize,
                                      GByte ** /*ppImageData */,
                                      int bMaskIsFloat, void *pValidityMask,
                                      int *pbOutAllOpaque);

CPLErr CPL_DLL GDALWarpSrcMaskMasker(void *pMaskFuncArg, int nBandCount,
                                     GDALDataType eType, int nXOff, int nYOff,
                                     int nXSize, int nYSize,
                                     GByte ** /*ppImageData */,
                                     int bMaskIsFloat, void *pValidityMask);

CPLErr CPL_DLL GDALWarpCutlineMasker(void *pMaskFuncArg, int nBandCount,
                                     GDALDataType eType, int nXOff, int nYOff,
                                     int nXSize, int nYSize,
                                     GByte ** /* ppImageData */,
                                     int bMaskIsFloat, void *pValidityMask);

/* GCMVF stands for GDALWARP_CUTLINE_MASKER_VALIDITY_FLAG */
#define GCMVF_PARTIAL_INTERSECTION 0
#define GCMVF_NO_INTERSECTION 1
#define GCMVF_CHUNK_FULLY_WITHIN_CUTLINE 2
CPLErr CPL_DLL GDALWarpCutlineMaskerEx(void *pMaskFuncArg, int nBandCount,
                                       GDALDataType eType, int nXOff, int nYOff,
                                       int nXSize, int nYSize,
                                       GByte ** /* ppImageData */,
                                       int bMaskIsFloat, void *pValidityMask,
                                       int *pnValidityFlag);

/*! @endcond */

/*! GWKMode tie-breaking strategy */
typedef enum
{
    /* Choose the first value encountered */ GWKTS_First = 1,
    /* Choose the minimal value */ GWKTS_Min = 2,
    /* Choose the maximum value */ GWKTS_Max = 3,
} GWKTieStrategy;

/************************************************************************/
/*                           GDALWarpOptions                            */
/************************************************************************/

/** Warp control options for use with GDALWarpOperation::Initialize()  */
typedef struct
{

    char **papszWarpOptions;

    /*! In bytes, 0.0 for internal default */
    double dfWarpMemoryLimit;

    /*! Resampling algorithm to use */
    GDALResampleAlg eResampleAlg;

    /*! data type to use during warp operation, GDT_Unknown lets the algorithm
        select the type */
    GDALDataType eWorkingDataType;

    /*! Source image dataset. */
    GDALDatasetH hSrcDS;

    /*! Destination image dataset - may be NULL if only using
     * GDALWarpOperation::WarpRegionToBuffer(). */
    GDALDatasetH hDstDS;

    /*! Number of bands to process, may be 0 to select all bands. */
    int nBandCount;

    /*! The band numbers for the source bands to process (1 based) */
    int *panSrcBands;

    /*! The band numbers for the destination bands to process (1 based) */
    int *panDstBands;

    /*! The source band so use as an alpha (transparency) value, 0=disabled */
    int nSrcAlphaBand;

    /*! The dest. band so use as an alpha (transparency) value, 0=disabled */
    int nDstAlphaBand;

    /*! The "nodata" value real component for each input band, if NULL there
     * isn't one */
    double *padfSrcNoDataReal;
    /*! The "nodata" value imaginary component - may be NULL even if real
      component is provided. This value is not used to flag invalid values.
      Only the real component is used. */
    double *padfSrcNoDataImag;

    /*! The "nodata" value real component for each output band, if NULL there
     * isn't one */
    double *padfDstNoDataReal;
    /*! The "nodata" value imaginary component - may be NULL even if real
      component is provided. Note that warp operations only use real component
      for flagging invalid data.*/
    double *padfDstNoDataImag;

    /*! GDALProgressFunc() compatible progress reporting function, or NULL
      if there isn't one. */
    GDALProgressFunc pfnProgress;

    /*! Callback argument to be passed to pfnProgress. */
    void *pProgressArg;

    /*! Type of spatial point transformer function */
    GDALTransformerFunc pfnTransformer;

    /*! Handle to image transformer setup structure */
    void *pTransformerArg;

    /** Unused. Must be NULL */
    GDALMaskFunc *papfnSrcPerBandValidityMaskFunc;
    /** Unused. Must be NULL */
    void **papSrcPerBandValidityMaskFuncArg;

    /** Unused. Must be NULL */
    GDALMaskFunc pfnSrcValidityMaskFunc;
    /** Unused. Must be NULL */
    void *pSrcValidityMaskFuncArg;

    /** Unused. Must be NULL */
    GDALMaskFunc pfnSrcDensityMaskFunc;
    /** Unused. Must be NULL */
    void *pSrcDensityMaskFuncArg;

    /** Unused. Must be NULL */
    GDALMaskFunc pfnDstDensityMaskFunc;
    /** Unused. Must be NULL */
    void *pDstDensityMaskFuncArg;

    /** Unused. Must be NULL */
    GDALMaskFunc pfnDstValidityMaskFunc;
    /** Unused. Must be NULL */
    void *pDstValidityMaskFuncArg;

    /** Unused. Must be NULL */
    CPLErr (*pfnPreWarpChunkProcessor)(void *pKern, void *pArg);
    /** Unused. Must be NULL */
    void *pPreWarpProcessorArg;

    /** Unused. Must be NULL */
    CPLErr (*pfnPostWarpChunkProcessor)(void *pKern, void *pArg);
    /** Unused. Must be NULL */
    void *pPostWarpProcessorArg;

    /*! Optional OGRPolygonH for a masking cutline. */
    void *hCutline;

    /*! Optional blending distance to apply across cutline in pixels, default is
     * zero. */
    double dfCutlineBlendDist;

    /** Tie-breaking method */
    GWKTieStrategy eTieStrategy;
} GDALWarpOptions;

const char CPL_DLL *GDALWarpGetOptionList(void);

GDALWarpOptions CPL_DLL *CPL_STDCALL GDALCreateWarpOptions(void);
void CPL_DLL CPL_STDCALL GDALDestroyWarpOptions(GDALWarpOptions *);
GDALWarpOptions CPL_DLL *CPL_STDCALL
GDALCloneWarpOptions(const GDALWarpOptions *);

void CPL_DLL CPL_STDCALL GDALWarpInitDstNoDataReal(GDALWarpOptions *,
                                                   double dNoDataReal);

void CPL_DLL CPL_STDCALL GDALWarpInitSrcNoDataReal(GDALWarpOptions *,
                                                   double dNoDataReal);

void CPL_DLL CPL_STDCALL GDALWarpInitNoDataReal(GDALWarpOptions *,
                                                double dNoDataReal);

void CPL_DLL CPL_STDCALL GDALWarpInitDstNoDataImag(GDALWarpOptions *,
                                                   double dNoDataImag);

void CPL_DLL CPL_STDCALL GDALWarpInitSrcNoDataImag(GDALWarpOptions *,
                                                   double dNoDataImag);

void CPL_DLL CPL_STDCALL GDALWarpResolveWorkingDataType(GDALWarpOptions *);

void CPL_DLL CPL_STDCALL GDALWarpInitDefaultBandMapping(GDALWarpOptions *,
                                                        int nBandCount);

/*! @cond Doxygen_Suppress */
CPLXMLNode CPL_DLL *CPL_STDCALL
GDALSerializeWarpOptions(const GDALWarpOptions *);
GDALWarpOptions CPL_DLL *CPL_STDCALL GDALDeserializeWarpOptions(CPLXMLNode *);
/*! @endcond */

/************************************************************************/
/*                         GDALReprojectImage()                         */
/************************************************************************/

CPLErr CPL_DLL CPL_STDCALL GDALReprojectImage(
    GDALDatasetH hSrcDS, const char *pszSrcWKT, GDALDatasetH hDstDS,
    const char *pszDstWKT, GDALResampleAlg eResampleAlg,
    double dfWarpMemoryLimit, double dfMaxError, GDALProgressFunc pfnProgress,
    void *pProgressArg, GDALWarpOptions *psOptions);

CPLErr CPL_DLL CPL_STDCALL GDALCreateAndReprojectImage(
    GDALDatasetH hSrcDS, const char *pszSrcWKT, const char *pszDstFilename,
    const char *pszDstWKT, GDALDriverH hDstDriver, char **papszCreateOptions,
    GDALResampleAlg eResampleAlg, double dfWarpMemoryLimit, double dfMaxError,
    GDALProgressFunc pfnProgress, void *pProgressArg,
    GDALWarpOptions *psOptions);

/************************************************************************/
/*                           VRTWarpedDataset                           */
/************************************************************************/

GDALDatasetH CPL_DLL CPL_STDCALL
GDALAutoCreateWarpedVRT(GDALDatasetH hSrcDS, const char *pszSrcWKT,
                        const char *pszDstWKT, GDALResampleAlg eResampleAlg,
                        double dfMaxError, const GDALWarpOptions *psOptions);

GDALDatasetH CPL_DLL CPL_STDCALL GDALAutoCreateWarpedVRTEx(
    GDALDatasetH hSrcDS, const char *pszSrcWKT, const char *pszDstWKT,
    GDALResampleAlg eResampleAlg, double dfMaxError,
    const GDALWarpOptions *psOptions, CSLConstList papszTransformerOptions);

GDALDatasetH CPL_DLL CPL_STDCALL
GDALCreateWarpedVRT(GDALDatasetH hSrcDS, int nPixels, int nLines,
                    const double *padfGeoTransform, GDALWarpOptions *psOptions);

CPLErr CPL_DLL CPL_STDCALL GDALInitializeWarpedVRT(GDALDatasetH hDS,
                                                   GDALWarpOptions *psWO);

CPL_C_END

#if defined(__cplusplus) && !defined(CPL_SUPRESS_CPLUSPLUS)

#include <vector>
#include <utility>

bool GDALGetWarpResampleAlg(const char *pszResampling,
                            GDALResampleAlg &eResampleAlg, bool bThrow = false);

/************************************************************************/
/*                            GDALWarpKernel                            */
/*                                                                      */

/** This is the number of dummy pixels that must be reserved in source arrays
 * in order to satisfy assumptions made in GWKResample(), and more specifically
 * by GWKGetPixelRow() that always read a even number of pixels. So if we are
 * in the situation to read the last pixel of the source array, we need 1 extra
 * dummy pixel to avoid reading out of bounds. */
#define WARP_EXTRA_ELTS 1

/** This class represents the lowest level of abstraction of warping.
 *
 * It holds the imagery for one "chunk" of a warp, and the
 * pre-prepared masks.  All IO is done before and after its
 * operation.  This class is not normally used by the
 * application.
 */
class CPL_DLL GDALWarpKernel
{
    CPL_DISALLOW_COPY_ASSIGN(GDALWarpKernel)

  public:
    /** Warp options */
    char **papszWarpOptions;

    /** Resample algorithm */
    GDALResampleAlg eResample;
    /** Working data type */
    GDALDataType eWorkingDataType;
    /** Number of input and output bands (excluding alpha bands) */
    int nBands;

    /** Width of the source image */
    int nSrcXSize;
    /** Height of the source image */
    int nSrcYSize;
    /** Extra pixels (included in nSrcXSize) reserved for filter window. Should
     * be ignored in scale computation */
    double dfSrcXExtraSize;
    /** Extra pixels (included in nSrcYSize) reserved for filter window. Should
     * be ignored in scale computation */
    double dfSrcYExtraSize;
    /** Array of nBands source images of size nSrcXSize * nSrcYSize. Each
     * subarray must have WARP_EXTRA_ELTS at the end */
    GByte **papabySrcImage;

    /** Array of nBands validity mask of size (nSrcXSize * nSrcYSize +
     * WARP_EXTRA_ELTS) / 8 */
    GUInt32 **papanBandSrcValid;
    /** Unified validity mask of size (nSrcXSize * nSrcYSize + WARP_EXTRA_ELTS)
     * / 8 */
    GUInt32 *panUnifiedSrcValid;
    /** Unified source density of size nSrcXSize * nSrcYSize + WARP_EXTRA_ELTS
     */
    float *pafUnifiedSrcDensity;

    /** Width of the destination image */
    int nDstXSize;
    /** Height of the destination image */
    int nDstYSize;
    /** Array of nBands destination images of size nDstXSize * nDstYSize */
    GByte **papabyDstImage;
    /** Validify mask of size (nDstXSize * nDstYSize) / 8 */
    GUInt32 *panDstValid;
    /** Destination density of size nDstXSize * nDstYSize */
    float *pafDstDensity;

    /** X resampling scale, i.e. nDstXSize / nSrcXSize */
    double dfXScale;
    /** Y resampling scale, i.e. nDstYSize / nSrcYSize */
    double dfYScale;
    /** X size of filter kernel */
    double dfXFilter;
    /** Y size of filter kernel */
    double dfYFilter;
    /** X size of window to filter */
    int nXRadius;
    /** Y size of window to filter */
    int nYRadius;
    /** X filtering offset */
    int nFiltInitX;
    /** Y filtering offset */
    int nFiltInitY;

    /** X offset of the source buffer regarding the top-left corner of the image
     */
    int nSrcXOff;
    /** Y offset of the source buffer regarding the top-left corner of the image
     */
    int nSrcYOff;

    /** X offset of the destination buffer regarding the top-left corner of the
     * image */
    int nDstXOff;
    /** Y offset of the destination buffer regarding the top-left corner of the
     * image */
    int nDstYOff;

    /** Pixel transformation function */
    GDALTransformerFunc pfnTransformer;
    /** User data provided to pfnTransformer */
    void *pTransformerArg;

    /** Progress function */
    GDALProgressFunc pfnProgress;
    /** User data provided to pfnProgress */
    void *pProgress;

    /** Base/offset value for progress computation */
    double dfProgressBase;
    /** Scale value for progress computation */
    double dfProgressScale;

    /** Array of nBands value for destination nodata */
    double *padfDstNoDataReal;

    /*! @cond Doxygen_Suppress */
    /** Per-thread data. Internally set */
    void *psThreadData;

    bool bApplyVerticalShift = false;

    double dfMultFactorVerticalShift = 1.0;

    // Tuples of values (e.g. "<R>,<G>,<B>" or "(<R1>,<G1>,<B1>),(<R2>,<G2>,<B2>)") that must
    // be ignored as contributing source pixels during resampling. Only taken into account by
    // Average currently
    std::vector<std::vector<double>> m_aadfExcludedValues{};

    GWKTieStrategy eTieStrategy;

    bool bWarnedAboutDstNoDataReplacement = false;

    /*! @endcond */

    GDALWarpKernel();
    ~GDALWarpKernel();

    CPLErr Validate();
    CPLErr PerformWarp();
};

/*! @cond Doxygen_Suppress */
void *GWKThreadsCreate(char **papszWarpOptions,
                       GDALTransformerFunc pfnTransformer,
                       void *pTransformerArg);
void GWKThreadsEnd(void *psThreadDataIn);
/*! @endcond */

/************************************************************************/
/*                         GDALWarpOperation()                          */
/*                                                                      */
/*      This object is application created, or created by a higher      */
/*      level convenience function.  It is responsible for              */
/*      subdividing the operation into chunks, loading and saving       */
/*      imagery, and establishing the various validity and density      */
/*      masks.  Actual resampling is done by the GDALWarpKernel.        */
/************************************************************************/

/*! @cond Doxygen_Suppress */
typedef struct _GDALWarpChunk GDALWarpChunk;

struct GDALTransformerUniquePtrReleaser
{
    void operator()(void *p)
    {
        GDALDestroyTransformer(p);
    }
};

/*! @endcond */

/** Unique pointer for the argument of a GDALTransformerFunc */
using GDALTransformerArgUniquePtr =
    std::unique_ptr<void, GDALTransformerUniquePtrReleaser>;

class CPL_DLL GDALWarpOperation final
{

    CPL_DISALLOW_COPY_ASSIGN(GDALWarpOperation)

  private:
    GDALWarpOptions *psOptions = nullptr;
    GDALTransformerArgUniquePtr m_psOwnedTransformerArg{nullptr};

    void WipeOptions();
    int ValidateOptions();

    bool ComputeSourceWindowTransformPoints(
        int nDstXOff, int nDstYOff, int nDstXSize, int nDstYSize, bool bUseGrid,
        bool bAll, int nStepCount, bool bTryWithCheckWithInvertProj,
        double &dfMinXOut, double &dfMinYOut, double &dfMaxXOut,
        double &dfMaxYOut, int &nSamplePoints, int &nFailedCount);

    void ComputeSourceWindowStartingFromSource(int nDstXOff, int nDstYOff,
                                               int nDstXSize, int nDstYSize,
                                               double *padfSrcMinX,
                                               double *padfSrcMinY,
                                               double *padfSrcMaxX,
                                               double *padfSrcMaxY);

    static CPLErr CreateKernelMask(GDALWarpKernel *, int iBand,
                                   const char *pszType);

    CPLMutex *hIOMutex = nullptr;
    CPLMutex *hWarpMutex = nullptr;

    int nChunkListCount = 0;
    int nChunkListMax = 0;
    GDALWarpChunk *pasChunkList = nullptr;

    bool bReportTimings = false;
    unsigned long nLastTimeReported = 0;

    void *psThreadData = nullptr;

    // Coordinates a few special points in target image space, to determine
    // if ComputeSourceWindow() must use a grid based sampling.
    std::vector<std::pair<double, double>> aDstXYSpecialPoints{};

    bool m_bIsTranslationOnPixelBoundaries = false;

    void WipeChunkList();
    CPLErr CollectChunkListInternal(int nDstXOff, int nDstYOff, int nDstXSize,
                                    int nDstYSize);
    void CollectChunkList(int nDstXOff, int nDstYOff, int nDstXSize,
                          int nDstYSize);
    void ReportTiming(const char *);

  public:
    GDALWarpOperation();
    ~GDALWarpOperation();

    CPLErr Initialize(const GDALWarpOptions *psNewOptions,
                      GDALTransformerFunc pfnTransformer = nullptr,
                      GDALTransformerArgUniquePtr psOwnedTransformerArg =
                          GDALTransformerArgUniquePtr{nullptr});
    void *CreateDestinationBuffer(int nDstXSize, int nDstYSize,
                                  int *pbWasInitialized = nullptr);
    CPLErr InitializeDestinationBuffer(void *pDstBuffer, int nDstXSize,
                                       int nDstYSize,
                                       int *pbWasInitialized = nullptr) const;
    static void DestroyDestinationBuffer(void *pDstBuffer);

    const GDALWarpOptions *GetOptions();

    CPLErr ChunkAndWarpImage(int nDstXOff, int nDstYOff, int nDstXSize,
                             int nDstYSize);
    CPLErr ChunkAndWarpMulti(int nDstXOff, int nDstYOff, int nDstXSize,
                             int nDstYSize);
    CPLErr WarpRegion(int nDstXOff, int nDstYOff, int nDstXSize, int nDstYSize,
                      int nSrcXOff = 0, int nSrcYOff = 0, int nSrcXSize = 0,
                      int nSrcYSize = 0, double dfProgressBase = 0.0,
                      double dfProgressScale = 1.0);
    CPLErr WarpRegion(int nDstXOff, int nDstYOff, int nDstXSize, int nDstYSize,
                      int nSrcXOff, int nSrcYOff, int nSrcXSize, int nSrcYSize,
                      double dfSrcXExtraSize, double dfSrcYExtraSize,
                      double dfProgressBase, double dfProgressScale);
    CPLErr WarpRegionToBuffer(int nDstXOff, int nDstYOff, int nDstXSize,
                              int nDstYSize, void *pDataBuf,
                              GDALDataType eBufDataType, int nSrcXOff = 0,
                              int nSrcYOff = 0, int nSrcXSize = 0,
                              int nSrcYSize = 0, double dfProgressBase = 0.0,
                              double dfProgressScale = 1.0);
    CPLErr WarpRegionToBuffer(int nDstXOff, int nDstYOff, int nDstXSize,
                              int nDstYSize, void *pDataBuf,
                              GDALDataType eBufDataType, int nSrcXOff,
                              int nSrcYOff, int nSrcXSize, int nSrcYSize,
                              double dfSrcXExtraSize, double dfSrcYExtraSize,
                              double dfProgressBase, double dfProgressScale);

  protected:
    friend class VRTWarpedDataset;
    CPLErr ComputeSourceWindow(int nDstXOff, int nDstYOff, int nDstXSize,
                               int nDstYSize, int *pnSrcXOff, int *pnSrcYOff,
                               int *pnSrcXSize, int *pnSrcYSize,
                               double *pdfSrcXExtraSize,
                               double *pdfSrcYExtraSize,
                               double *pdfSrcFillRatio);

    double GetWorkingMemoryForWindow(int nSrcXSize, int nSrcYSize,
                                     int nDstXSize, int nDstYSize) const;
};

#endif /* def __cplusplus */

CPL_C_START

/** Opaque type representing a GDALWarpOperation object */
typedef void *GDALWarpOperationH;

GDALWarpOperationH CPL_DLL GDALCreateWarpOperation(const GDALWarpOptions *);
void CPL_DLL GDALDestroyWarpOperation(GDALWarpOperationH);
CPLErr CPL_DLL GDALChunkAndWarpImage(GDALWarpOperationH, int, int, int, int);
CPLErr CPL_DLL GDALChunkAndWarpMulti(GDALWarpOperationH, int, int, int, int);
CPLErr CPL_DLL GDALWarpRegion(GDALWarpOperationH, int, int, int, int, int, int,
                              int, int);
CPLErr CPL_DLL GDALWarpRegionToBuffer(GDALWarpOperationH, int, int, int, int,
                                      void *, GDALDataType, int, int, int, int);

/************************************************************************/
/*                       Warping kernel functions                       */
/************************************************************************/

/*! @cond Doxygen_Suppress */
int GWKGetFilterRadius(GDALResampleAlg eResampleAlg);

typedef double (*FilterFuncType)(double dfX);
FilterFuncType GWKGetFilterFunc(GDALResampleAlg eResampleAlg);

// TODO(schwehr): Can padfVals be a const pointer?
typedef double (*FilterFunc4ValuesType)(double *padfVals);
FilterFunc4ValuesType GWKGetFilterFunc4Values(GDALResampleAlg eResampleAlg);
/*! @endcond */

CPL_C_END

#endif /* ndef GDAL_ALG_H_INCLUDED */
