//=====================================================================
// Copyright (c) 2007-2016    Advanced Micro Devices, Inc. All rights reserved.
// Copyright (c) 2004-2006    ATI Technologies Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
/// \file Compressonator.h
//
//=====================================================================

#ifndef COMPRESSONATOR_H
#define COMPRESSONATOR_H

#include <stdint.h>
#include <vector>
#include <stddef.h>

#include "../UseDefinitions.h"

#ifndef ASPM_GPU
namespace CMP {
// Basic types.
typedef uint8_t  BYTE;
typedef uint16_t WORD;
typedef uint32_t DWORD;
typedef int32_t  LONG;
typedef bool          BOOL;
#ifdef _LINUX
typedef int32_t*      DWORD_PTR;
#else
typedef size_t        DWORD_PTR;
#endif
typedef unsigned int  UINT;

}  // namespace CMP

typedef CMP::DWORD              CMP_DWORD;  ///< A 32-bit unsigned integer format.
typedef CMP::WORD               CMP_WORD;   ///< A 16-bit unsigned integer format.
typedef CMP::BOOL               CMP_BOOL;  ///< A 32-bit integer boolean format.
typedef CMP::DWORD_PTR          CMP_DWORD_PTR;
typedef CMP::BYTE               CMP_BYTE;   ///< An 8-bit unsigned integer format.
typedef char                    CMP_CHAR;   ///< An 8-bit signed   char    format.
typedef float                   CMP_FLOAT;  ///< A 32-bit signed   float   format.
typedef short                   CMP_HALFSHORT;   ///< A 16-bit short Half format. This should be unsigned!!
typedef long                    CMP_LONG;
typedef int                     CMP_INT;
typedef unsigned int            CMP_UINT;
typedef double                  CMP_DOUBLE;
typedef void                    CMP_VOID;
typedef std::vector<uint8_t>    CMP_VEC8;

#define AMD_COMPRESS_VERSION_MAJOR 3  ///< The major version number of this release.
#define AMD_COMPRESS_VERSION_MINOR 2  ///< The minor version number of this release.

#if defined(WIN32) || defined(_WIN64)
#define CMP_API __cdecl
#else
#define CMP_API
#endif

// Texture format. 
typedef enum {
    CMP_FORMAT_Unknown   = 0,         // Undefined texture format.

    // Channel Component formats --------------------------------------------------------------------------------
    CMP_FORMAT_ARGB_8888    ,         // ARGB format with 8-bit fixed channels.
    CMP_FORMAT_ABGR_8888    ,         // ABGR format with 8-bit fixed channels.
    CMP_FORMAT_RGBA_8888    ,         // RGBA format with 8-bit fixed channels.
    CMP_FORMAT_BGRA_8888    ,         // BGRA format with 8-bit fixed channels.
    CMP_FORMAT_RGB_888      ,         // RGB format with 8-bit fixed channels.
    CMP_FORMAT_BGR_888      ,         // BGR format with 8-bit fixed channels.
    CMP_FORMAT_RG_8         ,         // Two component format with 8-bit fixed channels.
    CMP_FORMAT_R_8          ,         // Single component format with 8-bit fixed channels.
    CMP_FORMAT_ARGB_2101010 ,         // ARGB format with 10-bit fixed channels for color & a 2-bit fixed channel for alpha.
    CMP_FORMAT_ARGB_16      ,         // ARGB format with 16-bit fixed channels.
    CMP_FORMAT_ABGR_16      ,         // ABGR format with 16-bit fixed channels.
    CMP_FORMAT_RGBA_16      ,         // RGBA format with 16-bit fixed channels.
    CMP_FORMAT_BGRA_16      ,         // BGRA format with 16-bit fixed channels.
    CMP_FORMAT_RG_16        ,         // Two component format with 16-bit fixed channels.
    CMP_FORMAT_R_16         ,         // Single component format with 16-bit fixed channels.
    CMP_FORMAT_RGBE_32F     ,         // RGB format with 9-bit floating point each channel and shared 5 bit exponent
    CMP_FORMAT_ARGB_16F     ,         // ARGB format with 16-bit floating-point channels.
    CMP_FORMAT_ABGR_16F     ,         // ABGR format with 16-bit floating-point channels.
    CMP_FORMAT_RGBA_16F     ,         // RGBA format with 16-bit floating-point channels.
    CMP_FORMAT_BGRA_16F     ,         // BGRA format with 16-bit floating-point channels.
    CMP_FORMAT_RG_16F       ,         // Two component format with 16-bit floating-point channels.
    CMP_FORMAT_R_16F        ,         // Single component with 16-bit floating-point channels.
    CMP_FORMAT_ARGB_32F     ,         // ARGB format with 32-bit floating-point channels.
    CMP_FORMAT_ABGR_32F     ,         // ABGR format with 32-bit floating-point channels.
    CMP_FORMAT_RGBA_32F     ,         // RGBA format with 32-bit floating-point channels.
    CMP_FORMAT_BGRA_32F     ,         // BGRA format with 32-bit floating-point channels.
    CMP_FORMAT_RGB_32F      ,         // RGB format with 32-bit floating-point channels.
    CMP_FORMAT_BGR_32F      ,         // BGR format with 32-bit floating-point channels.
    CMP_FORMAT_RG_32F       ,         // Two component format with 32-bit floating-point channels.
    CMP_FORMAT_R_32F        ,         // Single component with 32-bit floating-point channels.

    // Compression formats -----------------------------------------------------------------------------------
    CMP_FORMAT_ASTC                 , // ASTC (Adaptive Scalable Texture Compression) open texture compression standard
    CMP_FORMAT_ATI1N                , // Single component compression format using the same technique as DXT5 alpha. Four bits per pixel.
    CMP_FORMAT_ATI2N                , // Two component compression format using the same technique as DXT5 alpha. Designed for compression of tangent space normal maps. Eight bits per pixel.
    CMP_FORMAT_ATI2N_XY             , // Two component compression format using the same technique as DXT5 alpha. The same as ATI2N but with the channels swizzled. Eight bits per pixel.
    CMP_FORMAT_ATI2N_DXT5           , // ATI2N like format using DXT5. Intended for use on GPUs that do not natively support ATI2N. Eight bits per pixel.
    CMP_FORMAT_ATC_RGB              , // CMP - a compressed RGB format.
    CMP_FORMAT_ATC_RGBA_Explicit    , // CMP - a compressed ARGB format with explicit alpha.
    CMP_FORMAT_ATC_RGBA_Interpolated, // CMP - a compressed ARGB format with interpolated alpha.
    CMP_FORMAT_BC1                  , // A four component opaque (or 1-bit alpha) compressed texture format for Microsoft DirectX10. Identical to DXT1.  Four bits per pixel.
    CMP_FORMAT_BC2                  , // A four component compressed texture format with explicit alpha for Microsoft DirectX10. Identical to DXT3. Eight bits per pixel.
    CMP_FORMAT_BC3                  , // A four component compressed texture format with interpolated alpha for Microsoft DirectX10. Identical to DXT5. Eight bits per pixel.
    CMP_FORMAT_BC4                  , // A single component compressed texture format for Microsoft DirectX10. Identical to ATI1N. Four bits per pixel.
    CMP_FORMAT_BC5                  , // A two component compressed texture format for Microsoft DirectX10. Identical to ATI2N_XY. Eight bits per pixel.
    CMP_FORMAT_BC6H                 , // BC6H compressed texture format (UF)
    CMP_FORMAT_BC6H_SF              , // BC6H compressed texture format (SF)
    CMP_FORMAT_BC7                  , // BC7  compressed texture format
    CMP_FORMAT_DXT1                 , // An DXTC compressed texture matopaque (or 1-bit alpha). Four bits per pixel.
    CMP_FORMAT_DXT3                 , //   DXTC compressed texture format with explicit alpha. Eight bits per pixel.
    CMP_FORMAT_DXT5                 , //   DXTC compressed texture format with interpolated alpha. Eight bits per pixel.
    CMP_FORMAT_DXT5_xGBR            , // DXT5 with the red component swizzled into the alpha channel. Eight bits per pixel.
    CMP_FORMAT_DXT5_RxBG            , // swizzled DXT5 format with the green component swizzled into the alpha channel. Eight bits per pixel.
    CMP_FORMAT_DXT5_RBxG            , // swizzled DXT5 format with the green component swizzled into the alpha channel & the blue component swizzled into the green channel. Eight bits per pixel.
    CMP_FORMAT_DXT5_xRBG            , // swizzled DXT5 format with the green component swizzled into the alpha channel & the red component swizzled into the green channel. Eight bits per pixel.
    CMP_FORMAT_DXT5_RGxB            , // swizzled DXT5 format with the blue component swizzled into the alpha channel. Eight bits per pixel.
    CMP_FORMAT_DXT5_xGxR            , // two-component swizzled DXT5 format with the red component swizzled into the alpha channel & the green component in the green channel. Eight bits per pixel.
    CMP_FORMAT_ETC_RGB              , // ETC   GL_COMPRESSED_RGB8_ETC2  backward compatible
    CMP_FORMAT_ETC2_RGB             , // ETC2  GL_COMPRESSED_RGB8_ETC2
    CMP_FORMAT_ETC2_SRGB            , // ETC2  GL_COMPRESSED_SRGB8_ETC2
    CMP_FORMAT_ETC2_RGBA            , // ETC2  GL_COMPRESSED_RGBA8_ETC2_EAC
    CMP_FORMAT_ETC2_RGBA1           , // ETC2  GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2
    CMP_FORMAT_ETC2_SRGBA           , // ETC2  GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
    CMP_FORMAT_ETC2_SRGBA1          , // ETC2  GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2
    CMP_FORMAT_PVRTC                ,

    // Transcoder formats - ------------------------------------------------------------
    CMP_FORMAT_GTC                  ,        ///< GTC   Fast Gradient Texture Compressor
    CMP_FORMAT_BASIS                ,      ///< BASIS compression

    // End of list
    CMP_FORMAT_MAX = CMP_FORMAT_BASIS
} CMP_FORMAT;

/// Compress error codes
typedef enum {
    CMP_OK = 0,                            // Ok.
    CMP_ABORTED,                           // The conversion was aborted.
    CMP_ERR_INVALID_SOURCE_TEXTURE,        // The source texture is invalid.
    CMP_ERR_INVALID_DEST_TEXTURE,          // The destination texture is invalid.
    CMP_ERR_UNSUPPORTED_SOURCE_FORMAT,     // The source format is not a supported format.
    CMP_ERR_UNSUPPORTED_DEST_FORMAT,       // The destination format is not a supported format.
    CMP_ERR_UNSUPPORTED_GPU_ASTC_DECODE,   // The gpu hardware is not supported.
    CMP_ERR_UNSUPPORTED_GPU_BASIS_DECODE,  // The gpu hardware is not supported.
    CMP_ERR_SIZE_MISMATCH,                 // The source and destination texture sizes do not match.
    CMP_ERR_UNABLE_TO_INIT_CODEC,          // Compressonator was unable to initialize the codec needed for conversion.
    CMP_ERR_UNABLE_TO_INIT_DECOMPRESSLIB,  // GPU_Decode Lib was unable to initialize the codec needed for decompression .
    CMP_ERR_UNABLE_TO_INIT_COMPUTELIB,     // Compute Lib was unable to initialize the codec needed for compression.
    CMP_ERR_CMP_DESTINATION,               // Error in compressing destination texture
    CMP_ERR_MEM_ALLOC_FOR_MIPSET,          // Memory Error: allocating MIPSet compression level data buffer
    CMP_ERR_UNKNOWN_DESTINATION_FORMAT,    // The destination Codec Type is unknown! In SDK refer to GetCodecType()
    CMP_ERR_FAILED_HOST_SETUP,             // Failed to setup Host for processing
    CMP_ERR_PLUGIN_FILE_NOT_FOUND,         // The required plugin library was not found
    CMP_ERR_UNABLE_TO_LOAD_FILE,           // The requested file was not loaded
    CMP_ERR_UNABLE_TO_CREATE_ENCODER,      // Request to create an encoder failed
    CMP_ERR_UNABLE_TO_LOAD_ENCODER,        // Unable to load an encode library
    CMP_ERR_NOSHADER_CODE_DEFINED,         // No shader code is available for the requested framework
    CMP_ERR_GPU_DOESNOT_SUPPORT_COMPUTE,   // The GPU device selected does not support compute
    CMP_ERR_NOPERFSTATS,                    // No Performance Stats are available
    CMP_ERR_GENERIC                        // An unknown error occurred.
} CMP_ERROR;

//======================================== Interfaces used in v3.2 and higher (Host Libs) ========================================
/// An enum selecting the different GPU driver types.
typedef enum {
    CMP_UNKNOWN = 0,
    CMP_CPU     = 1,   //Use CPU Only, encoders defined CMP_CPUEncode or Compressonator lib will be used
    CMP_HPC     = 2,   //Use CPU High Performance Compute Encoders with SPMD support defined in CMP_CPUEncode)
//#ifdef USE_GPUEncoders
    CMP_GPU     = 3,   //Use GPU Kernel Encoders to compress textures using Default GPU Framework auto set by the codecs been used
    CMP_GPU_OCL = 4,   //Use GPU Kernel Encoders to compress textures using OpenCL Framework
    CMP_GPU_DXC = 5,   //Use GPU Kernel Encoders to compress textures using DirectX Compute Framework
    CMP_GPU_VLK = 6    //Use GPU Kernel Encoders to compress textures using Vulkan Compute Framework
//#endif

} CMP_Compute_type;

struct ComputeOptions {
//public: data settings
    bool force_rebuild;                     ///<Force the GPU host framework to rebuild shaders
//private: data settings: Do not use or set these
    void *plugin_compute;                   ///< Ref to Encoder codec plugin: For Internal use (will be removed!)
};

typedef enum CMPComputeExtensions {
    CMP_COMPUTE_FP16        = 0x0001,       ///< Enable Packed Math Option for GPU
    CMP_COMPUTE_MAX_ENUM    = 0x7FFF
} CMP_ComputeExtensions;

struct KernelPerformanceStats {
    CMP_FLOAT   m_computeShaderElapsedMS;       // Total Elapsed Shader Time to process all the blocks
    CMP_INT     m_num_blocks;                   // Number of Texel (Typically 4x4) blocks
    CMP_FLOAT   m_CmpMTxPerSec;                 // Number of Mega Texels processed per second
};

struct KernelDeviceInfo {
    CMP_CHAR      m_deviceName[256];     // Device name (CPU or GPU)
    CMP_CHAR      m_version[128];        // Kernel pipeline version number (CPU or GPU)
    CMP_INT       m_maxUCores;           // Max Unit device CPU cores or GPU compute units (CU)
                                         // AMD GCN::One compute unit combines 64 shader processors 
                                         // with 4 Texture Mapping units (TMU)
};

struct KernelOptions {
    CMP_ComputeExtensions   Extensions; // Compute extentions to use, set to 0 if you are not using any extensions
    CMP_DWORD  height;                  // Height of the encoded texture.
    CMP_DWORD  width;                   // Width of the encoded texture.
    CMP_FLOAT  fquality;                // Set the quality used for encoders 0.05 is the lowest and 1.0 for highest.
    CMP_FORMAT format;                  // Encoder codec format to use for processing
    CMP_Compute_type encodeWith;        // Host Type : default is HPC, options are [HPC or GPU]
    CMP_INT    threads;                 // requested number of threads to use (1= single) max is 128 for HPC
    CMP_BOOL   getPerfStats;            // Set to true if you want to get Performance Stats
    KernelPerformanceStats  perfStats;  // Data storage for the performance stats obtained from GPU or CPU while running encoder processing
    CMP_BOOL   getDeviceInfo;           // Set to true if you want to get target Device Info
    KernelDeviceInfo deviceInfo;        // Data storage for the target device 

    //private: data settings: Do not use it will be removed from this interface!
    CMP_UINT   size;                    // Size of *data
    void *data;                         // Data to pass down from CPU to kernel
    void *dataSVM;                      // Data allocated as Shared by CPU and GPU (used only when code is running in 64bit and devices support SVM)
    char *srcfile;                      // Shader source file location
};


//======================================== Interfaces used in Compressonator Lib =====================================================
#ifndef CMP_MAKEFOURCC
#define CMP_MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
   ((CMP_DWORD)(CMP_BYTE)(ch0) | ((CMP_DWORD)(CMP_BYTE)(ch1) << 8) |   \
   ((CMP_DWORD)(CMP_BYTE)(ch2) << 16) | ((CMP_DWORD)(CMP_BYTE)(ch3) << 24 ))
#endif

#define MS_FLAG_Default                0x0000
#define MS_FLAG_AlphaPremult           0x0001
#define MS_FLAG_DisableMipMapping      0x0002
#define AMD_MAX_CMDS        20
#define AMD_MAX_CMD_STR     32
#define AMD_MAX_CMD_PARAM   16

typedef struct {
    CMP_CHAR strCommand[AMD_MAX_CMD_STR];
    CMP_CHAR strParameter[AMD_MAX_CMD_PARAM];
} AMD_CMD_SET;

/// An enum selecting the speed vs. quality trade-off.
typedef enum {
    CMP_Speed_Normal,     ///< Highest quality mode
    CMP_Speed_Fast,       ///< Slightly lower quality but much faster compression mode - DXTn & ATInN only
    CMP_Speed_SuperFast,  ///< Slightly lower quality but much, much faster compression mode - DXTn & ATInN only
} CMP_Speed;

/// An enum selecting the different GPU driver types.
typedef enum {
    GPUDecode_OPENGL = 0,  ///< Use OpenGL   to decode Textures (default)
    GPUDecode_DIRECTX,     ///< Use DirectX  to decode Textures
    GPUDecode_VULKAN,      ///< Use Vulkan  to decode Textures
    GPUDecode_INVALID
} CMP_GPUDecode;

// mesh optimization feature is only available on windows OS
#ifdef _WIN32
#define USE_3DMESH_OPTIMIZE                         // Mesh Optimize
#endif


// CMP_PrintInfo
// function for printing std out info to users.
typedef void (CMP_API* CMP_PrintInfoStr)(const char* InfoStr );


// User options and setting used for processing
typedef struct {
    CMP_DWORD dwSize;                // The size of this structure.
    CMP_BOOL  bUseChannelWeighting;  // Use channel weightings. With swizzled formats the weighting applies to the data within the specified channel not the channel itself.
                                     // channel weigthing is not implemented for BC6H and BC7
    CMP_FLOAT fWeightingRed;         //    The weighting of the Red or X Channel.
    CMP_FLOAT fWeightingGreen;       //    The weighting of the Green or Y Channel.
    CMP_FLOAT fWeightingBlue;        //    The weighting of the Blue or Z Channel.
    CMP_BOOL  bUseAdaptiveWeighting; //    Adapt weighting on a per-block basis.
    CMP_BOOL  bDXT1UseAlpha;         // Encode single-bit alpha data. Only valid when compressing to DXT1 & BC1.
    CMP_BOOL  bUseGPUDecompress;     // Use GPU to decompress. Decode API can be changed by specified in DecodeWith parameter. Default is OpenGL.
    CMP_BOOL  bUseCGCompress;        // Use SPMD/GPU to compress. Encode API can be changed by specified in EncodeWith parameter. Default is OpenCL.
    CMP_BYTE  nAlphaThreshold;       // The alpha threshold to use when compressing to DXT1 & BC1 with bDXT1UseAlpha. Texels with an alpha value less than the threshold are treated as transparent.
                                     // Note: When nCompressionSpeed is not set to Normal AphaThreshold is ignored for DXT1 & BC1
    CMP_BOOL  bDisableMultiThreading;// Disable multi-threading of the compression. This will slow the compression but can be useful if you're managing threads in your application.
                                     // if set BC7 dwnumThreads will default to 1 during encoding and then return back to its original value when done.
    CMP_Speed nCompressionSpeed;     // The trade-off between compression speed & quality.
                                     // Notes:
                                     // 1. This value is ignored for BC6H and BC7 (for BC7 the compression speed depends on fquaility value)
                                     // 2. For 64 bit DXT1 to DXT5 and BC1 to BC5 nCompressionSpeed is ignored and set to Noramal Speed
                                     // 3. To force the use of nCompressionSpeed setting regarless of Note 2 use fQuality at 0.05
    CMP_GPUDecode    nGPUDecode;     // This value is set using DecodeWith argument (OpenGL, DirectX) default is OpenGL
    CMP_Compute_type nEncodeWith;    // This value is set using EncodeWith argument, currently only OpenCL is used
    CMP_DWORD        dwnumThreads;   // Number of threads to initialize for BC7 encoding (Max up to 128). Default set to auto,
    CMP_FLOAT        fquality;       // Quality of encoding. This value ranges between 0.0 and 1.0. Default set to 0.05
                                     // setting fquality above 0.0 gives the fastest, lowest quality encoding, 1.0 is the slowest, highest quality encoding. Default set to a low value of 0.05
    CMP_BOOL brestrictColour;        // This setting is a quality tuning setting for BC7 which may be necessary for convenience in some applications. Default set to false
                                     // if  set and the block does not need alpha it instructs the code not to use modes that have combined colour + alpha - this
                                     // avoids the possibility that the encoder might choose an alpha other than 1.0 (due to parity) and cause something to
                                     // become accidentally slightly transparent (it's possible that when encoding 3-component texture applications will assume that
                                     // the 4th component can safely be assumed to be 1.0 all the time.)
    CMP_BOOL brestrictAlpha;         // This setting is a quality tuning setting for BC7 which may be necessary for some textures. Default set to false,
                                     // if set it will also apply restriction to blocks with alpha to avoid issues with punch-through or thresholded alpha encoding
    CMP_DWORD dwmodeMask;            // Mode to set BC7 to encode blocks using any of 8 different block modes in order to obtain the highest quality. Default set to 0xFF)
                                     // You can combine the bits to test for which modes produce the best image quality.
                                     // The mode that produces the best image quality above a set quality level (fquality) is used and subsequent modes set in the mask
                                     // are not tested, this optimizes the performance of the compression versus the required quality.
                                     // If you prefer to check all modes regardless of the quality then set the fquality to a value of 0
    int         NumCmds;             // Count of the number of command value pairs in CmdSet[].  Max value that can be set is AMD_MAX_CMDS = 20 on this release
    AMD_CMD_SET CmdSet[AMD_MAX_CMDS];// Extended command options that can be set for the specified codec\n
                                     // Example to set the number of threads and quality used for compression\n
                                     //        CMP_CompressOptions Options;\n
                                     //        memset(Options,0,sizeof(CMP_CompressOptions));\n
                                     //        Options.dwSize = sizeof(CMP_CompressOptions)\n
                                     //        Options.CmdSet[0].strCommand   = "NumThreads"\n
                                     //        Options.CmdSet[0].strParameter = "8";\n
                                     //        Options.CmdSet[1].strCommand   = "Quality"\n
                                     //        Options.CmdSet[1].strParameter = "1.0";\n
                                     //        Options.NumCmds = 2;\n
    CMP_FLOAT fInputDefog;           // ToneMap properties for float type image send into non float compress algorithm.
    CMP_FLOAT fInputExposure;        //
    CMP_FLOAT fInputKneeLow;         //
    CMP_FLOAT fInputKneeHigh;        //
    CMP_FLOAT fInputGamma;           //

    CMP_INT iCmpLevel;               //< draco setting: compression level (range 0-10: higher mean more compressed) - default 7
    CMP_INT iPosBits;                // quantization bits for position - default 14
    CMP_INT iTexCBits;               // quantization bits for texture coordinates - default 12
    CMP_INT iNormalBits;             // quantization bits for normal - default 10
    CMP_INT iGenericBits;            // quantization bits for generic - default 8

#ifdef USE_3DMESH_OPTIMIZE
    CMP_INT iVcacheSize;             // For mesh vertices optimization, hardware vertex cache size. (value range 1- no limit as it allows users to simulate hardware cache size to find the most optimum size)- default is enabled with cache size = 16
    CMP_INT iVcacheFIFOSize;         // For mesh vertices optimization, hardware vertex cache size. (value range 1- no limit as it allows users to simulate hardware cache size to find the most optimum size)- default is disabled.
    CMP_FLOAT   fOverdrawACMR;       // For mesh overdraw optimization,  optimize overdraw with ACMR (average cache miss ratio) threshold value specified (value range 1-3) - default is enabled with ACMR value = 1.05 (i.e. 5% worse)
    CMP_INT iSimplifyLOD;            // simplify mesh using LOD (Level of Details) value specified.(value range 1- no limit as it allows users to simplify the mesh until the level they desired. Higher level means less triangles drawn, less details.)
    bool bVertexFetch;               // optimize vertices fetch . boolean value 0 - disabled, 1-enabled. -default is enabled.
#endif

    CMP_FORMAT SourceFormat;
    CMP_FORMAT DestFormat;
    CMP_BOOL   format_support_hostEncoder;  // Temp setting used while encoding with gpu or hpc plugins

    // User Print Info interface 
    CMP_PrintInfoStr m_PrintInfoStr;

    // User Info for Performance Query on GPU or CPU Encoder Processing
    CMP_BOOL   getPerfStats;            // Set to true if you want to get Performance Stats
    KernelPerformanceStats  perfStats;  // Data storage for the performance stats obtained from GPU or CPU while running encoder processing
    CMP_BOOL   getDeviceInfo;           // Set to true if you want to get target device info
    KernelDeviceInfo deviceInfo;        // Data storage for the performance stats obtained from GPU or CPU while running encoder processing

} CMP_CompressOptions;

/// The format of data in the channels of texture.
typedef enum {
    CF_8bit             = 0,  // 8-bit integer data.
    CF_Float16          = 1,  // 16-bit float data.
    CF_Float32          = 2,  // 32-bit float data.
    CF_Compressed       = 3,  // Compressed data.
    CF_16bit            = 4,  // 16-bit integer data.
    CF_2101010          = 5,  // 10-bit integer data in the color channels & 2-bit integer data in the alpha channel.
    CF_32bit            = 6,  // 32-bit integer data.
    CF_Float9995E       = 7,  // 32-bit partial precision float.
    CF_YUV_420          = 8,  // YUV Chroma formats
    CF_YUV_422          = 9,  // YUV Chroma formats
    CF_YUV_444          = 10, // YUV Chroma formats
    CF_YUV_4444         = 11, // YUV Chroma formats
} CMP_ChannelFormat;

typedef CMP_ChannelFormat   ChannelFormat;

/// The type of data the texture represents.
typedef enum {
    TDT_XRGB        = 0,  // An RGB texture padded to DWORD width.
    TDT_ARGB        = 1,  // An ARGB texture.
    TDT_NORMAL_MAP  = 2,  // A normal map.
    TDT_R           = 3,  // A single component texture.
    TDT_RG          = 4,  // A two component texture.
    TDT_YUV_SD      = 5,  // An YUB Standard Definition texture.
    TDT_YUV_HD      = 6,  // An YUB High Definition texture.
} CMP_TextureDataType;

typedef CMP_TextureDataType TextureDataType;

/// The type of the texture.
typedef enum {
    TT_2D               = 0,  // A regular 2D texture. data stored linearly (rgba,rgba,...rgba)
    TT_CubeMap          = 1,  // A cubemap texture.
    TT_VolumeTexture    = 2,  // A volume texture.
    TT__2D_Block        = 3,  // 2D texture data stored as [Height][Width] blocks as individual channels using cmp_rgb_t or cmp_yuv_t
    TT_Unknown          = 4,  // Unknown type of texture : No data is stored for this type
} CMP_TextureType;

typedef CMP_TextureType TextureType;

typedef struct {
    union {
        CMP_BYTE  rgba[4];  ///< The color as an array of components.
        CMP_DWORD asDword;  ///< The color as a DWORD.
    };
} CMP_COLOR;

/// A MipLevel is the fundamental unit for containing texture data.
/// \remarks
/// One logical mip level can be composed of many MipLevels, see the documentation of MipSet for explanation.
/// \sa \link TC_AppAllocateMipLevelData() TC_AppAllocateMipLevelData \endlink,
/// \link TC_AppAllocateCompressedMipLevelData() TC_AppAllocateCompressedMipLevelData \endlink,
/// \link MipSet \endlink
typedef struct {
    CMP_INT         m_nWidth;         ///< Width of the data in pixels.
    CMP_INT         m_nHeight;        ///< Height of the data in pixels.
    CMP_DWORD       m_dwLinearSize;   ///< Size of the data in bytes.
    union {
        CMP_BYTE*       m_pbData;         ///< pointer unsigned 8  bit.data blocks
        CMP_WORD*       m_pwData;         ///< pointer unsigned 16 bit.data blocks
        CMP_COLOR*      m_pcData;         ///< pointer to a union (array of 4 unsigned 8 bits or one 32 bit) data blocks
        CMP_FLOAT*      m_pfData;         ///< pointer to 32-bit signed float data blocks
        CMP_HALFSHORT*  m_phfsData;       ///< pointer to 16 bit short  data blocks
        CMP_DWORD*      m_pdwData;        ///< pointer to 32 bit data blocks
        CMP_VEC8*       m_pvec8Data;      ///< std::vector unsigned 8 bits data blocks
    };
} CMP_MipLevel;

typedef CMP_MipLevel  MipLevel;

typedef CMP_MipLevel* CMP_MipLevelTable; ///< A pointer to a set of MipLevels.

// Each texture and all its mip-map levels are encapsulated in a MipSet.
// Do not depend on m_pMipLevelTable being there, it is an implementation detail that you see only because there is no easy cross-complier 
// way of passing data around in internal classes.
//
// For 2D textures there are m_nMipLevels MipLevels.
// Cube maps have multiple faces or sides for each mip-map level . Instead of making a totally new data type, we just made each one of these faces be represented by a MipLevel, even though the terminology can be a bit confusing at first. So if your cube map consists of 6 faces for each mip-map level, then your first mip-map level will consist of 6 MipLevels, each having the same m_nWidth, m_nHeight. The next mip-map level will have half the m_nWidth & m_nHeight as the previous, but will be composed of 6 MipLevels still.
// A volume texture is a 3D texture. Again, instead of creating a new data type, we chose to make use of multiple MipLevels to create a single mip-map level of a volume texture. So a single mip-map level of a volume texture will consist of many MipLevels, all having the same m_nWidth and m_nHeight. The next mip-map level will have m_nWidth and m_nHeight half of the previous mip-map level's (to a minimum of 1) and will be composed of half as many MipLevels as the previous mip-map level (the first mip-map level takes this number from the MipSet it's part of), to a minimum of one.

typedef struct {
    CMP_INT           m_nWidth;            // User Setting: Width in pixels of the topmost mip-map level of the mip-map set. Initialized by TC_AppAllocateMipSet.
    CMP_INT           m_nHeight;           // User Setting: Height in pixels of the topmost mip-map level of the mip-map set. Initialized by TC_AppAllocateMipSet.
    CMP_INT           m_nDepth;            // User Setting: Depth in MipLevels of the topmost mip-map level of the mip-map set. Initialized by TC_AppAllocateMipSet. See Remarks.
    CMP_FORMAT        m_format;            // User Setting: Format for this MipSet

    // set by various API for internal use and user ref
    ChannelFormat     m_ChannelFormat;     // A texture is usually composed of channels, such as RGB channels for a texture with red green and blue image data. m_ChannelFormat indicates the representation of each of these channels. So a texture where each channel is an 8 bit integer would have CF_8bit for this. A compressed texture would use CF_Compressed.
    TextureDataType   m_TextureDataType;   // An indication of the type of data that the texture contains. A texture with just RGB values would use TDT_XRGB, while a texture that also uses the alpha channel would use TDT_ARGB.
    TextureType       m_TextureType;       // Indicates whether the texture is 2D, a cube map, or a volume texture. Used to determine how to treat MipLevels, among other things.
    CMP_UINT          m_Flags;             // Flags that mip-map set.
    CMP_BYTE          m_CubeFaceMask;      // A mask of MS_CubeFace values indicating which cube-map faces are present.
    CMP_DWORD         m_dwFourCC;          // The FourCC for this mip-map set. 0 if the mip-map set is uncompressed. Generated using MAKEFOURCC (defined in the Platform SDK or DX SDK).
    CMP_DWORD         m_dwFourCC2;         // An extra FourCC used by The Compressonator internally. Our DDS plugin saves/loads m_dwFourCC2 from pDDSD ddpfPixelFormat.dwPrivateFormatBitCount (since it's not really used by anything else) whether or not it is 0. Generated using MAKEFOURCC (defined in the Platform SDK or DX SDK). The FourCC2 field is currently used to allow differentiation between the various swizzled DXT5 formats. These formats must have a FourCC of DXT5 to be supported by the DirectX runtime but The Compressonator needs to know the swizzled FourCC to correctly display the texture.
    CMP_INT           m_nMaxMipLevels;     // Set by The Compressonator when you call TC_AppAllocateMipSet based on the width, height, depth, and textureType values passed in. Is really the maximum number of mip-map levels possible for that texture including the topmost mip-map level if you integer divide width height and depth by 2, rounding down but never falling below 1 until all three of them are 1. So a 5x10 2D texture would have a m_nMaxMipLevels of 4 (5x10  2x5  1x2  1x1).
    CMP_INT           m_nMipLevels;        // The number of mip-map levels in the mip-map set that actually have data. Always less than or equal to m_nMaxMipLevels. Set to 0 after TC_AppAllocateMipSet.
    CMP_FORMAT        m_transcodeFormat;   // For universal format: Sets the target data format for data processing and analysis
    CMP_BOOL          m_compressed;        // New Flags if data is compressed (example Block Compressed data in form of BCxx)
    CMP_FORMAT        m_isDeCompressed;    // The New MipSet is a decompressed result from a prior Compressed MipSet Format specified
    CMP_BOOL          m_swizzle;           // Flag is used by image load and save to indicate channels were swizzled from the origial source
    CMP_BYTE          m_nBlockWidth;       // Width in pixels of the Compression Block that is to be processed default for ASTC is 4
    CMP_BYTE          m_nBlockHeight;      // Height in pixels of the Compression Block that is to be processed default for ASTC is 4
    CMP_BYTE          m_nBlockDepth;       // Depth in pixels of the Compression Block that is to be processed default for ASTC is 1

    // set by various API for internal use. These values change when processing MipLevels
    CMP_DWORD         dwWidth;             // set by various API for ref,Width of the current active miplevel. if toplevel mipmap then value is same as m_nWidth
    CMP_DWORD         dwHeight;            // set by various API for ref,Height of the current active miplevel. if toplevel mipmap then value is same as m_nHeight
    CMP_DWORD         dwDataSize;          // set by various API for ref,Size of the current active miplevel allocated texture data.
    CMP_BYTE*         pData;               // set by various API for ref,Pointer to the current active miplevel texture data: used in MipLevelTable

    // Structure to hold all mip levels buffers
    CMP_MipLevelTable* m_pMipLevelTable;   // set by various API for ref, This is an implementation dependent way of storing the MipLevels that this mip-map set contains. Do not depend on it, use TC_AppGetMipLevel to access a mip-map set's MipLevels.
    void*              m_pReservedData;    // Reserved for ArchitectMF ImageLoader

    // Reserved for internal data tracking
    CMP_INT            m_nIterations;
} CMP_MipSet;

typedef CMP_MipSet   MipSet;

// The structure describing a texture.
typedef struct {
    CMP_DWORD  dwSize;          // Size of this structure.
    CMP_DWORD  dwWidth;         // Width of the texture.
    CMP_DWORD  dwHeight;        // Height of the texture.
    CMP_DWORD  dwPitch;         // Distance to start of next line,
                                // necessary only for uncompressed textures.
    CMP_FORMAT format;          // Format of the texture.
    CMP_FORMAT transcodeFormat; // if the "format" is CMP_FORMAT_BASIS; A optional target
                                // format can be set here (default is BC1), 
                                // it can also be conditionally set runtime
    CMP_BYTE   nBlockHeight;    // if the source is a compressed format, 
                                // specify its block dimensions (Default nBlockHeight = 4).
    CMP_BYTE   nBlockWidth;     // (Default nBlockWidth = 4)
    CMP_BYTE   nBlockDepth;     // For ASTC this is the z setting. (Default nBlockDepth = 1)
    CMP_DWORD  dwDataSize;      // Size of the current pData texture data
    CMP_BYTE*  pData;           // Pointer to the texture data to process, this can be the
                                // image source or a specific MIP level
    CMP_VOID*  pMipSet;         // Pointer to a MipSet structure, typically used by Load Texture 
                                // and Save Texture. Users can access any MIP level or cube map 
                                // buffer using MIP Level access API and this pointer.
} CMP_Texture;


//==================================================
//API Definitions for Compressonator v3.1
//==================================================
// Number of image components
#define BC_COMPONENT_COUNT 4

// Number of bytes in a BC7 Block
#define BC_BLOCK_BYTES (4 * 4)

// Number of pixels in a BC7 block
#define BC_BLOCK_PIXELS BC_BLOCK_BYTES

// This defines the ordering in which components should be packed into
// the block for encoding
typedef enum _BC_COMPONENT {
    BC_COMP_RED   = 0,
    BC_COMP_GREEN = 1,
    BC_COMP_BLUE  = 2,
    BC_COMP_ALPHA = 3
} BC_COMPONENT;

typedef enum _BC_ERROR {
    BC_ERROR_NONE,
    BC_ERROR_LIBRARY_NOT_INITIALIZED,
    BC_ERROR_LIBRARY_ALREADY_INITIALIZED,
    BC_ERROR_INVALID_PARAMETERS,
    BC_ERROR_OUT_OF_MEMORY,
} BC_ERROR;

class BC7BlockEncoder;
class BC6HBlockEncoder;


#ifdef __cplusplus
extern "C"
{
#endif
extern CMP_INT CMP_MaxFacesOrSlices(const CMP_MipSet* pMipSet, CMP_INT nMipLevel);

//=================================================================================
//
// InitializeBCLibrary() - Startup the BC6H or BC7 library
//
// Must be called before any other library methods are valid
//
BC_ERROR CMP_API CMP_InitializeBCLibrary();

//
// ShutdownBCLibrary - Shutdown the BC6H or BC7 library
//
BC_ERROR CMP_API CMP_ShutdownBCLibrary();

typedef struct {
    CMP_WORD dwMask;          // User can enable or disable specific modes default is 0xFFFF
    float   fExposure;       // Sets the image lighter (using larger values) or darker (using lower values) default is 0.95
    bool     bIsSigned;       // Specify if half floats are signed or unsigned BC6H_UF16 or BC6H_SF16
    float   fQuality;        // Reserved: not used in BC6H at this time
    bool     bUsePatternRec;  // Reserved: for new algorithm to use mono pattern shape matching based on two pixel planes
} CMP_BC6H_BLOCK_PARAMETERS;

//
// CMP_CreateBC6HEncoder() - Creates an encoder object with the specified quality and settings for BC6H codec
// CMP_CreateBC7Encoder()  - Creates an encoder object with the specified quality and settings for BC7  codec
//
// Library must be initialized before calling this function.
//
// Arguments and Settings:
//
//      quality       - Quality of encoding. This value ranges between 0.0 and 1.0. (Valid only for BC7 in this release) default is 0.01
//                      0.0 gives the fastest, lowest quality encoding, 1.0 is the slowest, highest quality encoding
//                      In general even quality level 0.0 will give very good results on the vast majority of images
//                      Higher quality settings may be needed for some difficult images (e.g. normal maps) to give good results
//                      Encoding time will increase significantly at high quality levels. Quality levels around 0.8 will
//                      give very close to the highest possible quality, increasing the level above this will cause large
//                      increases in encoding time for very marginal gains in quality
//
//      performance   - Perfromance of encoding. This value ranges between 0.0 and 1.0. (Valid only for BC7 in this release) Typical default is 1.0
//                      Encoding time can be reduced by incresing this value for a given Quality level. Lower values will improve overall quality with
//                        optimal setting been performed at a value of 0.
//
//      restrictColor - (for BC7) This setting is a quality tuning setting which may be necessary for convenience in some applications.
//                      BC7 can be used for encoding data with up to four-components (e.g. ARGB), but the output of a BC7 decoder
//                        is effectively always 4-components, even if the original input contained less
//                      If BC7 is used to encode three-component data (e.g. RGB) then the encoder generally assumes that it doesn't matter what
//                      ends up in the 4th component of the data, however some applications might be written in such a way that they
//                      expect the 4th component to always be 1.0 (this might, for example, allow mixing of textures with and without
//                      alpha channels without special handling). In this example case the default behaviour of the encoder might cause some
//                      unexpected results, as the alpha channel is not guaranteed to always contain exactly 1.0 (since some error may be distributed
//                      into the 4th channel)
//                      If the restrictColor flag is set then for any input blocks where the 4th component is always 1.0 (255) the encoder will
//                      restrict itself to using encodings where the reconstructed 4th component is also always guaranteed to contain 1.0 (255)
//                      This may cause a very slight loss in overall quality measured in absolute RMS error, but this will generally be negligible
//
//      restrictAlpha - (for BC7) This setting is a quality tuning setting which may be necessary for some textures. Some textures may need alpha values
//                      of 1.0 and 0.0 to be exactly represented, but some BC7 block modes distribute error between the colour and alpha
//                      channels (because they have a shared least significant bit in the encoding). This could result in the alpha values
//                      being pulled away from zero or one by the global minimization of the error. If this flag is specified then the encoder
//                      will restrict its behaviour so that for blocks which contain an alpha of zero or one then these values should be
//                      precisely represented
//
//      modeMask      - This is an advanced option. (Valid only for BC7 in this release)
//                      BC7 can encode blocks using any of 8 different block modes in order to obtain the highest quality (for reference of how each
//                      of these block modes work consult the BC7 specification)
//                      Under some circumstances it is possible that it might be desired to manipulate the encoder to only produce certain modes
//                      Using this setting it is possible to instruct the encoder to only use certain block modes.
//                      This input is a bitmask of permitted modes for the encoder to use - for normal operation it should be set to 0xFF (all modes valid)
//                      The bitmask is arranged such that a setting of 0x1 only allows the encoder to use block mode 0.
//                      0x80 would only permit the use of block mode 7
//                      Restricting the available modes will generally reduce quality, but will also increase encoding speed
//
//      encoder       - Address of a pointer to an encoder.
//                      This function will allocate a BC7BlockEncoder or BC6HBlockEncoder object using new
//
//      isSigned      - For BC6H this flag sets the bit layout, false = UF16 (unsigned float) and true = SF16 (signed float)
//
// Note: For BC6H quality and modeMask are reserved for future release
//
BC_ERROR CMP_API CMP_CreateBC6HEncoder(CMP_BC6H_BLOCK_PARAMETERS user_settings, BC6HBlockEncoder** encoder);
BC_ERROR CMP_API CMP_CreateBC7Encoder(double quality, CMP_BOOL restrictColour, CMP_BOOL restrictAlpha, CMP_DWORD modeMask, double performance,
                                      BC7BlockEncoder** encoder);

// CMP_EncodeBC7Block()  - Enqueue a single BC7  block to the library for encoding
// CMP_EncodeBC6HBlock() - Enqueue a single BC6H block to the library for encoding
//
// For BC7:
// Input is expected to be a single 16 element block containing 4 components in the range 0.->255.
// Pixel data in the block should be arranged in row-major order
// For three-component input images the 4th component (BC7_COMP_ALPHA) should be set to 255 for
// all pixels to ensure optimal encoding
//
// For BC6H:
// Input is expected to be a single 16 element block containing 4 components in Half-Float format (16bit).
// Pixel data in the block should be arranged in row-major order.
// the 4th component should be set to 0, since Alpha is not supported in BC6H
//
BC_ERROR CMP_API CMP_EncodeBC7Block(BC7BlockEncoder* encoder, double in[BC_BLOCK_PIXELS][BC_COMPONENT_COUNT], CMP_BYTE* out);
BC_ERROR CMP_API CMP_EncodeBC6HBlock(BC6HBlockEncoder* encoder, CMP_FLOAT in[BC_BLOCK_PIXELS][BC_COMPONENT_COUNT], CMP_BYTE* out);

//
// CMP_DecodeBC6HBlock() - Decode a BC6H block to an uncompressed output
// CMP_DecodeBC7Block()  - Decode a BC7 block to an uncompressed output
//
// This function takes a pointer to an encoded BC block as input, decodes it and writes out the result
//
//
BC_ERROR CMP_API CMP_DecodeBC6HBlock(CMP_BYTE* in, CMP_FLOAT out[BC_BLOCK_PIXELS][BC_COMPONENT_COUNT]);
BC_ERROR CMP_API CMP_DecodeBC7Block(CMP_BYTE* in, double out[BC_BLOCK_PIXELS][BC_COMPONENT_COUNT]);

//
// CMP_DestroyBC6HEncoder() - Deletes a previously allocated encoder object
// CMP_DestroyBC7Encoder()  - Deletes a previously allocated encoder object
//
//
BC_ERROR CMP_API CMP_DestroyBC6HEncoder(BC6HBlockEncoder* encoder);
BC_ERROR CMP_API CMP_DestroyBC7Encoder(BC7BlockEncoder* encoder);

//=================================================================================

// CMP_Feedback_Proc
// Feedback function for conversion.
// \param[in] fProgress The percentage progress of the texture compression.
// \param[in] mipProgress The current MIP level been processed, value of fProgress = mipProgress
// \return non-NULL(true) value to abort conversion
typedef bool(CMP_API* CMP_Feedback_Proc)(CMP_FLOAT fProgress, CMP_DWORD_PTR pUser1, CMP_DWORD_PTR pUser2);


/// Calculates the required buffer size for the specified texture
/// \param[in] pTexture A pointer to the texture.
/// \return    The size of the buffer required to hold the texture data.
CMP_DWORD CMP_API CMP_CalculateBufferSize(const CMP_Texture* pTexture);

/// Converts the source texture to the destination texture
/// This can be compression, decompression or converting between two uncompressed formats.
/// \param[in] pSourceTexture A pointer to the source texture.
/// \param[in] pDestTexture A pointer to the destination texture.
/// \param[in] pOptions A pointer to the compression options - can be NULL.
/// \param[in] pFeedbackProc A pointer to the feedback function - can be NULL.
/// \return    CMP_OK if successful, otherwise the error code.

CMP_ERROR CMP_API CMP_ConvertTexture(CMP_Texture* pSourceTexture, CMP_Texture* pDestTexture, const CMP_CompressOptions* pOptions,
                                     CMP_Feedback_Proc pFeedbackProc);


#ifdef __cplusplus
};
#endif

//==================================================
// API Definitions for Compressonator v3.2 and higher
//===================================================

typedef struct {
    CMP_FLOAT   mipProgress; // The percentage progress of the current MIP level texture compression
    CMP_INT     mipLevel;    // returns the current MIP level been processed 0..max available for the image
    CMP_INT     cubeFace;    // returns the current Cube Face been processed 1..6
} CMP_MIPPROGRESSPARAM;

// The structure describing block encoder level settings.
typedef struct {
    unsigned int  width;   // Width of the encoded texture.
    unsigned int  height;  // Height of the encoded texture.
    unsigned int  pitch;   // Distance to start of next line..
    float         quality; // Set the quality used for encoders 0.05 is the lowest and 1.0 for highest.
    unsigned int  format;  // Format of the encoder to use: this is a enum set see compressonator.h CMP_FORMAT
} CMP_EncoderSetting;


#ifdef __cplusplus
extern "C"
{
#endif

    /// MIP MAP Interfaces
    CMP_INT CMP_API CMP_CalcMinMipSize(CMP_INT nHeight, CMP_INT nWidth, CMP_INT MipsLevel);
    CMP_INT CMP_API CMP_GenerateMIPLevels(CMP_MipSet *pMipSet, CMP_INT nMinSize);
    CMP_ERROR CMP_API CMP_CreateCompressMipSet(CMP_MipSet* pMipSetCMP, CMP_MipSet* pMipSetSRC);

    /// CMP_MIPFeedback_Proc
    /// Feedback function for conversion.
    /// \param[in] fProgress The percentage progress of the texture compression.
    /// \param[in] mipProgress The current MIP level been processed, value of fProgress = mipProgress
    /// \return non-NULL(true) value to abort conversion
    typedef bool(CMP_API* CMP_MIPFeedback_Proc)(CMP_MIPPROGRESSPARAM mipProgress);

    /// Converts the source texture to the destination texture using MipSets with MIP MAP Levels
    CMP_ERROR CMP_API CMP_ConvertMipTexture(CMP_MipSet* p_MipSetIn, CMP_MipSet* p_MipSetOut, const CMP_CompressOptions* pOptions, CMP_Feedback_Proc pFeedbackProc);


//--------------------------------------------
// CMP_Compute Lib: Texture Encoder Interfaces
//--------------------------------------------
CMP_ERROR  CMP_API CMP_LoadTexture(const char *sourceFile, CMP_MipSet *pMipSet);
CMP_ERROR  CMP_API CMP_SaveTexture(const char *destFile,   CMP_MipSet *pMipSet);
CMP_ERROR  CMP_API CMP_ProcessTexture(CMP_MipSet* srcMipSet, CMP_MipSet* dstMipSet, KernelOptions kernelOptions,  CMP_Feedback_Proc pFeedbackProc);
CMP_ERROR  CMP_API CMP_CompressTexture(KernelOptions *options,CMP_MipSet srcMipSet,CMP_MipSet dstMipSet,CMP_Feedback_Proc pFeedback);
CMP_VOID   CMP_API CMP_Format2FourCC(CMP_FORMAT format,   CMP_MipSet *pMipSet);
CMP_FORMAT CMP_API CMP_ParseFormat(char* pFormat);
CMP_INT    CMP_API CMP_NumberOfProcessors();
CMP_VOID   CMP_API CMP_FreeMipSet(CMP_MipSet *MipSetIn);
CMP_VOID   CMP_API CMP_GetMipLevel(CMP_MipLevel **data, const CMP_MipSet* pMipSet, CMP_INT nMipLevel, CMP_INT nFaceOrSlice);
CMP_ERROR  CMP_API CMP_GetPerformanceStats(KernelPerformanceStats* pPerfStats);
CMP_ERROR  CMP_API CMP_GetDeviceInfo(KernelDeviceInfo* pDeviceInfo);

//--------------------------------------------
// CMP_Compute Lib: Host level interface
//--------------------------------------------
CMP_ERROR CMP_API CMP_CreateComputeLibrary(CMP_MipSet *srcTexture, KernelOptions  *kernelOptions, void *Reserved);
CMP_ERROR CMP_API CMP_DestroyComputeLibrary(CMP_BOOL forceClose);
CMP_ERROR CMP_API CMP_SetComputeOptions(ComputeOptions *options);

//---------------------------------------------------------
// Generic API to access the core using CMP_EncoderSetting
//----------------------------------------------------------
CMP_ERROR CMP_API CMP_CreateBlockEncoder(void **blockEncoder, CMP_EncoderSetting encodeSettings);
CMP_ERROR CMP_API CMP_CompressBlock( void **block_encoder,void *SourceTexture, unsigned int sourceStride, void *DestTexture, unsigned int DestStride);
CMP_ERROR CMP_API CMP_CompressBlockXY(void  **blockEncoder,unsigned int blockx, unsigned int blocky, void *imgSrc, unsigned int sourceStride, void *cmpDst, unsigned int dstStride);
void      CMP_API CMP_DestroyBlockEncoder(void  **blockEncoder);

#ifdef __cplusplus
};
#endif

#endif  // ASPM_GPU

typedef bool (CMP_API * Codec_Feedback_Proc)(float fProgress, CMP_DWORD_PTR pUser1, CMP_DWORD_PTR pUser2);
#endif  // COMPRESSONATOR_H