// basisu_comp.h // Copyright (C) 2019-2021 Binomial LLC. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #pragma once #include "basisu_frontend.h" #include "basisu_backend.h" #include "basisu_basis_file.h" #include "../transcoder/basisu_transcoder.h" #include "basisu_uastc_enc.h" #define BASISU_LIB_VERSION … #define BASISU_LIB_VERSION_STRING … #ifndef BASISD_SUPPORT_KTX2 #error BASISD_SUPPORT_KTX2 is undefined #endif #ifndef BASISD_SUPPORT_KTX2_ZSTD #error BASISD_SUPPORT_KTX2_ZSTD is undefined #endif #if !BASISD_SUPPORT_KTX2 #error BASISD_SUPPORT_KTX2 must be enabled when building the encoder. To reduce code size if KTX2 support is not needed, set BASISD_SUPPORT_KTX2_ZSTD to 0 #endif namespace basisu { struct opencl_context; opencl_context_ptr; const uint32_t BASISU_MAX_SUPPORTED_TEXTURE_DIMENSION = …; // Allow block's color distance to increase by 1.5 while searching for an alternative nearby endpoint. const float BASISU_DEFAULT_ENDPOINT_RDO_THRESH = …; // Allow block's color distance to increase by 1.25 while searching the selector history buffer for a close enough match. const float BASISU_DEFAULT_SELECTOR_RDO_THRESH = …; const int BASISU_DEFAULT_QUALITY = …; const float BASISU_DEFAULT_HYBRID_SEL_CB_QUALITY_THRESH = …; const uint32_t BASISU_MAX_IMAGE_DIMENSION = …; const uint32_t BASISU_QUALITY_MIN = …; const uint32_t BASISU_QUALITY_MAX = …; const uint32_t BASISU_MAX_ENDPOINT_CLUSTERS = …; const uint32_t BASISU_MAX_SELECTOR_CLUSTERS = …; const uint32_t BASISU_MAX_SLICES = …; const int BASISU_RDO_UASTC_DICT_SIZE_DEFAULT = …; // 32768; const int BASISU_RDO_UASTC_DICT_SIZE_MIN = …; const int BASISU_RDO_UASTC_DICT_SIZE_MAX = …; struct image_stats { … }; template<bool def> struct bool_param { … }; template<typename T> struct param { … }; struct basis_compressor_params { … }; // Important: basisu_encoder_init() MUST be called first before using this class. class basis_compressor { … }; // Alternative simple C-style wrapper API around the basis_compressor class. // This doesn't expose every encoder feature, but it's enough to get going. // Important: basisu_encoder_init() MUST be called first before calling these functions. // // Input parameters: // source_images: Array of "image" objects, one per mipmap level, largest mipmap level first. // OR // pImageRGBA: pointer to a 32-bpp RGBx or RGBA raster image, R first in memory, A last. Top scanline first in memory. // width/height/pitch_in_pixels: dimensions of pImageRGBA // // flags_and_quality: Combination of the above flags logically OR'd with the ETC1S or UASTC level, i.e. "cFlagSRGB | cFlagGenMipsClamp | cFlagThreaded | 128" or "cFlagSRGB | cFlagGenMipsClamp | cFlagUASTC | cFlagThreaded | cPackUASTCLevelDefault". // In ETC1S mode, the lower 8-bits are the ETC1S quality level which ranges from [1,255] (higher=better quality/larger files) // In UASTC mode, the lower 8-bits are the UASTC pack level (see cPackUASTCLevelFastest, etc.). Fastest/lowest quality is 0, so be sure to set it correctly. // // uastc_rdo_quality: Float UASTC RDO quality level (0=no change, higher values lower quality but increase compressibility, initially try .5-1.5) // // pSize: Returns the output data's compressed size in bytes // // Return value is the compressed .basis or .ktx2 file data, or nullptr on failure. Must call basis_free() to free it. enum { … }; // This function accepts an array of source images. // If more than one image is provided, it's assumed the images form a mipmap pyramid and automatic mipmap generation is disabled. // Returns a pointer to the compressed .basis or .ktx2 file data. *pSize is the size of the compressed data. The returned block must be freed using basis_free_data(). // basisu_encoder_init() MUST be called first! void* basis_compress( const basisu::vector<image> &source_images, uint32_t flags_and_quality, float uastc_rdo_quality, size_t* pSize, image_stats* pStats = nullptr); // This function only accepts a single source image. void* basis_compress( const uint8_t* pImageRGBA, uint32_t width, uint32_t height, uint32_t pitch_in_pixels, uint32_t flags_and_quality, float uastc_rdo_quality, size_t* pSize, image_stats* pStats = nullptr); // Frees the dynamically allocated file data returned by basis_compress(). void basis_free_data(void* p); // Runs a short benchmark using synthetic image data to time OpenCL encoding vs. CPU encoding, with multithreading enabled. // Returns true if opencl is worth using on this system, otherwise false. // If pOpenCL_failed is not null, it will be set to true if OpenCL encoding failed *on this particular machine/driver/BasisU version* and the encoder falled back to CPU encoding. // basisu_encoder_init() MUST be called first. If OpenCL support wasn't enabled this always returns false. bool basis_benchmark_etc1s_opencl(bool *pOpenCL_failed = nullptr); // Parallel compression API struct parallel_results { … }; // Compresses an array of input textures across total_threads threads using the basis_compressor class. // Compressing multiple textures at a time is substantially more efficient than just compressing one at a time. // total_threads must be >= 1. bool basis_parallel_compress( uint32_t total_threads, const basisu::vector<basis_compressor_params> ¶ms_vec, basisu::vector< parallel_results > &results_vec); } // namespace basisu